diff --git a/mingw/include/jpegtcl.h b/mingw/include/jpegtcl.h new file mode 100644 index 00000000..d9591833 --- /dev/null +++ b/mingw/include/jpegtcl.h @@ -0,0 +1,158 @@ +/* + * jpegtcl.h -- + * + * Interface to libjpeg. + * + * Copyright (c) 2002 Andreas Kupries + * + * Zveno Pty Ltd makes this software and associated documentation + * available free of charge for any purpose. You may make copies + * of the software but you must include all of this notice on any copy. + * + * Zveno Pty Ltd does not warrant that this software is error free + * or fit for any purpose. Zveno Pty Ltd disclaims any liability for + * all claims, expenses, losses, damages and costs any user may incur + * as a result of using, copying or modifying the software. + * + * $Id: jpegtcl.h,v 1.3 2004/06/03 21:54:43 andreas_kupries Exp $ + * + */ + +#ifndef __JPEGTCL_H__ +#define __JPEGTCL_H__ + +#include +#include "tcl.h" + +#define JPEGTCL_MAJOR_VERSION 1 +#define JPEGTCL_MINOR_VERSION 0 +#define JPEGTCL_RELEASE_LEVEL TCL_RELEASE +#define JPEGTCL_RELEASE_SERIAL 0 + +#define JPEGTCL_VERSION "1.0" +#define JPEGTCL_PATCH_LEVEL "1.0" + +/* + * Used to block the rest of this header file from resource compilers so + * we can just get the version info. + */ +#ifndef RC_INVOKED + +/* TIP 27 update. If CONST84 is not defined we are compiling against a + * core before 8.4 and have to disable some CONST'ness. + */ + +#ifndef CONST84 +# define CONST84 +#endif + +/* + * Fix the Borland bug that's in the EXTERN macro from tcl.h. + */ +#ifndef TCL_EXTERN +# undef DLLIMPORT +# undef DLLEXPORT +# if defined(STATIC_BUILD) +# define DLLIMPORT +# define DLLEXPORT +# elif (defined(__WIN32__) && (defined(_MSC_VER) || (__BORLANDC__ >= 0x0550) || (defined(__GNUC__) && defined(__declspec)))) || (defined(MAC_TCL) && FUNCTION_DECLSPEC) +# define DLLIMPORT __declspec(dllimport) +# define DLLEXPORT __declspec(dllexport) +# elif defined(__BORLANDC__) +# define OLDBORLAND 1 +# define DLLIMPORT __import +# define DLLEXPORT __export +# else +# define DLLIMPORT +# define DLLEXPORT +# endif + /* Avoid name mangling from C++ compilers. */ +# ifdef __cplusplus +# define TCL_EXTRNC extern "C" +# else +# define TCL_EXTRNC extern +# endif + /* Pre-5.5 Borland requires the attributes be placed after the */ + /* return type. */ +# ifdef OLDBORLAND +# define TCL_EXTERN(RTYPE) TCL_EXTRNC RTYPE TCL_STORAGE_CLASS +# else +# define TCL_EXTERN(RTYPE) TCL_EXTRNC TCL_STORAGE_CLASS RTYPE +# endif +#endif + + + +/* + * These macros are used to control whether functions are being declared for + * import or export in Windows, + * They map to no-op declarations on non-Windows systems. + * Assumes that tcl.h defines DLLEXPORT & DLLIMPORT correctly. + * The default build on windows is for a DLL, which causes the DLLIMPORT + * and DLLEXPORT macros to be nonempty. To build a static library, the + * macro STATIC_BUILD should be defined before the inclusion of tcl.h + * + * If a function is being declared while it is being built + * to be included in a shared library, then it should have the DLLEXPORT + * storage class. If is being declared for use by a module that is going to + * link against the shared library, then it should have the DLLIMPORT storage + * class. If the symbol is beind declared for a static build or for use from a + * stub library, then the storage class should be empty. + * + * The convention is that a macro called BUILD_xxxx, where xxxx is the + * name of a library we are building, is set on the compile line for sources + * that are to be placed in the library. When this macro is set, the + * storage class will be set to DLLEXPORT. At the end of the header file, the + * storage class will be reset to DLLIMPORt. + */ + +#undef TCL_STORAGE_CLASS +#ifdef BUILD_jpegtcl +# define TCL_STORAGE_CLASS DLLEXPORT +#else +# ifdef USE_JPEGTCL_STUBS +# define TCL_STORAGE_CLASS +# else +# define TCL_STORAGE_CLASS DLLIMPORT +# endif +#endif + +/* + *---------------------------------------------------------------------------- + * C API for Jpegtcl generic layer + *---------------------------------------------------------------------------- + */ + +/* + *---------------------------------------------------------------------------- + * Function prototypes for publically accessible routines + *---------------------------------------------------------------------------- + */ + +#include "jpegtclDecls.h" + +/* + *---------------------------------------------------------------------------- + * Function prototypes for stub initialization. + *---------------------------------------------------------------------------- + */ + +#ifdef USE_JPEGTCL_STUBS +EXTERN CONST char * +Jpegtcl_InitStubs _ANSI_ARGS_((Tcl_Interp *interp, CONST char *version, int exact)); +#else + +/* + * When not using stubs, make it a macro. + */ + +#define Jpegtcl_InitStubs(interp, version, exact) \ + Tcl_PkgRequire(interp, "jpegtcl", version, exact) +#endif + + +#undef TCL_STORAGE_CLASS +#define TCL_STORAGE_CLASS DLLIMPORT + +#endif /* RC_INVOKED */ +#endif /* __JPEGTCL_H__ */ diff --git a/mingw/include/jpegtclDecls.h b/mingw/include/jpegtclDecls.h new file mode 100644 index 00000000..cf7d5e81 --- /dev/null +++ b/mingw/include/jpegtclDecls.h @@ -0,0 +1,468 @@ +/* + * jpegtclDecls.h -- + * + * Declarations of functions in the platform independent public JPEGTCL API. + * + */ + +#ifndef _JPEGTCLDECLS +#define _JPEGTCLDECLS + +/* + * WARNING: The contents of this file is automatically generated by the + * genStubs.tcl script. Any modifications to the function declarations + * below should be made in the jpegtcl.decls script. + */ + +#include + +/* undef Tcl macros that conflict with libjpeg stuff (sigh) */ +#undef EXTERN + +#include +#include <../jpeglib.h> +#include <../jerror.h> +#include + +/* + * And recreate the definition of "tcl.h", we need it below. + */ + +#undef EXTERN +#ifdef __cplusplus +# define EXTERN extern "C" TCL_STORAGE_CLASS +#else +# define EXTERN extern TCL_STORAGE_CLASS +#endif + + +/* !BEGIN!: Do not edit below this line. */ + +/* + * Exported function declarations: + */ + +/* 0 */ +EXTERN struct jpeg_error_mgr * jpeg_std_error _ANSI_ARGS_(( + struct jpeg_error_mgr * err)); +/* 1 */ +EXTERN void jpeg_CreateCompress _ANSI_ARGS_(( + j_compress_ptr cinfo, int version, + size_t structsize)); +/* 2 */ +EXTERN void jpeg_CreateDecompress _ANSI_ARGS_(( + j_decompress_ptr cinfo, int version, + size_t structsize)); +/* 3 */ +EXTERN void jpeg_destroy_compress _ANSI_ARGS_(( + j_compress_ptr cinfo)); +/* 4 */ +EXTERN void jpeg_destroy_decompress _ANSI_ARGS_(( + j_decompress_ptr cinfo)); +/* 5 */ +EXTERN void jpeg_stdio_dest _ANSI_ARGS_((j_compress_ptr cinfo, + FILE * outfile)); +/* 6 */ +EXTERN void jpeg_stdio_src _ANSI_ARGS_((j_decompress_ptr cinfo, + FILE * infile)); +/* 7 */ +EXTERN void jpeg_set_defaults _ANSI_ARGS_((j_compress_ptr cinfo)); +/* 8 */ +EXTERN void jpeg_set_colorspace _ANSI_ARGS_(( + j_compress_ptr cinfo, + J_COLOR_SPACE colorspace)); +/* 9 */ +EXTERN void jpeg_default_colorspace _ANSI_ARGS_(( + j_compress_ptr cinfo)); +/* 10 */ +EXTERN void jpeg_set_quality _ANSI_ARGS_((j_compress_ptr cinfo, + int quality, boolean force_baseline)); +/* 11 */ +EXTERN void jpeg_set_linear_quality _ANSI_ARGS_(( + j_compress_ptr cinfo, int scale_factor, + boolean force_baseline)); +/* 12 */ +EXTERN void jpeg_add_quant_table _ANSI_ARGS_(( + j_compress_ptr cinfo, int which_tbl, + const unsigned int * basic_table, + int scale_factor, boolean force_baseline)); +/* 13 */ +EXTERN int jpeg_quality_scaling _ANSI_ARGS_((int quality)); +/* 14 */ +EXTERN void jpeg_simple_progression _ANSI_ARGS_(( + j_compress_ptr cinfo)); +/* 15 */ +EXTERN void jpeg_suppress_tables _ANSI_ARGS_(( + j_compress_ptr cinfo, boolean suppress)); +/* 16 */ +EXTERN JQUANT_TBL * jpeg_alloc_quant_table _ANSI_ARGS_(( + j_common_ptr cinfo)); +/* 17 */ +EXTERN JHUFF_TBL * jpeg_alloc_huff_table _ANSI_ARGS_(( + j_common_ptr cinfo)); +/* 18 */ +EXTERN void jpeg_start_compress _ANSI_ARGS_(( + j_compress_ptr cinfo, + boolean write_all_tables)); +/* 19 */ +EXTERN JDIMENSION jpeg_write_scanlines _ANSI_ARGS_(( + j_compress_ptr cinfo, JSAMPARRAY scanlines, + JDIMENSION num_lines)); +/* 20 */ +EXTERN void jpeg_finish_compress _ANSI_ARGS_(( + j_compress_ptr cinfo)); +/* 21 */ +EXTERN JDIMENSION jpeg_write_raw_data _ANSI_ARGS_(( + j_compress_ptr cinfo, JSAMPIMAGE data, + JDIMENSION num_lines)); +/* 22 */ +EXTERN void jpeg_write_marker _ANSI_ARGS_((j_compress_ptr cinfo, + int marker, const JOCTET * dataptr, + unsigned int datalen)); +/* 23 */ +EXTERN void jpeg_write_m_header _ANSI_ARGS_(( + j_compress_ptr cinfo, int marker, + unsigned int datalen)); +/* 24 */ +EXTERN void jpeg_write_m_byte _ANSI_ARGS_((j_compress_ptr cinfo, + int val)); +/* 25 */ +EXTERN void jpeg_write_tables _ANSI_ARGS_((j_compress_ptr cinfo)); +/* 26 */ +EXTERN int jpeg_read_header _ANSI_ARGS_((j_decompress_ptr cinfo, + boolean require_image)); +/* 27 */ +EXTERN boolean jpeg_start_decompress _ANSI_ARGS_(( + j_decompress_ptr cinfo)); +/* 28 */ +EXTERN JDIMENSION jpeg_read_scanlines _ANSI_ARGS_(( + j_decompress_ptr cinfo, JSAMPARRAY scanlines, + JDIMENSION max_lines)); +/* 29 */ +EXTERN boolean jpeg_finish_decompress _ANSI_ARGS_(( + j_decompress_ptr cinfo)); +/* 30 */ +EXTERN JDIMENSION jpeg_read_raw_data _ANSI_ARGS_(( + j_decompress_ptr cinfo, JSAMPIMAGE data, + JDIMENSION max_lines)); +/* 31 */ +EXTERN boolean jpeg_has_multiple_scans _ANSI_ARGS_(( + j_decompress_ptr cinfo)); +/* 32 */ +EXTERN boolean jpeg_start_output _ANSI_ARGS_(( + j_decompress_ptr cinfo, int scan_number)); +/* 33 */ +EXTERN boolean jpeg_finish_output _ANSI_ARGS_(( + j_decompress_ptr cinfo)); +/* 34 */ +EXTERN boolean jpeg_input_complete _ANSI_ARGS_(( + j_decompress_ptr cinfo)); +/* 35 */ +EXTERN void jpeg_new_colormap _ANSI_ARGS_(( + j_decompress_ptr cinfo)); +/* 36 */ +EXTERN int jpeg_consume_input _ANSI_ARGS_(( + j_decompress_ptr cinfo)); +/* 37 */ +EXTERN void jpeg_calc_output_dimensions _ANSI_ARGS_(( + j_decompress_ptr cinfo)); +/* 38 */ +EXTERN void jpeg_save_markers _ANSI_ARGS_(( + j_decompress_ptr cinfo, int marker_code, + unsigned int length_limit)); +/* 39 */ +EXTERN void jpeg_set_marker_processor _ANSI_ARGS_(( + j_decompress_ptr cinfo, int marker_code, + jpeg_marker_parser_method routine)); +/* 40 */ +EXTERN jvirt_barray_ptr * jpeg_read_coefficients _ANSI_ARGS_(( + j_decompress_ptr cinfo)); +/* 41 */ +EXTERN void jpeg_write_coefficients _ANSI_ARGS_(( + j_compress_ptr cinfo, + jvirt_barray_ptr * coef_arrays)); +/* 42 */ +EXTERN void jpeg_copy_critical_parameters _ANSI_ARGS_(( + j_decompress_ptr srcinfo, + j_compress_ptr dstinfo)); +/* 43 */ +EXTERN void jpeg_abort_compress _ANSI_ARGS_(( + j_compress_ptr cinfo)); +/* 44 */ +EXTERN void jpeg_abort_decompress _ANSI_ARGS_(( + j_decompress_ptr cinfo)); +/* 45 */ +EXTERN void jpeg_abort _ANSI_ARGS_((j_common_ptr cinfo)); +/* 46 */ +EXTERN void jpeg_destroy _ANSI_ARGS_((j_common_ptr cinfo)); +/* 47 */ +EXTERN boolean jpeg_resync_to_restart _ANSI_ARGS_(( + j_decompress_ptr cinfo, int desired)); + +typedef struct JpegtclStubs { + int magic; + struct JpegtclStubHooks *hooks; + + struct jpeg_error_mgr * (*jpeg_std_error) _ANSI_ARGS_((struct jpeg_error_mgr * err)); /* 0 */ + void (*jpeg_CreateCompress) _ANSI_ARGS_((j_compress_ptr cinfo, int version, size_t structsize)); /* 1 */ + void (*jpeg_CreateDecompress) _ANSI_ARGS_((j_decompress_ptr cinfo, int version, size_t structsize)); /* 2 */ + void (*jpeg_destroy_compress) _ANSI_ARGS_((j_compress_ptr cinfo)); /* 3 */ + void (*jpeg_destroy_decompress) _ANSI_ARGS_((j_decompress_ptr cinfo)); /* 4 */ + void (*jpeg_stdio_dest) _ANSI_ARGS_((j_compress_ptr cinfo, FILE * outfile)); /* 5 */ + void (*jpeg_stdio_src) _ANSI_ARGS_((j_decompress_ptr cinfo, FILE * infile)); /* 6 */ + void (*jpeg_set_defaults) _ANSI_ARGS_((j_compress_ptr cinfo)); /* 7 */ + void (*jpeg_set_colorspace) _ANSI_ARGS_((j_compress_ptr cinfo, J_COLOR_SPACE colorspace)); /* 8 */ + void (*jpeg_default_colorspace) _ANSI_ARGS_((j_compress_ptr cinfo)); /* 9 */ + void (*jpeg_set_quality) _ANSI_ARGS_((j_compress_ptr cinfo, int quality, boolean force_baseline)); /* 10 */ + void (*jpeg_set_linear_quality) _ANSI_ARGS_((j_compress_ptr cinfo, int scale_factor, boolean force_baseline)); /* 11 */ + void (*jpeg_add_quant_table) _ANSI_ARGS_((j_compress_ptr cinfo, int which_tbl, const unsigned int * basic_table, int scale_factor, boolean force_baseline)); /* 12 */ + int (*jpeg_quality_scaling) _ANSI_ARGS_((int quality)); /* 13 */ + void (*jpeg_simple_progression) _ANSI_ARGS_((j_compress_ptr cinfo)); /* 14 */ + void (*jpeg_suppress_tables) _ANSI_ARGS_((j_compress_ptr cinfo, boolean suppress)); /* 15 */ + JQUANT_TBL * (*jpeg_alloc_quant_table) _ANSI_ARGS_((j_common_ptr cinfo)); /* 16 */ + JHUFF_TBL * (*jpeg_alloc_huff_table) _ANSI_ARGS_((j_common_ptr cinfo)); /* 17 */ + void (*jpeg_start_compress) _ANSI_ARGS_((j_compress_ptr cinfo, boolean write_all_tables)); /* 18 */ + JDIMENSION (*jpeg_write_scanlines) _ANSI_ARGS_((j_compress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION num_lines)); /* 19 */ + void (*jpeg_finish_compress) _ANSI_ARGS_((j_compress_ptr cinfo)); /* 20 */ + JDIMENSION (*jpeg_write_raw_data) _ANSI_ARGS_((j_compress_ptr cinfo, JSAMPIMAGE data, JDIMENSION num_lines)); /* 21 */ + void (*jpeg_write_marker) _ANSI_ARGS_((j_compress_ptr cinfo, int marker, const JOCTET * dataptr, unsigned int datalen)); /* 22 */ + void (*jpeg_write_m_header) _ANSI_ARGS_((j_compress_ptr cinfo, int marker, unsigned int datalen)); /* 23 */ + void (*jpeg_write_m_byte) _ANSI_ARGS_((j_compress_ptr cinfo, int val)); /* 24 */ + void (*jpeg_write_tables) _ANSI_ARGS_((j_compress_ptr cinfo)); /* 25 */ + int (*jpeg_read_header) _ANSI_ARGS_((j_decompress_ptr cinfo, boolean require_image)); /* 26 */ + boolean (*jpeg_start_decompress) _ANSI_ARGS_((j_decompress_ptr cinfo)); /* 27 */ + JDIMENSION (*jpeg_read_scanlines) _ANSI_ARGS_((j_decompress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION max_lines)); /* 28 */ + boolean (*jpeg_finish_decompress) _ANSI_ARGS_((j_decompress_ptr cinfo)); /* 29 */ + JDIMENSION (*jpeg_read_raw_data) _ANSI_ARGS_((j_decompress_ptr cinfo, JSAMPIMAGE data, JDIMENSION max_lines)); /* 30 */ + boolean (*jpeg_has_multiple_scans) _ANSI_ARGS_((j_decompress_ptr cinfo)); /* 31 */ + boolean (*jpeg_start_output) _ANSI_ARGS_((j_decompress_ptr cinfo, int scan_number)); /* 32 */ + boolean (*jpeg_finish_output) _ANSI_ARGS_((j_decompress_ptr cinfo)); /* 33 */ + boolean (*jpeg_input_complete) _ANSI_ARGS_((j_decompress_ptr cinfo)); /* 34 */ + void (*jpeg_new_colormap) _ANSI_ARGS_((j_decompress_ptr cinfo)); /* 35 */ + int (*jpeg_consume_input) _ANSI_ARGS_((j_decompress_ptr cinfo)); /* 36 */ + void (*jpeg_calc_output_dimensions) _ANSI_ARGS_((j_decompress_ptr cinfo)); /* 37 */ + void (*jpeg_save_markers) _ANSI_ARGS_((j_decompress_ptr cinfo, int marker_code, unsigned int length_limit)); /* 38 */ + void (*jpeg_set_marker_processor) _ANSI_ARGS_((j_decompress_ptr cinfo, int marker_code, jpeg_marker_parser_method routine)); /* 39 */ + jvirt_barray_ptr * (*jpeg_read_coefficients) _ANSI_ARGS_((j_decompress_ptr cinfo)); /* 40 */ + void (*jpeg_write_coefficients) _ANSI_ARGS_((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)); /* 41 */ + void (*jpeg_copy_critical_parameters) _ANSI_ARGS_((j_decompress_ptr srcinfo, j_compress_ptr dstinfo)); /* 42 */ + void (*jpeg_abort_compress) _ANSI_ARGS_((j_compress_ptr cinfo)); /* 43 */ + void (*jpeg_abort_decompress) _ANSI_ARGS_((j_decompress_ptr cinfo)); /* 44 */ + void (*jpeg_abort) _ANSI_ARGS_((j_common_ptr cinfo)); /* 45 */ + void (*jpeg_destroy) _ANSI_ARGS_((j_common_ptr cinfo)); /* 46 */ + boolean (*jpeg_resync_to_restart) _ANSI_ARGS_((j_decompress_ptr cinfo, int desired)); /* 47 */ +} JpegtclStubs; + +#ifdef __cplusplus +extern "C" { +#endif +extern JpegtclStubs *jpegtclStubsPtr; +#ifdef __cplusplus +} +#endif + +#if defined(USE_JPEGTCL_STUBS) && !defined(USE_JPEGTCL_STUB_PROCS) + +/* + * Inline function declarations: + */ + +#ifndef jpeg_std_error +#define jpeg_std_error \ + (jpegtclStubsPtr->jpeg_std_error) /* 0 */ +#endif +#ifndef jpeg_CreateCompress +#define jpeg_CreateCompress \ + (jpegtclStubsPtr->jpeg_CreateCompress) /* 1 */ +#endif +#ifndef jpeg_CreateDecompress +#define jpeg_CreateDecompress \ + (jpegtclStubsPtr->jpeg_CreateDecompress) /* 2 */ +#endif +#ifndef jpeg_destroy_compress +#define jpeg_destroy_compress \ + (jpegtclStubsPtr->jpeg_destroy_compress) /* 3 */ +#endif +#ifndef jpeg_destroy_decompress +#define jpeg_destroy_decompress \ + (jpegtclStubsPtr->jpeg_destroy_decompress) /* 4 */ +#endif +#ifndef jpeg_stdio_dest +#define jpeg_stdio_dest \ + (jpegtclStubsPtr->jpeg_stdio_dest) /* 5 */ +#endif +#ifndef jpeg_stdio_src +#define jpeg_stdio_src \ + (jpegtclStubsPtr->jpeg_stdio_src) /* 6 */ +#endif +#ifndef jpeg_set_defaults +#define jpeg_set_defaults \ + (jpegtclStubsPtr->jpeg_set_defaults) /* 7 */ +#endif +#ifndef jpeg_set_colorspace +#define jpeg_set_colorspace \ + (jpegtclStubsPtr->jpeg_set_colorspace) /* 8 */ +#endif +#ifndef jpeg_default_colorspace +#define jpeg_default_colorspace \ + (jpegtclStubsPtr->jpeg_default_colorspace) /* 9 */ +#endif +#ifndef jpeg_set_quality +#define jpeg_set_quality \ + (jpegtclStubsPtr->jpeg_set_quality) /* 10 */ +#endif +#ifndef jpeg_set_linear_quality +#define jpeg_set_linear_quality \ + (jpegtclStubsPtr->jpeg_set_linear_quality) /* 11 */ +#endif +#ifndef jpeg_add_quant_table +#define jpeg_add_quant_table \ + (jpegtclStubsPtr->jpeg_add_quant_table) /* 12 */ +#endif +#ifndef jpeg_quality_scaling +#define jpeg_quality_scaling \ + (jpegtclStubsPtr->jpeg_quality_scaling) /* 13 */ +#endif +#ifndef jpeg_simple_progression +#define jpeg_simple_progression \ + (jpegtclStubsPtr->jpeg_simple_progression) /* 14 */ +#endif +#ifndef jpeg_suppress_tables +#define jpeg_suppress_tables \ + (jpegtclStubsPtr->jpeg_suppress_tables) /* 15 */ +#endif +#ifndef jpeg_alloc_quant_table +#define jpeg_alloc_quant_table \ + (jpegtclStubsPtr->jpeg_alloc_quant_table) /* 16 */ +#endif +#ifndef jpeg_alloc_huff_table +#define jpeg_alloc_huff_table \ + (jpegtclStubsPtr->jpeg_alloc_huff_table) /* 17 */ +#endif +#ifndef jpeg_start_compress +#define jpeg_start_compress \ + (jpegtclStubsPtr->jpeg_start_compress) /* 18 */ +#endif +#ifndef jpeg_write_scanlines +#define jpeg_write_scanlines \ + (jpegtclStubsPtr->jpeg_write_scanlines) /* 19 */ +#endif +#ifndef jpeg_finish_compress +#define jpeg_finish_compress \ + (jpegtclStubsPtr->jpeg_finish_compress) /* 20 */ +#endif +#ifndef jpeg_write_raw_data +#define jpeg_write_raw_data \ + (jpegtclStubsPtr->jpeg_write_raw_data) /* 21 */ +#endif +#ifndef jpeg_write_marker +#define jpeg_write_marker \ + (jpegtclStubsPtr->jpeg_write_marker) /* 22 */ +#endif +#ifndef jpeg_write_m_header +#define jpeg_write_m_header \ + (jpegtclStubsPtr->jpeg_write_m_header) /* 23 */ +#endif +#ifndef jpeg_write_m_byte +#define jpeg_write_m_byte \ + (jpegtclStubsPtr->jpeg_write_m_byte) /* 24 */ +#endif +#ifndef jpeg_write_tables +#define jpeg_write_tables \ + (jpegtclStubsPtr->jpeg_write_tables) /* 25 */ +#endif +#ifndef jpeg_read_header +#define jpeg_read_header \ + (jpegtclStubsPtr->jpeg_read_header) /* 26 */ +#endif +#ifndef jpeg_start_decompress +#define jpeg_start_decompress \ + (jpegtclStubsPtr->jpeg_start_decompress) /* 27 */ +#endif +#ifndef jpeg_read_scanlines +#define jpeg_read_scanlines \ + (jpegtclStubsPtr->jpeg_read_scanlines) /* 28 */ +#endif +#ifndef jpeg_finish_decompress +#define jpeg_finish_decompress \ + (jpegtclStubsPtr->jpeg_finish_decompress) /* 29 */ +#endif +#ifndef jpeg_read_raw_data +#define jpeg_read_raw_data \ + (jpegtclStubsPtr->jpeg_read_raw_data) /* 30 */ +#endif +#ifndef jpeg_has_multiple_scans +#define jpeg_has_multiple_scans \ + (jpegtclStubsPtr->jpeg_has_multiple_scans) /* 31 */ +#endif +#ifndef jpeg_start_output +#define jpeg_start_output \ + (jpegtclStubsPtr->jpeg_start_output) /* 32 */ +#endif +#ifndef jpeg_finish_output +#define jpeg_finish_output \ + (jpegtclStubsPtr->jpeg_finish_output) /* 33 */ +#endif +#ifndef jpeg_input_complete +#define jpeg_input_complete \ + (jpegtclStubsPtr->jpeg_input_complete) /* 34 */ +#endif +#ifndef jpeg_new_colormap +#define jpeg_new_colormap \ + (jpegtclStubsPtr->jpeg_new_colormap) /* 35 */ +#endif +#ifndef jpeg_consume_input +#define jpeg_consume_input \ + (jpegtclStubsPtr->jpeg_consume_input) /* 36 */ +#endif +#ifndef jpeg_calc_output_dimensions +#define jpeg_calc_output_dimensions \ + (jpegtclStubsPtr->jpeg_calc_output_dimensions) /* 37 */ +#endif +#ifndef jpeg_save_markers +#define jpeg_save_markers \ + (jpegtclStubsPtr->jpeg_save_markers) /* 38 */ +#endif +#ifndef jpeg_set_marker_processor +#define jpeg_set_marker_processor \ + (jpegtclStubsPtr->jpeg_set_marker_processor) /* 39 */ +#endif +#ifndef jpeg_read_coefficients +#define jpeg_read_coefficients \ + (jpegtclStubsPtr->jpeg_read_coefficients) /* 40 */ +#endif +#ifndef jpeg_write_coefficients +#define jpeg_write_coefficients \ + (jpegtclStubsPtr->jpeg_write_coefficients) /* 41 */ +#endif +#ifndef jpeg_copy_critical_parameters +#define jpeg_copy_critical_parameters \ + (jpegtclStubsPtr->jpeg_copy_critical_parameters) /* 42 */ +#endif +#ifndef jpeg_abort_compress +#define jpeg_abort_compress \ + (jpegtclStubsPtr->jpeg_abort_compress) /* 43 */ +#endif +#ifndef jpeg_abort_decompress +#define jpeg_abort_decompress \ + (jpegtclStubsPtr->jpeg_abort_decompress) /* 44 */ +#endif +#ifndef jpeg_abort +#define jpeg_abort \ + (jpegtclStubsPtr->jpeg_abort) /* 45 */ +#endif +#ifndef jpeg_destroy +#define jpeg_destroy \ + (jpegtclStubsPtr->jpeg_destroy) /* 46 */ +#endif +#ifndef jpeg_resync_to_restart +#define jpeg_resync_to_restart \ + (jpegtclStubsPtr->jpeg_resync_to_restart) /* 47 */ +#endif + +#endif /* defined(USE_JPEGTCL_STUBS) && !defined(USE_JPEGTCL_STUB_PROCS) */ + +/* !END!: Do not edit above this line. */ + +#endif /* _JPEGTCLDECLS */ + diff --git a/mingw/include/jpegtclDeclsMask.h b/mingw/include/jpegtclDeclsMask.h new file mode 100644 index 00000000..317bd46f --- /dev/null +++ b/mingw/include/jpegtclDeclsMask.h @@ -0,0 +1,58 @@ +#ifdef WIN32 +/* + * While the definitions in the original header are technically the + * same as the definitions in 'zlibDecls.h' on Windows they are not, + * in a small detail: DLLEXPORT vs. DLLIMPORT. As our artificial + * definitions do the right thing we use the macro definitions below + * to move the original definitionsd out of the way. We do retain the + * inclusion of all the type definitions, etc. + */ +#define jpeg_std_error __mask_jpeg_std_error +#define jpeg_CreateCompress __mask_jpeg_CreateCompress +#define jpeg_CreateDecompress __mask_jpeg_CreateDecompress +#define jpeg_destroy_compress __mask_jpeg_destroy_compress +#define jpeg_destroy_decompress __mask_jpeg_destroy_decompress +#define jpeg_stdio_dest __mask_jpeg_stdio_dest +#define jpeg_stdio_src __mask_jpeg_stdio_src +#define jpeg_set_defaults __mask_jpeg_set_defaults +#define jpeg_set_colorspace __mask_jpeg_set_colorspace +#define jpeg_default_colorspace __mask_jpeg_default_colorspace +#define jpeg_set_quality __mask_jpeg_set_quality +#define jpeg_set_linear_quality __mask_jpeg_set_linear_quality +#define jpeg_add_quant_table __mask_jpeg_add_quant_table +#define jpeg_quality_scaling __mask_jpeg_quality_scaling +#define jpeg_simple_progression __mask_jpeg_simple_progression +#define jpeg_suppress_tables __mask_jpeg_suppress_tables +#define jpeg_alloc_quant_table __mask_jpeg_alloc_quant_table +#define jpeg_alloc_huff_table __mask_jpeg_alloc_huff_table +#define jpeg_start_compress __mask_jpeg_start_compress +#define jpeg_write_scanlines __mask_jpeg_write_scanlines +#define jpeg_finish_compress __mask_jpeg_finish_compress +#define jpeg_write_raw_data __mask_jpeg_write_raw_data +#define jpeg_write_marker __mask_jpeg_write_marker +#define jpeg_write_m_header __mask_jpeg_write_m_header +#define jpeg_write_m_byte __mask_jpeg_write_m_byte +#define jpeg_write_tables __mask_jpeg_write_tables +#define jpeg_read_header __mask_jpeg_read_header +#define jpeg_start_decompress __mask_jpeg_start_decompress +#define jpeg_read_scanlines __mask_jpeg_read_scanlines +#define jpeg_finish_decompress __mask_jpeg_finish_decompress +#define jpeg_read_raw_data __mask_jpeg_read_raw_data +#define jpeg_has_multiple_scans __mask_jpeg_has_multiple_scans +#define jpeg_start_output __mask_jpeg_start_output +#define jpeg_finish_output __mask_jpeg_finish_output +#define jpeg_input_complete __mask_jpeg_input_complete +#define jpeg_new_colormap __mask_jpeg_new_colormap +#define jpeg_consume_input __mask_jpeg_consume_input +#define jpeg_calc_output_dimensions __mask_jpeg_calc_output_dimensions +#define jpeg_save_markers __mask_jpeg_save_markers +#define jpeg_set_marker_processor __mask_jpeg_set_marker_processor +#define jpeg_read_coefficients __mask_jpeg_read_coefficients +#define jpeg_write_coefficients __mask_jpeg_write_coefficients +#define jpeg_copy_critical_parameters __mask_jpeg_copy_critical_parameters +#define jpeg_abort_compress __mask_jpeg_abort_compress +#define jpeg_abort_decompress __mask_jpeg_abort_decompress +#define jpeg_abort __mask_jpeg_abort +#define jpeg_destroy __mask_jpeg_destroy +#define jpeg_resync_to_restart __mask_jpeg_resync_to_restart +#endif /* WIN32 */ diff --git a/mingw/include/jpegtclDeclsUnmask.h b/mingw/include/jpegtclDeclsUnmask.h new file mode 100644 index 00000000..6322ffed --- /dev/null +++ b/mingw/include/jpegtclDeclsUnmask.h @@ -0,0 +1,51 @@ +#ifdef WIN32 +/* Restore the usage of the original names */ +#undef jpeg_std_error +#undef jpeg_CreateCompress +#undef jpeg_CreateDecompress +#undef jpeg_destroy_compress +#undef jpeg_destroy_decompress +#undef jpeg_stdio_dest +#undef jpeg_stdio_src +#undef jpeg_set_defaults +#undef jpeg_set_colorspace +#undef jpeg_default_colorspace +#undef jpeg_set_quality +#undef jpeg_set_linear_quality +#undef jpeg_add_quant_table +#undef jpeg_quality_scaling +#undef jpeg_simple_progression +#undef jpeg_suppress_tables +#undef jpeg_alloc_quant_table +#undef jpeg_alloc_huff_table +#undef jpeg_start_compress +#undef jpeg_write_scanlines +#undef jpeg_finish_compress +#undef jpeg_write_raw_data +#undef jpeg_write_marker +#undef jpeg_write_m_header +#undef jpeg_write_m_byte +#undef jpeg_write_tables +#undef jpeg_read_header +#undef jpeg_start_decompress +#undef jpeg_read_scanlines +#undef jpeg_finish_decompress +#undef jpeg_read_raw_data +#undef jpeg_has_multiple_scans +#undef jpeg_start_output +#undef jpeg_finish_output +#undef jpeg_input_complete +#undef jpeg_new_colormap +#undef jpeg_consume_input +#undef jpeg_calc_output_dimensions +#undef jpeg_save_markers +#undef jpeg_set_marker_processor +#undef jpeg_read_coefficients +#undef jpeg_write_coefficients +#undef jpeg_copy_critical_parameters +#undef jpeg_abort_compress +#undef jpeg_abort_decompress +#undef jpeg_abort +#undef jpeg_destroy +#undef jpeg_resync_to_restart +#endif /* WIN32 */ diff --git a/mingw/include/tifftcl.h b/mingw/include/tifftcl.h new file mode 100644 index 00000000..a8853b6a --- /dev/null +++ b/mingw/include/tifftcl.h @@ -0,0 +1,157 @@ +/* + * tifftcl.h -- + * + * Interface to libtiff. + * + * Copyright (c) 2002-2004 Andreas Kupries + * + * Zveno Pty Ltd makes this software and associated documentation + * available free of charge for any purpose. You may make copies + * of the software but you must include all of this notice on any copy. + * + * Zveno Pty Ltd does not warrant that this software is error free + * or fit for any purpose. Zveno Pty Ltd disclaims any liability for + * all claims, expenses, losses, damages and costs any user may incur + * as a result of using, copying or modifying the software. + * + * $Id: tifftcl.h,v 1.3 2004/08/16 19:23:38 andreas_kupries Exp $ + * + */ + +#ifndef __TIFFTCL_H__ +#define __TIFFTCL_H__ + +#include "tcl.h" + +#define TIFFTCL_MAJOR_VERSION 3 +#define TIFFTCL_MINOR_VERSION 6 +#define TIFFTCL_RELEASE_LEVEL TCL_RELEASE +#define TIFFTCL_RELEASE_SERIAL 1 + +#define TIFFTCL_VERSION "3.6.1" +#define TIFFTCL_PATCH_LEVEL "3.6.1" + +/* + * Used to block the rest of this header file from resource compilers so + * we can just get the version info. + */ +#ifndef RC_INVOKED + +/* TIP 27 update. If CONST84 is not defined we are compiling against a + * core before 8.4 and have to disable some CONST'ness. + */ + +#ifndef CONST84 +# define CONST84 +#endif + +/* + * Fix the Borland bug that's in the EXTERN macro from tcl.h. + */ +#ifndef TCL_EXTERN +# undef DLLIMPORT +# undef DLLEXPORT +# if defined(STATIC_BUILD) +# define DLLIMPORT +# define DLLEXPORT +# elif (defined(__WIN32__) && (defined(_MSC_VER) || (__BORLANDC__ >= 0x0550) || (defined(__GNUC__) && defined(__declspec)))) || (defined(MAC_TCL) && FUNCTION_DECLSPEC) +# define DLLIMPORT __declspec(dllimport) +# define DLLEXPORT __declspec(dllexport) +# elif defined(__BORLANDC__) +# define OLDBORLAND 1 +# define DLLIMPORT __import +# define DLLEXPORT __export +# else +# define DLLIMPORT +# define DLLEXPORT +# endif + /* Avoid name mangling from C++ compilers. */ +# ifdef __cplusplus +# define TCL_EXTRNC extern "C" +# else +# define TCL_EXTRNC extern +# endif + /* Pre-5.5 Borland requires the attributes be placed after the */ + /* return type. */ +# ifdef OLDBORLAND +# define TCL_EXTERN(RTYPE) TCL_EXTRNC RTYPE TCL_STORAGE_CLASS +# else +# define TCL_EXTERN(RTYPE) TCL_EXTRNC TCL_STORAGE_CLASS RTYPE +# endif +#endif + + + +/* + * These macros are used to control whether functions are being declared for + * import or export in Windows, + * They map to no-op declarations on non-Windows systems. + * Assumes that tcl.h defines DLLEXPORT & DLLIMPORT correctly. + * The default build on windows is for a DLL, which causes the DLLIMPORT + * and DLLEXPORT macros to be nonempty. To build a static library, the + * macro STATIC_BUILD should be defined before the inclusion of tcl.h + * + * If a function is being declared while it is being built + * to be included in a shared library, then it should have the DLLEXPORT + * storage class. If is being declared for use by a module that is going to + * link against the shared library, then it should have the DLLIMPORT storage + * class. If the symbol is beind declared for a static build or for use from a + * stub library, then the storage class should be empty. + * + * The convention is that a macro called BUILD_xxxx, where xxxx is the + * name of a library we are building, is set on the compile line for sources + * that are to be placed in the library. When this macro is set, the + * storage class will be set to DLLEXPORT. At the end of the header file, the + * storage class will be reset to DLLIMPORt. + */ + +#undef TCL_STORAGE_CLASS +#ifdef BUILD_tifftcl +# define TCL_STORAGE_CLASS DLLEXPORT +#else +# ifdef USE_TIFFTCL_STUBS +# define TCL_STORAGE_CLASS +# else +# define TCL_STORAGE_CLASS DLLIMPORT +# endif +#endif + +/* + *---------------------------------------------------------------------------- + * C API for Tifftcl generic layer + *---------------------------------------------------------------------------- + */ + +/* + *---------------------------------------------------------------------------- + * Function prototypes for publically accessible routines + *---------------------------------------------------------------------------- + */ + +#include "tifftclDecls.h" + +/* + *---------------------------------------------------------------------------- + * Function prototypes for stub initialization. + *---------------------------------------------------------------------------- + */ + +#ifdef USE_TIFFTCL_STUBS +EXTERN CONST char * +Tifftcl_InitStubs _ANSI_ARGS_((Tcl_Interp *interp, CONST char *version, int exact)); +#else + +/* + * When not using stubs, make it a macro. + */ + +#define Tifftcl_InitStubs(interp, version, exact) \ + Tcl_PkgRequire(interp, "tifftcl", version, exact) +#endif + + +#undef TCL_STORAGE_CLASS +#define TCL_STORAGE_CLASS DLLIMPORT + +#endif /* RC_INVOKED */ +#endif /* __TIFFTCL_H__ */ diff --git a/mingw/include/tifftclDecls.h b/mingw/include/tifftclDecls.h new file mode 100644 index 00000000..17681b5c --- /dev/null +++ b/mingw/include/tifftclDecls.h @@ -0,0 +1,1212 @@ +/* + * tifftclDecls.h -- + * + * Declarations of functions in the platform independent public TIFFTCL API. + * + */ + +#ifndef _TIFFTCLDECLS +#define _TIFFTCLDECLS + +/* + * WARNING: The contents of this file is automatically generated by the + * genStubs.tcl script. Any modifications to the function declarations + * below should be made in the tifftcl.decls script. + */ + +#include +#include +#include <../libtiff/tiffio.h> +#include <../libtiff/tiffiop.h> +#include <../libtiff/tif_predict.h> +#include + +/* !BEGIN!: Do not edit below this line. */ + +/* + * Ensure usage of + */ + +#if defined(NO_STDARG) +# error "This code requires " +#else +# include +#endif + +/* + * Exported function declarations: + */ + +/* 0 */ +EXTERN const char* TIFFGetVersion _ANSI_ARGS_((void)); +/* 1 */ +EXTERN const TIFFCodec* TIFFFindCODEC _ANSI_ARGS_((uint16 a)); +/* 2 */ +EXTERN TIFFCodec* TIFFRegisterCODEC _ANSI_ARGS_((uint16 a, + const char* b, TIFFInitMethod c)); +/* 3 */ +EXTERN void TIFFUnRegisterCODEC _ANSI_ARGS_((TIFFCodec* a)); +/* 4 */ +EXTERN tdata_t _TIFFmalloc _ANSI_ARGS_((tsize_t a)); +/* 5 */ +EXTERN tdata_t _TIFFrealloc _ANSI_ARGS_((tdata_t a, tsize_t b)); +/* 6 */ +EXTERN void _TIFFmemset _ANSI_ARGS_((tdata_t a, int b, tsize_t c)); +/* 7 */ +EXTERN void _TIFFmemcpy _ANSI_ARGS_((tdata_t a, const tdata_t b, + tsize_t c)); +/* 8 */ +EXTERN int _TIFFmemcmp _ANSI_ARGS_((const tdata_t a, + const tdata_t b, tsize_t c)); +/* 9 */ +EXTERN void _TIFFfree _ANSI_ARGS_((tdata_t a)); +/* 10 */ +EXTERN void TIFFClose _ANSI_ARGS_((TIFF* tiffptr)); +/* 11 */ +EXTERN int TIFFFlush _ANSI_ARGS_((TIFF* tiffptr)); +/* 12 */ +EXTERN int TIFFFlushData _ANSI_ARGS_((TIFF* tiffptr)); +/* 13 */ +EXTERN int TIFFGetField _ANSI_ARGS_((TIFF* tiffptr, ttag_t a, + ... )); +/* 14 */ +EXTERN int TIFFVGetField _ANSI_ARGS_((TIFF* tiffptr, ttag_t a, + va_list b)); +/* 15 */ +EXTERN int TIFFGetFieldDefaulted _ANSI_ARGS_((TIFF* tiffptr, + ttag_t a, ... )); +/* 16 */ +EXTERN int TIFFVGetFieldDefaulted _ANSI_ARGS_((TIFF* tiffptr, + ttag_t a, va_list b)); +/* 17 */ +EXTERN int TIFFReadDirectory _ANSI_ARGS_((TIFF* tiffptr)); +/* 18 */ +EXTERN tsize_t TIFFScanlineSize _ANSI_ARGS_((TIFF* tiffptr)); +/* 19 */ +EXTERN tsize_t TIFFRasterScanlineSize _ANSI_ARGS_((TIFF* tiffptr)); +/* 20 */ +EXTERN tsize_t TIFFStripSize _ANSI_ARGS_((TIFF* tiffptr)); +/* 21 */ +EXTERN tsize_t TIFFVStripSize _ANSI_ARGS_((TIFF* tiffptr, uint32 a)); +/* 22 */ +EXTERN tsize_t TIFFTileRowSize _ANSI_ARGS_((TIFF* tiffptr)); +/* 23 */ +EXTERN tsize_t TIFFTileSize _ANSI_ARGS_((TIFF* tiffptr)); +/* 24 */ +EXTERN tsize_t TIFFVTileSize _ANSI_ARGS_((TIFF* tiffptr, uint32 a)); +/* 25 */ +EXTERN uint32 TIFFDefaultStripSize _ANSI_ARGS_((TIFF* tiffptr, + uint32 a)); +/* 26 */ +EXTERN void TIFFDefaultTileSize _ANSI_ARGS_((TIFF* tiffptr, + uint32* a, uint32* b)); +/* 27 */ +EXTERN int TIFFFileno _ANSI_ARGS_((TIFF* tiffptr)); +/* 28 */ +EXTERN int TIFFGetMode _ANSI_ARGS_((TIFF* tiffptr)); +/* 29 */ +EXTERN int TIFFIsTiled _ANSI_ARGS_((TIFF* tiffptr)); +/* 30 */ +EXTERN int TIFFIsByteSwapped _ANSI_ARGS_((TIFF* tiffptr)); +/* 31 */ +EXTERN int TIFFIsUpSampled _ANSI_ARGS_((TIFF* tiffptr)); +/* 32 */ +EXTERN int TIFFIsMSB2LSB _ANSI_ARGS_((TIFF* tiffptr)); +/* 33 */ +EXTERN uint32 TIFFCurrentRow _ANSI_ARGS_((TIFF* tiffptr)); +/* 34 */ +EXTERN tdir_t TIFFCurrentDirectory _ANSI_ARGS_((TIFF* tiffptr)); +/* 35 */ +EXTERN tdir_t TIFFNumberOfDirectories _ANSI_ARGS_((TIFF* tiffptr)); +/* 36 */ +EXTERN uint32 TIFFCurrentDirOffset _ANSI_ARGS_((TIFF* tiffptr)); +/* 37 */ +EXTERN tstrip_t TIFFCurrentStrip _ANSI_ARGS_((TIFF* tiffptr)); +/* 38 */ +EXTERN ttile_t TIFFCurrentTile _ANSI_ARGS_((TIFF* tiffptr)); +/* 39 */ +EXTERN int TIFFReadBufferSetup _ANSI_ARGS_((TIFF* tiffptr, + tdata_t a, tsize_t b)); +/* 40 */ +EXTERN int TIFFWriteBufferSetup _ANSI_ARGS_((TIFF* tiffptr, + tdata_t a, tsize_t b)); +/* 41 */ +EXTERN int TIFFWriteCheck _ANSI_ARGS_((TIFF* tiffptr, int a, + const char * b)); +/* 42 */ +EXTERN int TIFFCreateDirectory _ANSI_ARGS_((TIFF* tiffptr)); +/* 43 */ +EXTERN int TIFFLastDirectory _ANSI_ARGS_((TIFF* tiffptr)); +/* 44 */ +EXTERN int TIFFSetDirectory _ANSI_ARGS_((TIFF* tiffptr, + tdir_t a)); +/* 45 */ +EXTERN int TIFFSetSubDirectory _ANSI_ARGS_((TIFF* tiffptr, + uint32 a)); +/* 46 */ +EXTERN int TIFFUnlinkDirectory _ANSI_ARGS_((TIFF* tiffptr, + tdir_t a)); +/* 47 */ +EXTERN int TIFFSetField _ANSI_ARGS_((TIFF* tiffptr, ttag_t a, + ... )); +/* 48 */ +EXTERN int TIFFVSetField _ANSI_ARGS_((TIFF* tiffptr, ttag_t a, + va_list b)); +/* 49 */ +EXTERN int TIFFWriteDirectory _ANSI_ARGS_((TIFF * tiffptr)); +/* 50 */ +EXTERN int TIFFReassignTagToIgnore _ANSI_ARGS_(( + enum TIFFIgnoreSense a, int b)); +/* 51 */ +EXTERN void TIFFPrintDirectory _ANSI_ARGS_((TIFF* tiffptr, + FILE* a, long b)); +/* 52 */ +EXTERN int TIFFReadScanline _ANSI_ARGS_((TIFF* tiffptr, + tdata_t a, uint32 b, tsample_t c)); +/* 53 */ +EXTERN int TIFFWriteScanline _ANSI_ARGS_((TIFF* tiffptr, + tdata_t a, uint32 b, tsample_t c)); +/* 54 */ +EXTERN int TIFFReadRGBAImage _ANSI_ARGS_((TIFF* tiffptr, + uint32 a, uint32 b, uint32* c, int d)); +/* 55 */ +EXTERN int TIFFReadRGBAStrip _ANSI_ARGS_((TIFF* tiffptr, + tstrip_t a, uint32 * b)); +/* 56 */ +EXTERN int TIFFReadRGBATile _ANSI_ARGS_((TIFF* tiffptr, + uint32 a, uint32 b, uint32 * c)); +/* 57 */ +EXTERN int TIFFRGBAImageOK _ANSI_ARGS_((TIFF* tiffptr, char* a)); +/* 58 */ +EXTERN int TIFFRGBAImageBegin _ANSI_ARGS_((TIFFRGBAImage* a, + TIFF* tiffptr, int b, char* c)); +/* 59 */ +EXTERN int TIFFRGBAImageGet _ANSI_ARGS_((TIFFRGBAImage* d, + uint32* c, uint32 b, uint32 a)); +/* 60 */ +EXTERN void TIFFRGBAImageEnd _ANSI_ARGS_((TIFFRGBAImage* a)); +/* 61 */ +EXTERN TIFF* TIFFOpen _ANSI_ARGS_((const char* b, const char* a)); +/* 62 */ +EXTERN TIFF* TIFFFdOpen _ANSI_ARGS_((int a, const char* b, + const char* c)); +/* 63 */ +EXTERN TIFF* TIFFClientOpen _ANSI_ARGS_((const char* a, + const char* b, thandle_t c, + TIFFReadWriteProc d, TIFFReadWriteProc e, + TIFFSeekProc f, TIFFCloseProc g, + TIFFSizeProc h, TIFFMapFileProc i, + TIFFUnmapFileProc j)); +/* 64 */ +EXTERN const char* TIFFFileName _ANSI_ARGS_((TIFF* tiffptr)); +/* 65 */ +EXTERN void TIFFError _ANSI_ARGS_((const char* a, const char* b, + ... )); +/* 66 */ +EXTERN void TIFFWarning _ANSI_ARGS_((const char* a, + const char* b, ... )); +/* 67 */ +EXTERN TIFFErrorHandler TIFFSetErrorHandler _ANSI_ARGS_((TIFFErrorHandler a)); +/* 68 */ +EXTERN TIFFErrorHandler TIFFSetWarningHandler _ANSI_ARGS_(( + TIFFErrorHandler a)); +/* 69 */ +EXTERN TIFFExtendProc TIFFSetTagExtender _ANSI_ARGS_((TIFFExtendProc a)); +/* 70 */ +EXTERN ttile_t TIFFComputeTile _ANSI_ARGS_((TIFF* tiffptr, uint32 a, + uint32 b, uint32 c, tsample_t d)); +/* 71 */ +EXTERN int TIFFCheckTile _ANSI_ARGS_((TIFF* tiffptr, uint32 d, + uint32 c, uint32 b, tsample_t a)); +/* 72 */ +EXTERN ttile_t TIFFNumberOfTiles _ANSI_ARGS_((TIFF* tiffptr)); +/* 73 */ +EXTERN tsize_t TIFFReadTile _ANSI_ARGS_((TIFF* tiffptr, tdata_t a, + uint32 b, uint32 c, uint32 d, tsample_t e)); +/* 74 */ +EXTERN tsize_t TIFFWriteTile _ANSI_ARGS_((TIFF* tiffptr, tdata_t e, + uint32 d, uint32 c, uint32 b, tsample_t a)); +/* 75 */ +EXTERN tstrip_t TIFFComputeStrip _ANSI_ARGS_((TIFF* tiffptr, + uint32 a, tsample_t b)); +/* 76 */ +EXTERN tstrip_t TIFFNumberOfStrips _ANSI_ARGS_((TIFF* tiffptr)); +/* 77 */ +EXTERN tsize_t TIFFReadEncodedStrip _ANSI_ARGS_((TIFF* tiffptr, + tstrip_t a, tdata_t b, tsize_t c)); +/* 78 */ +EXTERN tsize_t TIFFReadRawStrip _ANSI_ARGS_((TIFF* tiffptr, + tstrip_t a, tdata_t b, tsize_t c)); +/* 79 */ +EXTERN tsize_t TIFFReadEncodedTile _ANSI_ARGS_((TIFF* tiffptr, + ttile_t a, tdata_t b, tsize_t c)); +/* 80 */ +EXTERN tsize_t TIFFReadRawTile _ANSI_ARGS_((TIFF* tiffptr, + ttile_t c, tdata_t b, tsize_t a)); +/* 81 */ +EXTERN tsize_t TIFFWriteEncodedStrip _ANSI_ARGS_((TIFF* tiffptr, + tstrip_t a, tdata_t b, tsize_t c)); +/* 82 */ +EXTERN tsize_t TIFFWriteRawStrip _ANSI_ARGS_((TIFF* tiffptr, + tstrip_t a, tdata_t b, tsize_t c)); +/* 83 */ +EXTERN tsize_t TIFFWriteEncodedTile _ANSI_ARGS_((TIFF* tiffptr, + ttile_t a, tdata_t b, tsize_t c)); +/* 84 */ +EXTERN tsize_t TIFFWriteRawTile _ANSI_ARGS_((TIFF* tiffptr, + ttile_t c, tdata_t b, tsize_t a)); +/* 85 */ +EXTERN void TIFFSetWriteOffset _ANSI_ARGS_((TIFF* tiffptr, + toff_t a)); +/* 86 */ +EXTERN void TIFFSwabShort _ANSI_ARGS_((uint16* a)); +/* 87 */ +EXTERN void TIFFSwabLong _ANSI_ARGS_((uint32* a)); +/* 88 */ +EXTERN void TIFFSwabDouble _ANSI_ARGS_((double* a)); +/* 89 */ +EXTERN void TIFFSwabArrayOfShort _ANSI_ARGS_((uint16* a, + unsigned long b)); +/* 90 */ +EXTERN void TIFFSwabArrayOfLong _ANSI_ARGS_((uint32* b, + unsigned long a)); +/* 91 */ +EXTERN void TIFFSwabArrayOfDouble _ANSI_ARGS_((double* a, + unsigned long b)); +/* 92 */ +EXTERN void TIFFReverseBits _ANSI_ARGS_((unsigned char* a, + unsigned long b)); +/* 93 */ +EXTERN const unsigned char* TIFFGetBitRevTable _ANSI_ARGS_((int a)); +/* Slot 94 is reserved */ +/* Slot 95 is reserved */ +/* Slot 96 is reserved */ +/* Slot 97 is reserved */ +/* Slot 98 is reserved */ +/* Slot 99 is reserved */ +/* 100 */ +EXTERN int TIFFPredictorInit _ANSI_ARGS_((TIFF* tiffptr)); +/* Slot 101 is reserved */ +/* Slot 102 is reserved */ +/* Slot 103 is reserved */ +/* Slot 104 is reserved */ +/* Slot 105 is reserved */ +/* Slot 106 is reserved */ +/* Slot 107 is reserved */ +/* Slot 108 is reserved */ +/* Slot 109 is reserved */ +/* 110 */ +EXTERN void _TIFFSetupFieldInfo _ANSI_ARGS_((TIFF* tiffptr)); +/* 111 */ +EXTERN void TIFFMergeFieldInfo _ANSI_ARGS_((TIFF* tiffptr, + const TIFFFieldInfo* a, int b)); +/* 112 */ +EXTERN void _TIFFPrintFieldInfo _ANSI_ARGS_((TIFF* tiffptr, + FILE* a)); +/* 113 */ +EXTERN const TIFFFieldInfo* TIFFFindFieldInfo _ANSI_ARGS_((TIFF* tiffptr, + ttag_t a, TIFFDataType b)); +/* 114 */ +EXTERN const TIFFFieldInfo* TIFFFieldWithTag _ANSI_ARGS_((TIFF* tiffptr, + ttag_t a)); +/* 115 */ +EXTERN TIFFDataType _TIFFSampleToTagType _ANSI_ARGS_((TIFF* tiffptr)); +/* Slot 116 is reserved */ +/* Slot 117 is reserved */ +/* Slot 118 is reserved */ +/* Slot 119 is reserved */ +/* 120 */ +EXTERN int _TIFFgetMode _ANSI_ARGS_((const char* a, + const char* b)); +/* 121 */ +EXTERN int _TIFFNoRowEncode _ANSI_ARGS_((TIFF* tiffptr, + tidata_t a, tsize_t b, tsample_t c)); +/* 122 */ +EXTERN int _TIFFNoStripEncode _ANSI_ARGS_((TIFF* tiffptr, + tidata_t c, tsize_t b, tsample_t a)); +/* 123 */ +EXTERN int _TIFFNoTileEncode _ANSI_ARGS_((TIFF* tiffptr, + tidata_t a, tsize_t b, tsample_t c)); +/* 124 */ +EXTERN int _TIFFNoRowDecode _ANSI_ARGS_((TIFF* tiffptr, + tidata_t c, tsize_t b, tsample_t a)); +/* 125 */ +EXTERN int _TIFFNoStripDecode _ANSI_ARGS_((TIFF* tiffptr, + tidata_t a, tsize_t b, tsample_t c)); +/* 126 */ +EXTERN int _TIFFNoTileDecode _ANSI_ARGS_((TIFF* tiffptr, + tidata_t c, tsize_t b, tsample_t a)); +/* 127 */ +EXTERN void _TIFFNoPostDecode _ANSI_ARGS_((TIFF* tiffptr, + tidata_t a, tsize_t b)); +/* 128 */ +EXTERN int _TIFFNoPreCode _ANSI_ARGS_((TIFF* tiffptr, + tsample_t a)); +/* 129 */ +EXTERN int _TIFFNoSeek _ANSI_ARGS_((TIFF* tiffptr, uint32 a)); +/* 130 */ +EXTERN void _TIFFSwab16BitData _ANSI_ARGS_((TIFF* tiffptr, + tidata_t a, tsize_t b)); +/* 131 */ +EXTERN void _TIFFSwab32BitData _ANSI_ARGS_((TIFF* tiffptr, + tidata_t b, tsize_t a)); +/* 132 */ +EXTERN void _TIFFSwab64BitData _ANSI_ARGS_((TIFF* tiffptr, + tidata_t a, tsize_t b)); +/* 133 */ +EXTERN int TIFFFlushData1 _ANSI_ARGS_((TIFF* tiffptr)); +/* 134 */ +EXTERN void TIFFFreeDirectory _ANSI_ARGS_((TIFF* tiffptr)); +/* 135 */ +EXTERN int TIFFDefaultDirectory _ANSI_ARGS_((TIFF* tiffptr)); +/* 136 */ +EXTERN int TIFFSetCompressionScheme _ANSI_ARGS_((TIFF* tiffptr, + int a)); +/* 137 */ +EXTERN int _TIFFSetDefaultCompressionState _ANSI_ARGS_(( + TIFF* tiffptr)); +/* 138 */ +EXTERN uint32 _TIFFDefaultStripSize _ANSI_ARGS_((TIFF* tiffptr, + uint32 a)); +/* 139 */ +EXTERN void _TIFFDefaultTileSize _ANSI_ARGS_((TIFF* tiffptr, + uint32* a, uint32* b)); +/* 140 */ +EXTERN void _TIFFsetByteArray _ANSI_ARGS_((void** a, void* b, + long c)); +/* 141 */ +EXTERN void _TIFFsetString _ANSI_ARGS_((char** a, char* b)); +/* 142 */ +EXTERN void _TIFFsetShortArray _ANSI_ARGS_((uint16** a, + uint16* b, long c)); +/* 143 */ +EXTERN void _TIFFsetLongArray _ANSI_ARGS_((uint32** a, uint32* b, + long c)); +/* 144 */ +EXTERN void _TIFFsetFloatArray _ANSI_ARGS_((float** a, float* b, + long c)); +/* 145 */ +EXTERN void _TIFFsetDoubleArray _ANSI_ARGS_((double** a, + double* b, long c)); +/* 146 */ +EXTERN void _TIFFprintAscii _ANSI_ARGS_((FILE* a, const char* b)); +/* 147 */ +EXTERN void _TIFFprintAsciiTag _ANSI_ARGS_((FILE* a, + const char* b, const char* c)); +/* 148 */ +EXTERN int TIFFInitDumpMode _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 149 */ +EXTERN int TIFFInitPackBits _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 150 */ +EXTERN int TIFFInitCCITTRLE _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 151 */ +EXTERN int TIFFInitCCITTRLEW _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 152 */ +EXTERN int TIFFInitCCITTFax3 _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 153 */ +EXTERN int TIFFInitCCITTFax4 _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 154 */ +EXTERN int TIFFInitThunderScan _ANSI_ARGS_((TIFF* tiffptr, + int a)); +/* 155 */ +EXTERN int TIFFInitNeXT _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 156 */ +EXTERN int TIFFInitLZW _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 157 */ +EXTERN int TIFFInitOJPEG _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 158 */ +EXTERN int TIFFInitJPEG _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 159 */ +EXTERN int TIFFInitJBIG _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 160 */ +EXTERN int TIFFInitZIP _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 161 */ +EXTERN int TIFFInitPixarLog _ANSI_ARGS_((TIFF* tiffptr, int a)); +/* 162 */ +EXTERN int TIFFInitSGILog _ANSI_ARGS_((TIFF* tiffptr, int a)); + +typedef struct TifftclStubs { + int magic; + struct TifftclStubHooks *hooks; + + const char* (*tIFFGetVersion) _ANSI_ARGS_((void)); /* 0 */ + const TIFFCodec* (*tIFFFindCODEC) _ANSI_ARGS_((uint16 a)); /* 1 */ + TIFFCodec* (*tIFFRegisterCODEC) _ANSI_ARGS_((uint16 a, const char* b, TIFFInitMethod c)); /* 2 */ + void (*tIFFUnRegisterCODEC) _ANSI_ARGS_((TIFFCodec* a)); /* 3 */ + tdata_t (*_TIFFmalloc) _ANSI_ARGS_((tsize_t a)); /* 4 */ + tdata_t (*_TIFFrealloc) _ANSI_ARGS_((tdata_t a, tsize_t b)); /* 5 */ + void (*_TIFFmemset) _ANSI_ARGS_((tdata_t a, int b, tsize_t c)); /* 6 */ + void (*_TIFFmemcpy) _ANSI_ARGS_((tdata_t a, const tdata_t b, tsize_t c)); /* 7 */ + int (*_TIFFmemcmp) _ANSI_ARGS_((const tdata_t a, const tdata_t b, tsize_t c)); /* 8 */ + void (*_TIFFfree) _ANSI_ARGS_((tdata_t a)); /* 9 */ + void (*tIFFClose) _ANSI_ARGS_((TIFF* tiffptr)); /* 10 */ + int (*tIFFFlush) _ANSI_ARGS_((TIFF* tiffptr)); /* 11 */ + int (*tIFFFlushData) _ANSI_ARGS_((TIFF* tiffptr)); /* 12 */ + int (*tIFFGetField) _ANSI_ARGS_((TIFF* tiffptr, ttag_t a, ... )); /* 13 */ + int (*tIFFVGetField) _ANSI_ARGS_((TIFF* tiffptr, ttag_t a, va_list b)); /* 14 */ + int (*tIFFGetFieldDefaulted) _ANSI_ARGS_((TIFF* tiffptr, ttag_t a, ... )); /* 15 */ + int (*tIFFVGetFieldDefaulted) _ANSI_ARGS_((TIFF* tiffptr, ttag_t a, va_list b)); /* 16 */ + int (*tIFFReadDirectory) _ANSI_ARGS_((TIFF* tiffptr)); /* 17 */ + tsize_t (*tIFFScanlineSize) _ANSI_ARGS_((TIFF* tiffptr)); /* 18 */ + tsize_t (*tIFFRasterScanlineSize) _ANSI_ARGS_((TIFF* tiffptr)); /* 19 */ + tsize_t (*tIFFStripSize) _ANSI_ARGS_((TIFF* tiffptr)); /* 20 */ + tsize_t (*tIFFVStripSize) _ANSI_ARGS_((TIFF* tiffptr, uint32 a)); /* 21 */ + tsize_t (*tIFFTileRowSize) _ANSI_ARGS_((TIFF* tiffptr)); /* 22 */ + tsize_t (*tIFFTileSize) _ANSI_ARGS_((TIFF* tiffptr)); /* 23 */ + tsize_t (*tIFFVTileSize) _ANSI_ARGS_((TIFF* tiffptr, uint32 a)); /* 24 */ + uint32 (*tIFFDefaultStripSize) _ANSI_ARGS_((TIFF* tiffptr, uint32 a)); /* 25 */ + void (*tIFFDefaultTileSize) _ANSI_ARGS_((TIFF* tiffptr, uint32* a, uint32* b)); /* 26 */ + int (*tIFFFileno) _ANSI_ARGS_((TIFF* tiffptr)); /* 27 */ + int (*tIFFGetMode) _ANSI_ARGS_((TIFF* tiffptr)); /* 28 */ + int (*tIFFIsTiled) _ANSI_ARGS_((TIFF* tiffptr)); /* 29 */ + int (*tIFFIsByteSwapped) _ANSI_ARGS_((TIFF* tiffptr)); /* 30 */ + int (*tIFFIsUpSampled) _ANSI_ARGS_((TIFF* tiffptr)); /* 31 */ + int (*tIFFIsMSB2LSB) _ANSI_ARGS_((TIFF* tiffptr)); /* 32 */ + uint32 (*tIFFCurrentRow) _ANSI_ARGS_((TIFF* tiffptr)); /* 33 */ + tdir_t (*tIFFCurrentDirectory) _ANSI_ARGS_((TIFF* tiffptr)); /* 34 */ + tdir_t (*tIFFNumberOfDirectories) _ANSI_ARGS_((TIFF* tiffptr)); /* 35 */ + uint32 (*tIFFCurrentDirOffset) _ANSI_ARGS_((TIFF* tiffptr)); /* 36 */ + tstrip_t (*tIFFCurrentStrip) _ANSI_ARGS_((TIFF* tiffptr)); /* 37 */ + ttile_t (*tIFFCurrentTile) _ANSI_ARGS_((TIFF* tiffptr)); /* 38 */ + int (*tIFFReadBufferSetup) _ANSI_ARGS_((TIFF* tiffptr, tdata_t a, tsize_t b)); /* 39 */ + int (*tIFFWriteBufferSetup) _ANSI_ARGS_((TIFF* tiffptr, tdata_t a, tsize_t b)); /* 40 */ + int (*tIFFWriteCheck) _ANSI_ARGS_((TIFF* tiffptr, int a, const char * b)); /* 41 */ + int (*tIFFCreateDirectory) _ANSI_ARGS_((TIFF* tiffptr)); /* 42 */ + int (*tIFFLastDirectory) _ANSI_ARGS_((TIFF* tiffptr)); /* 43 */ + int (*tIFFSetDirectory) _ANSI_ARGS_((TIFF* tiffptr, tdir_t a)); /* 44 */ + int (*tIFFSetSubDirectory) _ANSI_ARGS_((TIFF* tiffptr, uint32 a)); /* 45 */ + int (*tIFFUnlinkDirectory) _ANSI_ARGS_((TIFF* tiffptr, tdir_t a)); /* 46 */ + int (*tIFFSetField) _ANSI_ARGS_((TIFF* tiffptr, ttag_t a, ... )); /* 47 */ + int (*tIFFVSetField) _ANSI_ARGS_((TIFF* tiffptr, ttag_t a, va_list b)); /* 48 */ + int (*tIFFWriteDirectory) _ANSI_ARGS_((TIFF * tiffptr)); /* 49 */ + int (*tIFFReassignTagToIgnore) _ANSI_ARGS_((enum TIFFIgnoreSense a, int b)); /* 50 */ + void (*tIFFPrintDirectory) _ANSI_ARGS_((TIFF* tiffptr, FILE* a, long b)); /* 51 */ + int (*tIFFReadScanline) _ANSI_ARGS_((TIFF* tiffptr, tdata_t a, uint32 b, tsample_t c)); /* 52 */ + int (*tIFFWriteScanline) _ANSI_ARGS_((TIFF* tiffptr, tdata_t a, uint32 b, tsample_t c)); /* 53 */ + int (*tIFFReadRGBAImage) _ANSI_ARGS_((TIFF* tiffptr, uint32 a, uint32 b, uint32* c, int d)); /* 54 */ + int (*tIFFReadRGBAStrip) _ANSI_ARGS_((TIFF* tiffptr, tstrip_t a, uint32 * b)); /* 55 */ + int (*tIFFReadRGBATile) _ANSI_ARGS_((TIFF* tiffptr, uint32 a, uint32 b, uint32 * c)); /* 56 */ + int (*tIFFRGBAImageOK) _ANSI_ARGS_((TIFF* tiffptr, char* a)); /* 57 */ + int (*tIFFRGBAImageBegin) _ANSI_ARGS_((TIFFRGBAImage* a, TIFF* tiffptr, int b, char* c)); /* 58 */ + int (*tIFFRGBAImageGet) _ANSI_ARGS_((TIFFRGBAImage* d, uint32* c, uint32 b, uint32 a)); /* 59 */ + void (*tIFFRGBAImageEnd) _ANSI_ARGS_((TIFFRGBAImage* a)); /* 60 */ + TIFF* (*tIFFOpen) _ANSI_ARGS_((const char* b, const char* a)); /* 61 */ + TIFF* (*tIFFFdOpen) _ANSI_ARGS_((int a, const char* b, const char* c)); /* 62 */ + TIFF* (*tIFFClientOpen) _ANSI_ARGS_((const char* a, const char* b, thandle_t c, TIFFReadWriteProc d, TIFFReadWriteProc e, TIFFSeekProc f, TIFFCloseProc g, TIFFSizeProc h, TIFFMapFileProc i, TIFFUnmapFileProc j)); /* 63 */ + const char* (*tIFFFileName) _ANSI_ARGS_((TIFF* tiffptr)); /* 64 */ + void (*tIFFError) _ANSI_ARGS_((const char* a, const char* b, ... )); /* 65 */ + void (*tIFFWarning) _ANSI_ARGS_((const char* a, const char* b, ... )); /* 66 */ + TIFFErrorHandler (*tIFFSetErrorHandler) _ANSI_ARGS_((TIFFErrorHandler a)); /* 67 */ + TIFFErrorHandler (*tIFFSetWarningHandler) _ANSI_ARGS_((TIFFErrorHandler a)); /* 68 */ + TIFFExtendProc (*tIFFSetTagExtender) _ANSI_ARGS_((TIFFExtendProc a)); /* 69 */ + ttile_t (*tIFFComputeTile) _ANSI_ARGS_((TIFF* tiffptr, uint32 a, uint32 b, uint32 c, tsample_t d)); /* 70 */ + int (*tIFFCheckTile) _ANSI_ARGS_((TIFF* tiffptr, uint32 d, uint32 c, uint32 b, tsample_t a)); /* 71 */ + ttile_t (*tIFFNumberOfTiles) _ANSI_ARGS_((TIFF* tiffptr)); /* 72 */ + tsize_t (*tIFFReadTile) _ANSI_ARGS_((TIFF* tiffptr, tdata_t a, uint32 b, uint32 c, uint32 d, tsample_t e)); /* 73 */ + tsize_t (*tIFFWriteTile) _ANSI_ARGS_((TIFF* tiffptr, tdata_t e, uint32 d, uint32 c, uint32 b, tsample_t a)); /* 74 */ + tstrip_t (*tIFFComputeStrip) _ANSI_ARGS_((TIFF* tiffptr, uint32 a, tsample_t b)); /* 75 */ + tstrip_t (*tIFFNumberOfStrips) _ANSI_ARGS_((TIFF* tiffptr)); /* 76 */ + tsize_t (*tIFFReadEncodedStrip) _ANSI_ARGS_((TIFF* tiffptr, tstrip_t a, tdata_t b, tsize_t c)); /* 77 */ + tsize_t (*tIFFReadRawStrip) _ANSI_ARGS_((TIFF* tiffptr, tstrip_t a, tdata_t b, tsize_t c)); /* 78 */ + tsize_t (*tIFFReadEncodedTile) _ANSI_ARGS_((TIFF* tiffptr, ttile_t a, tdata_t b, tsize_t c)); /* 79 */ + tsize_t (*tIFFReadRawTile) _ANSI_ARGS_((TIFF* tiffptr, ttile_t c, tdata_t b, tsize_t a)); /* 80 */ + tsize_t (*tIFFWriteEncodedStrip) _ANSI_ARGS_((TIFF* tiffptr, tstrip_t a, tdata_t b, tsize_t c)); /* 81 */ + tsize_t (*tIFFWriteRawStrip) _ANSI_ARGS_((TIFF* tiffptr, tstrip_t a, tdata_t b, tsize_t c)); /* 82 */ + tsize_t (*tIFFWriteEncodedTile) _ANSI_ARGS_((TIFF* tiffptr, ttile_t a, tdata_t b, tsize_t c)); /* 83 */ + tsize_t (*tIFFWriteRawTile) _ANSI_ARGS_((TIFF* tiffptr, ttile_t c, tdata_t b, tsize_t a)); /* 84 */ + void (*tIFFSetWriteOffset) _ANSI_ARGS_((TIFF* tiffptr, toff_t a)); /* 85 */ + void (*tIFFSwabShort) _ANSI_ARGS_((uint16* a)); /* 86 */ + void (*tIFFSwabLong) _ANSI_ARGS_((uint32* a)); /* 87 */ + void (*tIFFSwabDouble) _ANSI_ARGS_((double* a)); /* 88 */ + void (*tIFFSwabArrayOfShort) _ANSI_ARGS_((uint16* a, unsigned long b)); /* 89 */ + void (*tIFFSwabArrayOfLong) _ANSI_ARGS_((uint32* b, unsigned long a)); /* 90 */ + void (*tIFFSwabArrayOfDouble) _ANSI_ARGS_((double* a, unsigned long b)); /* 91 */ + void (*tIFFReverseBits) _ANSI_ARGS_((unsigned char* a, unsigned long b)); /* 92 */ + const unsigned char* (*tIFFGetBitRevTable) _ANSI_ARGS_((int a)); /* 93 */ + void *reserved94; + void *reserved95; + void *reserved96; + void *reserved97; + void *reserved98; + void *reserved99; + int (*tIFFPredictorInit) _ANSI_ARGS_((TIFF* tiffptr)); /* 100 */ + void *reserved101; + void *reserved102; + void *reserved103; + void *reserved104; + void *reserved105; + void *reserved106; + void *reserved107; + void *reserved108; + void *reserved109; + void (*_TIFFSetupFieldInfo) _ANSI_ARGS_((TIFF* tiffptr)); /* 110 */ + void (*tIFFMergeFieldInfo) _ANSI_ARGS_((TIFF* tiffptr, const TIFFFieldInfo* a, int b)); /* 111 */ + void (*_TIFFPrintFieldInfo) _ANSI_ARGS_((TIFF* tiffptr, FILE* a)); /* 112 */ + const TIFFFieldInfo* (*tIFFFindFieldInfo) _ANSI_ARGS_((TIFF* tiffptr, ttag_t a, TIFFDataType b)); /* 113 */ + const TIFFFieldInfo* (*tIFFFieldWithTag) _ANSI_ARGS_((TIFF* tiffptr, ttag_t a)); /* 114 */ + TIFFDataType (*_TIFFSampleToTagType) _ANSI_ARGS_((TIFF* tiffptr)); /* 115 */ + void *reserved116; + void *reserved117; + void *reserved118; + void *reserved119; + int (*_TIFFgetMode) _ANSI_ARGS_((const char* a, const char* b)); /* 120 */ + int (*_TIFFNoRowEncode) _ANSI_ARGS_((TIFF* tiffptr, tidata_t a, tsize_t b, tsample_t c)); /* 121 */ + int (*_TIFFNoStripEncode) _ANSI_ARGS_((TIFF* tiffptr, tidata_t c, tsize_t b, tsample_t a)); /* 122 */ + int (*_TIFFNoTileEncode) _ANSI_ARGS_((TIFF* tiffptr, tidata_t a, tsize_t b, tsample_t c)); /* 123 */ + int (*_TIFFNoRowDecode) _ANSI_ARGS_((TIFF* tiffptr, tidata_t c, tsize_t b, tsample_t a)); /* 124 */ + int (*_TIFFNoStripDecode) _ANSI_ARGS_((TIFF* tiffptr, tidata_t a, tsize_t b, tsample_t c)); /* 125 */ + int (*_TIFFNoTileDecode) _ANSI_ARGS_((TIFF* tiffptr, tidata_t c, tsize_t b, tsample_t a)); /* 126 */ + void (*_TIFFNoPostDecode) _ANSI_ARGS_((TIFF* tiffptr, tidata_t a, tsize_t b)); /* 127 */ + int (*_TIFFNoPreCode) _ANSI_ARGS_((TIFF* tiffptr, tsample_t a)); /* 128 */ + int (*_TIFFNoSeek) _ANSI_ARGS_((TIFF* tiffptr, uint32 a)); /* 129 */ + void (*_TIFFSwab16BitData) _ANSI_ARGS_((TIFF* tiffptr, tidata_t a, tsize_t b)); /* 130 */ + void (*_TIFFSwab32BitData) _ANSI_ARGS_((TIFF* tiffptr, tidata_t b, tsize_t a)); /* 131 */ + void (*_TIFFSwab64BitData) _ANSI_ARGS_((TIFF* tiffptr, tidata_t a, tsize_t b)); /* 132 */ + int (*tIFFFlushData1) _ANSI_ARGS_((TIFF* tiffptr)); /* 133 */ + void (*tIFFFreeDirectory) _ANSI_ARGS_((TIFF* tiffptr)); /* 134 */ + int (*tIFFDefaultDirectory) _ANSI_ARGS_((TIFF* tiffptr)); /* 135 */ + int (*tIFFSetCompressionScheme) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 136 */ + int (*_TIFFSetDefaultCompressionState) _ANSI_ARGS_((TIFF* tiffptr)); /* 137 */ + uint32 (*_TIFFDefaultStripSize) _ANSI_ARGS_((TIFF* tiffptr, uint32 a)); /* 138 */ + void (*_TIFFDefaultTileSize) _ANSI_ARGS_((TIFF* tiffptr, uint32* a, uint32* b)); /* 139 */ + void (*_TIFFsetByteArray) _ANSI_ARGS_((void** a, void* b, long c)); /* 140 */ + void (*_TIFFsetString) _ANSI_ARGS_((char** a, char* b)); /* 141 */ + void (*_TIFFsetShortArray) _ANSI_ARGS_((uint16** a, uint16* b, long c)); /* 142 */ + void (*_TIFFsetLongArray) _ANSI_ARGS_((uint32** a, uint32* b, long c)); /* 143 */ + void (*_TIFFsetFloatArray) _ANSI_ARGS_((float** a, float* b, long c)); /* 144 */ + void (*_TIFFsetDoubleArray) _ANSI_ARGS_((double** a, double* b, long c)); /* 145 */ + void (*_TIFFprintAscii) _ANSI_ARGS_((FILE* a, const char* b)); /* 146 */ + void (*_TIFFprintAsciiTag) _ANSI_ARGS_((FILE* a, const char* b, const char* c)); /* 147 */ + int (*tIFFInitDumpMode) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 148 */ + int (*tIFFInitPackBits) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 149 */ + int (*tIFFInitCCITTRLE) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 150 */ + int (*tIFFInitCCITTRLEW) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 151 */ + int (*tIFFInitCCITTFax3) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 152 */ + int (*tIFFInitCCITTFax4) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 153 */ + int (*tIFFInitThunderScan) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 154 */ + int (*tIFFInitNeXT) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 155 */ + int (*tIFFInitLZW) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 156 */ + int (*tIFFInitOJPEG) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 157 */ + int (*tIFFInitJPEG) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 158 */ + int (*tIFFInitJBIG) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 159 */ + int (*tIFFInitZIP) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 160 */ + int (*tIFFInitPixarLog) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 161 */ + int (*tIFFInitSGILog) _ANSI_ARGS_((TIFF* tiffptr, int a)); /* 162 */ +} TifftclStubs; + +#ifdef __cplusplus +extern "C" { +#endif +extern TifftclStubs *tifftclStubsPtr; +#ifdef __cplusplus +} +#endif + +#if defined(USE_TIFFTCL_STUBS) && !defined(USE_TIFFTCL_STUB_PROCS) + +/* + * Inline function declarations: + */ + +#ifndef TIFFGetVersion +#define TIFFGetVersion \ + (tifftclStubsPtr->tIFFGetVersion) /* 0 */ +#endif +#ifndef TIFFFindCODEC +#define TIFFFindCODEC \ + (tifftclStubsPtr->tIFFFindCODEC) /* 1 */ +#endif +#ifndef TIFFRegisterCODEC +#define TIFFRegisterCODEC \ + (tifftclStubsPtr->tIFFRegisterCODEC) /* 2 */ +#endif +#ifndef TIFFUnRegisterCODEC +#define TIFFUnRegisterCODEC \ + (tifftclStubsPtr->tIFFUnRegisterCODEC) /* 3 */ +#endif +#ifndef _TIFFmalloc +#define _TIFFmalloc \ + (tifftclStubsPtr->_TIFFmalloc) /* 4 */ +#endif +#ifndef _TIFFrealloc +#define _TIFFrealloc \ + (tifftclStubsPtr->_TIFFrealloc) /* 5 */ +#endif +#ifndef _TIFFmemset +#define _TIFFmemset \ + (tifftclStubsPtr->_TIFFmemset) /* 6 */ +#endif +#ifndef _TIFFmemcpy +#define _TIFFmemcpy \ + (tifftclStubsPtr->_TIFFmemcpy) /* 7 */ +#endif +#ifndef _TIFFmemcmp +#define _TIFFmemcmp \ + (tifftclStubsPtr->_TIFFmemcmp) /* 8 */ +#endif +#ifndef _TIFFfree +#define _TIFFfree \ + (tifftclStubsPtr->_TIFFfree) /* 9 */ +#endif +#ifndef TIFFClose +#define TIFFClose \ + (tifftclStubsPtr->tIFFClose) /* 10 */ +#endif +#ifndef TIFFFlush +#define TIFFFlush \ + (tifftclStubsPtr->tIFFFlush) /* 11 */ +#endif +#ifndef TIFFFlushData +#define TIFFFlushData \ + (tifftclStubsPtr->tIFFFlushData) /* 12 */ +#endif +#ifndef TIFFGetField +#define TIFFGetField \ + (tifftclStubsPtr->tIFFGetField) /* 13 */ +#endif +#ifndef TIFFVGetField +#define TIFFVGetField \ + (tifftclStubsPtr->tIFFVGetField) /* 14 */ +#endif +#ifndef TIFFGetFieldDefaulted +#define TIFFGetFieldDefaulted \ + (tifftclStubsPtr->tIFFGetFieldDefaulted) /* 15 */ +#endif +#ifndef TIFFVGetFieldDefaulted +#define TIFFVGetFieldDefaulted \ + (tifftclStubsPtr->tIFFVGetFieldDefaulted) /* 16 */ +#endif +#ifndef TIFFReadDirectory +#define TIFFReadDirectory \ + (tifftclStubsPtr->tIFFReadDirectory) /* 17 */ +#endif +#ifndef TIFFScanlineSize +#define TIFFScanlineSize \ + (tifftclStubsPtr->tIFFScanlineSize) /* 18 */ +#endif +#ifndef TIFFRasterScanlineSize +#define TIFFRasterScanlineSize \ + (tifftclStubsPtr->tIFFRasterScanlineSize) /* 19 */ +#endif +#ifndef TIFFStripSize +#define TIFFStripSize \ + (tifftclStubsPtr->tIFFStripSize) /* 20 */ +#endif +#ifndef TIFFVStripSize +#define TIFFVStripSize \ + (tifftclStubsPtr->tIFFVStripSize) /* 21 */ +#endif +#ifndef TIFFTileRowSize +#define TIFFTileRowSize \ + (tifftclStubsPtr->tIFFTileRowSize) /* 22 */ +#endif +#ifndef TIFFTileSize +#define TIFFTileSize \ + (tifftclStubsPtr->tIFFTileSize) /* 23 */ +#endif +#ifndef TIFFVTileSize +#define TIFFVTileSize \ + (tifftclStubsPtr->tIFFVTileSize) /* 24 */ +#endif +#ifndef TIFFDefaultStripSize +#define TIFFDefaultStripSize \ + (tifftclStubsPtr->tIFFDefaultStripSize) /* 25 */ +#endif +#ifndef TIFFDefaultTileSize +#define TIFFDefaultTileSize \ + (tifftclStubsPtr->tIFFDefaultTileSize) /* 26 */ +#endif +#ifndef TIFFFileno +#define TIFFFileno \ + (tifftclStubsPtr->tIFFFileno) /* 27 */ +#endif +#ifndef TIFFGetMode +#define TIFFGetMode \ + (tifftclStubsPtr->tIFFGetMode) /* 28 */ +#endif +#ifndef TIFFIsTiled +#define TIFFIsTiled \ + (tifftclStubsPtr->tIFFIsTiled) /* 29 */ +#endif +#ifndef TIFFIsByteSwapped +#define TIFFIsByteSwapped \ + (tifftclStubsPtr->tIFFIsByteSwapped) /* 30 */ +#endif +#ifndef TIFFIsUpSampled +#define TIFFIsUpSampled \ + (tifftclStubsPtr->tIFFIsUpSampled) /* 31 */ +#endif +#ifndef TIFFIsMSB2LSB +#define TIFFIsMSB2LSB \ + (tifftclStubsPtr->tIFFIsMSB2LSB) /* 32 */ +#endif +#ifndef TIFFCurrentRow +#define TIFFCurrentRow \ + (tifftclStubsPtr->tIFFCurrentRow) /* 33 */ +#endif +#ifndef TIFFCurrentDirectory +#define TIFFCurrentDirectory \ + (tifftclStubsPtr->tIFFCurrentDirectory) /* 34 */ +#endif +#ifndef TIFFNumberOfDirectories +#define TIFFNumberOfDirectories \ + (tifftclStubsPtr->tIFFNumberOfDirectories) /* 35 */ +#endif +#ifndef TIFFCurrentDirOffset +#define TIFFCurrentDirOffset \ + (tifftclStubsPtr->tIFFCurrentDirOffset) /* 36 */ +#endif +#ifndef TIFFCurrentStrip +#define TIFFCurrentStrip \ + (tifftclStubsPtr->tIFFCurrentStrip) /* 37 */ +#endif +#ifndef TIFFCurrentTile +#define TIFFCurrentTile \ + (tifftclStubsPtr->tIFFCurrentTile) /* 38 */ +#endif +#ifndef TIFFReadBufferSetup +#define TIFFReadBufferSetup \ + (tifftclStubsPtr->tIFFReadBufferSetup) /* 39 */ +#endif +#ifndef TIFFWriteBufferSetup +#define TIFFWriteBufferSetup \ + (tifftclStubsPtr->tIFFWriteBufferSetup) /* 40 */ +#endif +#ifndef TIFFWriteCheck +#define TIFFWriteCheck \ + (tifftclStubsPtr->tIFFWriteCheck) /* 41 */ +#endif +#ifndef TIFFCreateDirectory +#define TIFFCreateDirectory \ + (tifftclStubsPtr->tIFFCreateDirectory) /* 42 */ +#endif +#ifndef TIFFLastDirectory +#define TIFFLastDirectory \ + (tifftclStubsPtr->tIFFLastDirectory) /* 43 */ +#endif +#ifndef TIFFSetDirectory +#define TIFFSetDirectory \ + (tifftclStubsPtr->tIFFSetDirectory) /* 44 */ +#endif +#ifndef TIFFSetSubDirectory +#define TIFFSetSubDirectory \ + (tifftclStubsPtr->tIFFSetSubDirectory) /* 45 */ +#endif +#ifndef TIFFUnlinkDirectory +#define TIFFUnlinkDirectory \ + (tifftclStubsPtr->tIFFUnlinkDirectory) /* 46 */ +#endif +#ifndef TIFFSetField +#define TIFFSetField \ + (tifftclStubsPtr->tIFFSetField) /* 47 */ +#endif +#ifndef TIFFVSetField +#define TIFFVSetField \ + (tifftclStubsPtr->tIFFVSetField) /* 48 */ +#endif +#ifndef TIFFWriteDirectory +#define TIFFWriteDirectory \ + (tifftclStubsPtr->tIFFWriteDirectory) /* 49 */ +#endif +#ifndef TIFFReassignTagToIgnore +#define TIFFReassignTagToIgnore \ + (tifftclStubsPtr->tIFFReassignTagToIgnore) /* 50 */ +#endif +#ifndef TIFFPrintDirectory +#define TIFFPrintDirectory \ + (tifftclStubsPtr->tIFFPrintDirectory) /* 51 */ +#endif +#ifndef TIFFReadScanline +#define TIFFReadScanline \ + (tifftclStubsPtr->tIFFReadScanline) /* 52 */ +#endif +#ifndef TIFFWriteScanline +#define TIFFWriteScanline \ + (tifftclStubsPtr->tIFFWriteScanline) /* 53 */ +#endif +#ifndef TIFFReadRGBAImage +#define TIFFReadRGBAImage \ + (tifftclStubsPtr->tIFFReadRGBAImage) /* 54 */ +#endif +#ifndef TIFFReadRGBAStrip +#define TIFFReadRGBAStrip \ + (tifftclStubsPtr->tIFFReadRGBAStrip) /* 55 */ +#endif +#ifndef TIFFReadRGBATile +#define TIFFReadRGBATile \ + (tifftclStubsPtr->tIFFReadRGBATile) /* 56 */ +#endif +#ifndef TIFFRGBAImageOK +#define TIFFRGBAImageOK \ + (tifftclStubsPtr->tIFFRGBAImageOK) /* 57 */ +#endif +#ifndef TIFFRGBAImageBegin +#define TIFFRGBAImageBegin \ + (tifftclStubsPtr->tIFFRGBAImageBegin) /* 58 */ +#endif +#ifndef TIFFRGBAImageGet +#define TIFFRGBAImageGet \ + (tifftclStubsPtr->tIFFRGBAImageGet) /* 59 */ +#endif +#ifndef TIFFRGBAImageEnd +#define TIFFRGBAImageEnd \ + (tifftclStubsPtr->tIFFRGBAImageEnd) /* 60 */ +#endif +#ifndef TIFFOpen +#define TIFFOpen \ + (tifftclStubsPtr->tIFFOpen) /* 61 */ +#endif +#ifndef TIFFFdOpen +#define TIFFFdOpen \ + (tifftclStubsPtr->tIFFFdOpen) /* 62 */ +#endif +#ifndef TIFFClientOpen +#define TIFFClientOpen \ + (tifftclStubsPtr->tIFFClientOpen) /* 63 */ +#endif +#ifndef TIFFFileName +#define TIFFFileName \ + (tifftclStubsPtr->tIFFFileName) /* 64 */ +#endif +#ifndef TIFFError +#define TIFFError \ + (tifftclStubsPtr->tIFFError) /* 65 */ +#endif +#ifndef TIFFWarning +#define TIFFWarning \ + (tifftclStubsPtr->tIFFWarning) /* 66 */ +#endif +#ifndef TIFFSetErrorHandler +#define TIFFSetErrorHandler \ + (tifftclStubsPtr->tIFFSetErrorHandler) /* 67 */ +#endif +#ifndef TIFFSetWarningHandler +#define TIFFSetWarningHandler \ + (tifftclStubsPtr->tIFFSetWarningHandler) /* 68 */ +#endif +#ifndef TIFFSetTagExtender +#define TIFFSetTagExtender \ + (tifftclStubsPtr->tIFFSetTagExtender) /* 69 */ +#endif +#ifndef TIFFComputeTile +#define TIFFComputeTile \ + (tifftclStubsPtr->tIFFComputeTile) /* 70 */ +#endif +#ifndef TIFFCheckTile +#define TIFFCheckTile \ + (tifftclStubsPtr->tIFFCheckTile) /* 71 */ +#endif +#ifndef TIFFNumberOfTiles +#define TIFFNumberOfTiles \ + (tifftclStubsPtr->tIFFNumberOfTiles) /* 72 */ +#endif +#ifndef TIFFReadTile +#define TIFFReadTile \ + (tifftclStubsPtr->tIFFReadTile) /* 73 */ +#endif +#ifndef TIFFWriteTile +#define TIFFWriteTile \ + (tifftclStubsPtr->tIFFWriteTile) /* 74 */ +#endif +#ifndef TIFFComputeStrip +#define TIFFComputeStrip \ + (tifftclStubsPtr->tIFFComputeStrip) /* 75 */ +#endif +#ifndef TIFFNumberOfStrips +#define TIFFNumberOfStrips \ + (tifftclStubsPtr->tIFFNumberOfStrips) /* 76 */ +#endif +#ifndef TIFFReadEncodedStrip +#define TIFFReadEncodedStrip \ + (tifftclStubsPtr->tIFFReadEncodedStrip) /* 77 */ +#endif +#ifndef TIFFReadRawStrip +#define TIFFReadRawStrip \ + (tifftclStubsPtr->tIFFReadRawStrip) /* 78 */ +#endif +#ifndef TIFFReadEncodedTile +#define TIFFReadEncodedTile \ + (tifftclStubsPtr->tIFFReadEncodedTile) /* 79 */ +#endif +#ifndef TIFFReadRawTile +#define TIFFReadRawTile \ + (tifftclStubsPtr->tIFFReadRawTile) /* 80 */ +#endif +#ifndef TIFFWriteEncodedStrip +#define TIFFWriteEncodedStrip \ + (tifftclStubsPtr->tIFFWriteEncodedStrip) /* 81 */ +#endif +#ifndef TIFFWriteRawStrip +#define TIFFWriteRawStrip \ + (tifftclStubsPtr->tIFFWriteRawStrip) /* 82 */ +#endif +#ifndef TIFFWriteEncodedTile +#define TIFFWriteEncodedTile \ + (tifftclStubsPtr->tIFFWriteEncodedTile) /* 83 */ +#endif +#ifndef TIFFWriteRawTile +#define TIFFWriteRawTile \ + (tifftclStubsPtr->tIFFWriteRawTile) /* 84 */ +#endif +#ifndef TIFFSetWriteOffset +#define TIFFSetWriteOffset \ + (tifftclStubsPtr->tIFFSetWriteOffset) /* 85 */ +#endif +#ifndef TIFFSwabShort +#define TIFFSwabShort \ + (tifftclStubsPtr->tIFFSwabShort) /* 86 */ +#endif +#ifndef TIFFSwabLong +#define TIFFSwabLong \ + (tifftclStubsPtr->tIFFSwabLong) /* 87 */ +#endif +#ifndef TIFFSwabDouble +#define TIFFSwabDouble \ + (tifftclStubsPtr->tIFFSwabDouble) /* 88 */ +#endif +#ifndef TIFFSwabArrayOfShort +#define TIFFSwabArrayOfShort \ + (tifftclStubsPtr->tIFFSwabArrayOfShort) /* 89 */ +#endif +#ifndef TIFFSwabArrayOfLong +#define TIFFSwabArrayOfLong \ + (tifftclStubsPtr->tIFFSwabArrayOfLong) /* 90 */ +#endif +#ifndef TIFFSwabArrayOfDouble +#define TIFFSwabArrayOfDouble \ + (tifftclStubsPtr->tIFFSwabArrayOfDouble) /* 91 */ +#endif +#ifndef TIFFReverseBits +#define TIFFReverseBits \ + (tifftclStubsPtr->tIFFReverseBits) /* 92 */ +#endif +#ifndef TIFFGetBitRevTable +#define TIFFGetBitRevTable \ + (tifftclStubsPtr->tIFFGetBitRevTable) /* 93 */ +#endif +/* Slot 94 is reserved */ +/* Slot 95 is reserved */ +/* Slot 96 is reserved */ +/* Slot 97 is reserved */ +/* Slot 98 is reserved */ +/* Slot 99 is reserved */ +#ifndef TIFFPredictorInit +#define TIFFPredictorInit \ + (tifftclStubsPtr->tIFFPredictorInit) /* 100 */ +#endif +/* Slot 101 is reserved */ +/* Slot 102 is reserved */ +/* Slot 103 is reserved */ +/* Slot 104 is reserved */ +/* Slot 105 is reserved */ +/* Slot 106 is reserved */ +/* Slot 107 is reserved */ +/* Slot 108 is reserved */ +/* Slot 109 is reserved */ +#ifndef _TIFFSetupFieldInfo +#define _TIFFSetupFieldInfo \ + (tifftclStubsPtr->_TIFFSetupFieldInfo) /* 110 */ +#endif +#ifndef TIFFMergeFieldInfo +#define TIFFMergeFieldInfo \ + (tifftclStubsPtr->tIFFMergeFieldInfo) /* 111 */ +#endif +#ifndef _TIFFPrintFieldInfo +#define _TIFFPrintFieldInfo \ + (tifftclStubsPtr->_TIFFPrintFieldInfo) /* 112 */ +#endif +#ifndef TIFFFindFieldInfo +#define TIFFFindFieldInfo \ + (tifftclStubsPtr->tIFFFindFieldInfo) /* 113 */ +#endif +#ifndef TIFFFieldWithTag +#define TIFFFieldWithTag \ + (tifftclStubsPtr->tIFFFieldWithTag) /* 114 */ +#endif +#ifndef _TIFFSampleToTagType +#define _TIFFSampleToTagType \ + (tifftclStubsPtr->_TIFFSampleToTagType) /* 115 */ +#endif +/* Slot 116 is reserved */ +/* Slot 117 is reserved */ +/* Slot 118 is reserved */ +/* Slot 119 is reserved */ +#ifndef _TIFFgetMode +#define _TIFFgetMode \ + (tifftclStubsPtr->_TIFFgetMode) /* 120 */ +#endif +#ifndef _TIFFNoRowEncode +#define _TIFFNoRowEncode \ + (tifftclStubsPtr->_TIFFNoRowEncode) /* 121 */ +#endif +#ifndef _TIFFNoStripEncode +#define _TIFFNoStripEncode \ + (tifftclStubsPtr->_TIFFNoStripEncode) /* 122 */ +#endif +#ifndef _TIFFNoTileEncode +#define _TIFFNoTileEncode \ + (tifftclStubsPtr->_TIFFNoTileEncode) /* 123 */ +#endif +#ifndef _TIFFNoRowDecode +#define _TIFFNoRowDecode \ + (tifftclStubsPtr->_TIFFNoRowDecode) /* 124 */ +#endif +#ifndef _TIFFNoStripDecode +#define _TIFFNoStripDecode \ + (tifftclStubsPtr->_TIFFNoStripDecode) /* 125 */ +#endif +#ifndef _TIFFNoTileDecode +#define _TIFFNoTileDecode \ + (tifftclStubsPtr->_TIFFNoTileDecode) /* 126 */ +#endif +#ifndef _TIFFNoPostDecode +#define _TIFFNoPostDecode \ + (tifftclStubsPtr->_TIFFNoPostDecode) /* 127 */ +#endif +#ifndef _TIFFNoPreCode +#define _TIFFNoPreCode \ + (tifftclStubsPtr->_TIFFNoPreCode) /* 128 */ +#endif +#ifndef _TIFFNoSeek +#define _TIFFNoSeek \ + (tifftclStubsPtr->_TIFFNoSeek) /* 129 */ +#endif +#ifndef _TIFFSwab16BitData +#define _TIFFSwab16BitData \ + (tifftclStubsPtr->_TIFFSwab16BitData) /* 130 */ +#endif +#ifndef _TIFFSwab32BitData +#define _TIFFSwab32BitData \ + (tifftclStubsPtr->_TIFFSwab32BitData) /* 131 */ +#endif +#ifndef _TIFFSwab64BitData +#define _TIFFSwab64BitData \ + (tifftclStubsPtr->_TIFFSwab64BitData) /* 132 */ +#endif +#ifndef TIFFFlushData1 +#define TIFFFlushData1 \ + (tifftclStubsPtr->tIFFFlushData1) /* 133 */ +#endif +#ifndef TIFFFreeDirectory +#define TIFFFreeDirectory \ + (tifftclStubsPtr->tIFFFreeDirectory) /* 134 */ +#endif +#ifndef TIFFDefaultDirectory +#define TIFFDefaultDirectory \ + (tifftclStubsPtr->tIFFDefaultDirectory) /* 135 */ +#endif +#ifndef TIFFSetCompressionScheme +#define TIFFSetCompressionScheme \ + (tifftclStubsPtr->tIFFSetCompressionScheme) /* 136 */ +#endif +#ifndef _TIFFSetDefaultCompressionState +#define _TIFFSetDefaultCompressionState \ + (tifftclStubsPtr->_TIFFSetDefaultCompressionState) /* 137 */ +#endif +#ifndef _TIFFDefaultStripSize +#define _TIFFDefaultStripSize \ + (tifftclStubsPtr->_TIFFDefaultStripSize) /* 138 */ +#endif +#ifndef _TIFFDefaultTileSize +#define _TIFFDefaultTileSize \ + (tifftclStubsPtr->_TIFFDefaultTileSize) /* 139 */ +#endif +#ifndef _TIFFsetByteArray +#define _TIFFsetByteArray \ + (tifftclStubsPtr->_TIFFsetByteArray) /* 140 */ +#endif +#ifndef _TIFFsetString +#define _TIFFsetString \ + (tifftclStubsPtr->_TIFFsetString) /* 141 */ +#endif +#ifndef _TIFFsetShortArray +#define _TIFFsetShortArray \ + (tifftclStubsPtr->_TIFFsetShortArray) /* 142 */ +#endif +#ifndef _TIFFsetLongArray +#define _TIFFsetLongArray \ + (tifftclStubsPtr->_TIFFsetLongArray) /* 143 */ +#endif +#ifndef _TIFFsetFloatArray +#define _TIFFsetFloatArray \ + (tifftclStubsPtr->_TIFFsetFloatArray) /* 144 */ +#endif +#ifndef _TIFFsetDoubleArray +#define _TIFFsetDoubleArray \ + (tifftclStubsPtr->_TIFFsetDoubleArray) /* 145 */ +#endif +#ifndef _TIFFprintAscii +#define _TIFFprintAscii \ + (tifftclStubsPtr->_TIFFprintAscii) /* 146 */ +#endif +#ifndef _TIFFprintAsciiTag +#define _TIFFprintAsciiTag \ + (tifftclStubsPtr->_TIFFprintAsciiTag) /* 147 */ +#endif +#ifndef TIFFInitDumpMode +#define TIFFInitDumpMode \ + (tifftclStubsPtr->tIFFInitDumpMode) /* 148 */ +#endif +#ifndef TIFFInitPackBits +#define TIFFInitPackBits \ + (tifftclStubsPtr->tIFFInitPackBits) /* 149 */ +#endif +#ifndef TIFFInitCCITTRLE +#define TIFFInitCCITTRLE \ + (tifftclStubsPtr->tIFFInitCCITTRLE) /* 150 */ +#endif +#ifndef TIFFInitCCITTRLEW +#define TIFFInitCCITTRLEW \ + (tifftclStubsPtr->tIFFInitCCITTRLEW) /* 151 */ +#endif +#ifndef TIFFInitCCITTFax3 +#define TIFFInitCCITTFax3 \ + (tifftclStubsPtr->tIFFInitCCITTFax3) /* 152 */ +#endif +#ifndef TIFFInitCCITTFax4 +#define TIFFInitCCITTFax4 \ + (tifftclStubsPtr->tIFFInitCCITTFax4) /* 153 */ +#endif +#ifndef TIFFInitThunderScan +#define TIFFInitThunderScan \ + (tifftclStubsPtr->tIFFInitThunderScan) /* 154 */ +#endif +#ifndef TIFFInitNeXT +#define TIFFInitNeXT \ + (tifftclStubsPtr->tIFFInitNeXT) /* 155 */ +#endif +#ifndef TIFFInitLZW +#define TIFFInitLZW \ + (tifftclStubsPtr->tIFFInitLZW) /* 156 */ +#endif +#ifndef TIFFInitOJPEG +#define TIFFInitOJPEG \ + (tifftclStubsPtr->tIFFInitOJPEG) /* 157 */ +#endif +#ifndef TIFFInitJPEG +#define TIFFInitJPEG \ + (tifftclStubsPtr->tIFFInitJPEG) /* 158 */ +#endif +#ifndef TIFFInitJBIG +#define TIFFInitJBIG \ + (tifftclStubsPtr->tIFFInitJBIG) /* 159 */ +#endif +#ifndef TIFFInitZIP +#define TIFFInitZIP \ + (tifftclStubsPtr->tIFFInitZIP) /* 160 */ +#endif +#ifndef TIFFInitPixarLog +#define TIFFInitPixarLog \ + (tifftclStubsPtr->tIFFInitPixarLog) /* 161 */ +#endif +#ifndef TIFFInitSGILog +#define TIFFInitSGILog \ + (tifftclStubsPtr->tIFFInitSGILog) /* 162 */ +#endif + +#endif /* defined(USE_TIFFTCL_STUBS) && !defined(USE_TIFFTCL_STUB_PROCS) */ + +/* !END!: Do not edit above this line. */ + +#endif /* _TIFFTCLDECLS */ + diff --git a/mingw/include/tifftclDeclsMask.h b/mingw/include/tifftclDeclsMask.h new file mode 100644 index 00000000..47d487e1 --- /dev/null +++ b/mingw/include/tifftclDeclsMask.h @@ -0,0 +1,154 @@ +#ifdef WIN32 +/* + * While the definitions in the original header are technically the + * same as the definitions in 'zlibDecls.h' on Windows they are not, + * in a small detail: DLLEXPORT vs. DLLIMPORT. As our artificial + * definitions do the right thing we use the macro definitions below + * to move the original definitionsd out of the way. We do retain the + * inclusion of all the type definitions, etc. + */ +#define TIFFGetVersion __mask_TIFFGetVersion +#define TIFFFindCODEC __mask_TIFFFindCODEC +#define TIFFRegisterCODEC __mask_TIFFRegisterCODEC +#define TIFFUnRegisterCODEC __mask_TIFFUnRegisterCODEC +#define _TIFFmalloc __mask__TIFFmalloc +#define _TIFFrealloc __mask__TIFFrealloc +#define _TIFFmemset __mask__TIFFmemset +#define _TIFFmemcpy __mask__TIFFmemcpy +#define _TIFFmemcmp __mask__TIFFmemcmp +#define _TIFFfree __mask__TIFFfree +#define TIFFClose __mask_TIFFClose +#define TIFFFlush __mask_TIFFFlush +#define TIFFFlushData __mask_TIFFFlushData +#define TIFFGetField __mask_TIFFGetField +#define TIFFVGetField __mask_TIFFVGetField +#define TIFFGetFieldDefaulted __mask_TIFFGetFieldDefaulted +#define TIFFVGetFieldDefaulted __mask_TIFFVGetFieldDefaulted +#define TIFFReadDirectory __mask_TIFFReadDirectory +#define TIFFScanlineSize __mask_TIFFScanlineSize +#define TIFFRasterScanlineSize __mask_TIFFRasterScanlineSize +#define TIFFStripSize __mask_TIFFStripSize +#define TIFFVStripSize __mask_TIFFVStripSize +#define TIFFTileRowSize __mask_TIFFTileRowSize +#define TIFFTileSize __mask_TIFFTileSize +#define TIFFVTileSize __mask_TIFFVTileSize +#define TIFFDefaultStripSize __mask_TIFFDefaultStripSize +#define TIFFDefaultTileSize __mask_TIFFDefaultTileSize +#define TIFFFileno __mask_TIFFFileno +#define TIFFGetMode __mask_TIFFGetMode +#define TIFFIsTiled __mask_TIFFIsTiled +#define TIFFIsByteSwapped __mask_TIFFIsByteSwapped +#define TIFFIsUpSampled __mask_TIFFIsUpSampled +#define TIFFIsMSB2LSB __mask_TIFFIsMSB2LSB +#define TIFFCurrentRow __mask_TIFFCurrentRow +#define TIFFCurrentDirectory __mask_TIFFCurrentDirectory +#define TIFFNumberOfDirectories __mask_TIFFNumberOfDirectories +#define TIFFCurrentDirOffset __mask_TIFFCurrentDirOffset +#define TIFFCurrentStrip __mask_TIFFCurrentStrip +#define TIFFCurrentTile __mask_TIFFCurrentTile +#define TIFFReadBufferSetup __mask_TIFFReadBufferSetup +#define TIFFWriteBufferSetup __mask_TIFFWriteBufferSetup +#define TIFFWriteCheck __mask_TIFFWriteCheck +#define TIFFCreateDirectory __mask_TIFFCreateDirectory +#define TIFFLastDirectory __mask_TIFFLastDirectory +#define TIFFSetDirectory __mask_TIFFSetDirectory +#define TIFFSetSubDirectory __mask_TIFFSetSubDirectory +#define TIFFUnlinkDirectory __mask_TIFFUnlinkDirectory +#define TIFFSetField __mask_TIFFSetField +#define TIFFVSetField __mask_TIFFVSetField +#define TIFFWriteDirectory __mask_TIFFWriteDirectory +#define TIFFReassignTagToIgnore __mask_TIFFReassignTagToIgnore +#define TIFFPrintDirectory __mask_TIFFPrintDirectory +#define TIFFReadScanline __mask_TIFFReadScanline +#define TIFFWriteScanline __mask_TIFFWriteScanline +#define TIFFReadRGBAImage __mask_TIFFReadRGBAImage +#define TIFFReadRGBAStrip __mask_TIFFReadRGBAStrip +#define TIFFReadRGBATile __mask_TIFFReadRGBATile +#define TIFFRGBAImageOK __mask_TIFFRGBAImageOK +#define TIFFRGBAImageBegin __mask_TIFFRGBAImageBegin +#define TIFFRGBAImageGet __mask_TIFFRGBAImageGet +#define TIFFRGBAImageEnd __mask_TIFFRGBAImageEnd +#define TIFFOpen __mask_TIFFOpen +#define TIFFFdOpen __mask_TIFFFdOpen +#define TIFFClientOpen __mask_TIFFClientOpen +#define TIFFFileName __mask_TIFFFileName +#define TIFFError __mask_TIFFError +#define TIFFWarning __mask_TIFFWarning +#define TIFFSetErrorHandler __mask_TIFFSetErrorHandler +#define TIFFSetWarningHandler __mask_TIFFSetWarningHandler +#define TIFFSetTagExtender __mask_TIFFSetTagExtender +#define TIFFComputeTile __mask_TIFFComputeTile +#define TIFFCheckTile __mask_TIFFCheckTile +#define TIFFNumberOfTiles __mask_TIFFNumberOfTiles +#define TIFFReadTile __mask_TIFFReadTile +#define TIFFWriteTile __mask_TIFFWriteTile +#define TIFFComputeStrip __mask_TIFFComputeStrip +#define TIFFNumberOfStrips __mask_TIFFNumberOfStrips +#define TIFFReadEncodedStrip __mask_TIFFReadEncodedStrip +#define TIFFReadRawStrip __mask_TIFFReadRawStrip +#define TIFFReadEncodedTile __mask_TIFFReadEncodedTile +#define TIFFReadRawTile __mask_TIFFReadRawTile +#define TIFFWriteEncodedStrip __mask_TIFFWriteEncodedStrip +#define TIFFWriteRawStrip __mask_TIFFWriteRawStrip +#define TIFFWriteEncodedTile __mask_TIFFWriteEncodedTile +#define TIFFWriteRawTile __mask_TIFFWriteRawTile +#define TIFFSetWriteOffset __mask_TIFFSetWriteOffset +#define TIFFSwabShort __mask_TIFFSwabShort +#define TIFFSwabLong __mask_TIFFSwabLong +#define TIFFSwabDouble __mask_TIFFSwabDouble +#define TIFFSwabArrayOfShort __mask_TIFFSwabArrayOfShort +#define TIFFSwabArrayOfLong __mask_TIFFSwabArrayOfLong +#define TIFFSwabArrayOfDouble __mask_TIFFSwabArrayOfDouble +#define TIFFReverseBits __mask_TIFFReverseBits +#define TIFFGetBitRevTable __mask_TIFFGetBitRevTable +#define TIFFPredictorInit __mask_TIFFPredictorInit +#define _TIFFSetupFieldInfo __mask__TIFFSetupFieldInfo +#define TIFFMergeFieldInfo __mask__TIFFMergeFieldInfo +#define _TIFFPrintFieldInfo __mask__TIFFPrintFieldInfo +#define TIFFFindFieldInfo __mask__TIFFFindFieldInfo +#define TIFFFieldWithTag __mask__TIFFFieldWithTag +#define _TIFFSampleToTagType __mask__TIFFSampleToTagType +#define _TIFFgetMode __mask__TIFFgetMode +#define _TIFFNoRowEncode __mask__TIFFNoRowEncode +#define _TIFFNoStripEncode __mask__TIFFNoStripEncode +#define _TIFFNoTileEncode __mask__TIFFNoTileEncode +#define _TIFFNoRowDecode __mask__TIFFNoRowDecode +#define _TIFFNoStripDecode __mask__TIFFNoStripDecode +#define _TIFFNoTileDecode __mask__TIFFNoTileDecode +#define _TIFFNoPostDecode __mask__TIFFNoPostDecode +#define _TIFFNoPreCode __mask__TIFFNoPreCode +#define _TIFFNoSeek __mask__TIFFNoSeek +#define _TIFFSwab16BitData __mask__TIFFSwab16BitData +#define _TIFFSwab32BitData __mask__TIFFSwab32BitData +#define _TIFFSwab64BitData __mask__TIFFSwab64BitData +#define TIFFFlushData1 __mask_TIFFFlushData1 +#define TIFFFreeDirectory __mask_TIFFFreeDirectory +#define TIFFDefaultDirectory __mask_TIFFDefaultDirectory +#define TIFFSetCompressionScheme __mask_TIFFSetCompressionScheme +#define TIFFSetDefaultCompressionState __mask_TIFFSetDefaultCompressionState +#define _TIFFDefaultStripSize __mask__TIFFDefaultStripSize +#define _TIFFDefaultTileSize __mask__TIFFDefaultTileSize +#define _TIFFsetByteArray __mask__TIFFsetByteArray +#define _TIFFsetString __mask__TIFFsetString +#define _TIFFsetShortArray __mask__TIFFsetShortArray +#define _TIFFsetLongArray __mask__TIFFsetLongArray +#define _TIFFsetFloatArray __mask__TIFFsetFloatArray +#define _TIFFsetDoubleArray __mask__TIFFsetDoubleArray +#define _TIFFprintAscii __mask__TIFFprintAscii +#define _TIFFprintAsciiTag __mask__TIFFprintAsciiTag +#define TIFFInitDumpMode __mask_TIFFInitDumpMode +#define TIFFInitPackBits __mask_TIFFInitPackBits +#define TIFFInitCCITTRLE __mask_TIFFInitCCITTRLE +#define TIFFInitCCITTRLEW __mask_TIFFInitCCITTRLEW +#define TIFFInitCCITTFax3 __mask_TIFFInitCCITTFax3 +#define TIFFInitCCITTFax4 __mask_TIFFInitCCITTFax4 +#define TIFFInitThunderScan __mask_TIFFInitThunderScan +#define TIFFInitNeXT __mask_TIFFInitNeXT +#define TIFFInitLZW __mask_TIFFInitLZW +#define TIFFInitOJPEG __mask_TIFFInitOJPEG +#define TIFFInitJPEG __mask_TIFFInitJPEG +#define TIFFInitJBIG __mask_TIFFInitJBIG +#define TIFFInitZIP __mask_TIFFInitZIP +#define TIFFInitPixarLog __mask_TIFFInitPixarLog +#define TIFFInitSGILog __mask_TIFFInitSGILog +#endif /* WIN32 */ diff --git a/mingw/include/tifftclDeclsUnmask.h b/mingw/include/tifftclDeclsUnmask.h new file mode 100644 index 00000000..4dd05f9e --- /dev/null +++ b/mingw/include/tifftclDeclsUnmask.h @@ -0,0 +1,147 @@ +#ifdef WIN32 +/* Restore the usage of the original names */ +#undef TIFFGetVersion +#undef TIFFFindCODEC +#undef TIFFRegisterCODEC +#undef TIFFUnRegisterCODEC +#undef _TIFFmalloc +#undef _TIFFrealloc +#undef _TIFFmemset +#undef _TIFFmemcpy +#undef _TIFFmemcmp +#undef _TIFFfree +#undef TIFFClose +#undef TIFFFlush +#undef TIFFFlushData +#undef TIFFGetField +#undef TIFFVGetField +#undef TIFFGetFieldDefaulted +#undef TIFFVGetFieldDefaulted +#undef TIFFReadDirectory +#undef TIFFScanlineSize +#undef TIFFRasterScanlineSize +#undef TIFFStripSize +#undef TIFFVStripSize +#undef TIFFTileRowSize +#undef TIFFTileSize +#undef TIFFVTileSize +#undef TIFFDefaultStripSize +#undef TIFFDefaultTileSize +#undef TIFFFileno +#undef TIFFGetMode +#undef TIFFIsTiled +#undef TIFFIsByteSwapped +#undef TIFFIsUpSampled +#undef TIFFIsMSB2LSB +#undef TIFFCurrentRow +#undef TIFFCurrentDirectory +#undef TIFFNumberOfDirectories +#undef TIFFCurrentDirOffset +#undef TIFFCurrentStrip +#undef TIFFCurrentTile +#undef TIFFReadBufferSetup +#undef TIFFWriteBufferSetup +#undef TIFFWriteCheck +#undef TIFFCreateDirectory +#undef TIFFLastDirectory +#undef TIFFSetDirectory +#undef TIFFSetSubDirectory +#undef TIFFUnlinkDirectory +#undef TIFFSetField +#undef TIFFVSetField +#undef TIFFWriteDirectory +#undef TIFFReassignTagToIgnore +#undef TIFFPrintDirectory +#undef TIFFReadScanline +#undef TIFFWriteScanline +#undef TIFFReadRGBAImage +#undef TIFFReadRGBAStrip +#undef TIFFReadRGBATile +#undef TIFFRGBAImageOK +#undef TIFFRGBAImageBegin +#undef TIFFRGBAImageGet +#undef TIFFRGBAImageEnd +#undef TIFFOpen +#undef TIFFFdOpen +#undef TIFFClientOpen +#undef TIFFFileName +#undef TIFFError +#undef TIFFWarning +#undef TIFFSetErrorHandler +#undef TIFFSetWarningHandler +#undef TIFFSetTagExtender +#undef TIFFComputeTile +#undef TIFFCheckTile +#undef TIFFNumberOfTiles +#undef TIFFReadTile +#undef TIFFWriteTile +#undef TIFFComputeStrip +#undef TIFFNumberOfStrips +#undef TIFFReadEncodedStrip +#undef TIFFReadRawStrip +#undef TIFFReadEncodedTile +#undef TIFFReadRawTile +#undef TIFFWriteEncodedStrip +#undef TIFFWriteRawStrip +#undef TIFFWriteEncodedTile +#undef TIFFWriteRawTile +#undef TIFFSetWriteOffset +#undef TIFFSwabShort +#undef TIFFSwabLong +#undef TIFFSwabDouble +#undef TIFFSwabArrayOfShort +#undef TIFFSwabArrayOfLong +#undef TIFFSwabArrayOfDouble +#undef TIFFReverseBits +#undef TIFFGetBitRevTable +#undef TIFFPredictorInit +#undef _TIFFSetupFieldInfo +#undef TIFFMergeFieldInfo +#undef _TIFFPrintFieldInfo +#undef TIFFFindFieldInfo +#undef TIFFFieldWithTag +#undef _TIFFSampleToTagType +#undef _TIFFgetMode +#undef _TIFFNoRowEncode +#undef _TIFFNoStripEncode +#undef _TIFFNoTileEncode +#undef _TIFFNoRowDecode +#undef _TIFFNoStripDecode +#undef _TIFFNoTileDecode +#undef _TIFFNoPostDecode +#undef _TIFFNoPreCode +#undef _TIFFNoSeek +#undef _TIFFSwab16BitData +#undef _TIFFSwab32BitData +#undef _TIFFSwab64BitData +#undef TIFFFlushData1 +#undef TIFFFreeDirectory +#undef TIFFDefaultDirectory +#undef TIFFSetCompressionScheme +#undef TIFFSetDefaultCompressionState +#undef _TIFFDefaultStripSize +#undef _TIFFDefaultTileSize +#undef _TIFFsetByteArray +#undef _TIFFsetString +#undef _TIFFsetShortArray +#undef _TIFFsetLongArray +#undef _TIFFsetFloatArray +#undef _TIFFsetDoubleArray +#undef _TIFFprintAscii +#undef _TIFFprintAsciiTag +#undef TIFFInitDumpMode +#undef TIFFInitPackBits +#undef TIFFInitCCITTRLE +#undef TIFFInitCCITTRLEW +#undef TIFFInitCCITTFax3 +#undef TIFFInitCCITTFax4 +#undef TIFFInitThunderScan +#undef TIFFInitNeXT +#undef TIFFInitLZW +#undef TIFFInitOJPEG +#undef TIFFInitJPEG +#undef TIFFInitJBIG +#undef TIFFInitZIP +#undef TIFFInitPixarLog +#undef TIFFInitSGILog +#endif /* WIN32 */ diff --git a/mingw/include/tkimg.h b/mingw/include/tkimg.h new file mode 100644 index 00000000..8d6d7232 --- /dev/null +++ b/mingw/include/tkimg.h @@ -0,0 +1,193 @@ +/* + * tkimg.h -- + * + * Interface to tkimg Base package. + * + * Copyright (c) 2002 Andreas Kupries + * + * Zveno Pty Ltd makes this software and associated documentation + * available free of charge for any purpose. You may make copies + * of the software but you must include all of this notice on any copy. + * + * Zveno Pty Ltd does not warrant that this software is error free + * or fit for any purpose. Zveno Pty Ltd disclaims any liability for + * all claims, expenses, losses, damages and costs any user may incur + * as a result of using, copying or modifying the software. + * + * $Id: tkimg.h,v 1.4 2004/06/03 21:54:42 andreas_kupries Exp $ + * + */ + +#ifndef __TKIMG_H__ +#define __TKIMG_H__ + +#include /* stdout, and other definitions */ +#include "tk.h" + +/* + * Used to block the rest of this header file from resource compilers so + * we can just get the version info. + */ +#ifndef RC_INVOKED + +/* TIP 27 update. If CONST84 is not defined we are compiling against a + * core before 8.4 and have to disable some CONST'ness. + */ + +#ifndef CONST84 +# define CONST84 +#endif + +/* + * Fix the Borland bug that's in the EXTERN macro from tcl.h. + */ +#ifndef TCL_EXTERN +# undef DLLIMPORT +# undef DLLEXPORT +# if defined(STATIC_BUILD) +# define DLLIMPORT +# define DLLEXPORT +# elif (defined(__WIN32__) && (defined(_MSC_VER) || (__BORLANDC__ >= 0x0550) || (defined(__GNUC__) && defined(__declspec)))) || (defined(MAC_TCL) && FUNCTION_DECLSPEC) +# define DLLIMPORT __declspec(dllimport) +# define DLLEXPORT __declspec(dllexport) +# elif defined(__BORLANDC__) +# define OLDBORLAND 1 +# define DLLIMPORT __import +# define DLLEXPORT __export +# else +# define DLLIMPORT +# define DLLEXPORT +# endif + /* Avoid name mangling from C++ compilers. */ +# ifdef __cplusplus +# define TCL_EXTRNC extern "C" +# else +# define TCL_EXTRNC extern +# endif + /* Pre-5.5 Borland requires the attributes be placed after the */ + /* return type. */ +# ifdef OLDBORLAND +# define TCL_EXTERN(RTYPE) TCL_EXTRNC RTYPE TCL_STORAGE_CLASS +# else +# define TCL_EXTERN(RTYPE) TCL_EXTRNC TCL_STORAGE_CLASS RTYPE +# endif +#endif + +/* + * These macros are used to control whether functions are being declared for + * import or export in Windows, + * They map to no-op declarations on non-Windows systems. + * Assumes that tcl.h defines DLLEXPORT & DLLIMPORT correctly. + * The default build on windows is for a DLL, which causes the DLLIMPORT + * and DLLEXPORT macros to be nonempty. To build a static library, the + * macro STATIC_BUILD should be defined before the inclusion of tcl.h + * + * If a function is being declared while it is being built + * to be included in a shared library, then it should have the DLLEXPORT + * storage class. If is being declared for use by a module that is going to + * link against the shared library, then it should have the DLLIMPORT storage + * class. If the symbol is beind declared for a static build or for use from a + * stub library, then the storage class should be empty. + * + * The convention is that a macro called BUILD_xxxx, where xxxx is the + * name of a library we are building, is set on the compile line for sources + * that are to be placed in the library. When this macro is set, the + * storage class will be set to DLLEXPORT. At the end of the header file, the + * storage class will be reset to DLLIMPORt. + */ + +#undef TCL_STORAGE_CLASS +#ifdef BUILD_tkimg +# define TCL_STORAGE_CLASS DLLEXPORT +#else +# ifdef USE_TKIMG_STUBS +# define TCL_STORAGE_CLASS +# else +# define TCL_STORAGE_CLASS DLLIMPORT +# endif +#endif + +/* + *---------------------------------------------------------------------------- + * C API for Tkimg generic layer + *---------------------------------------------------------------------------- + */ + +typedef struct tkimg_MFile { + Tcl_DString *buffer;/* pointer to dynamical string */ + char *data; /* mmencoded source string */ + int c; /* bits left over from previous char */ + int state; /* decoder state (0-4 or IMG_DONE) */ + int length; /* length of physical line already written */ +} tkimg_MFile; + +#define IMG_SPECIAL (1<<8) +#define IMG_PAD (IMG_SPECIAL+1) +#define IMG_SPACE (IMG_SPECIAL+2) +#define IMG_BAD (IMG_SPECIAL+3) +#define IMG_DONE (IMG_SPECIAL+4) +#define IMG_CHAN (IMG_SPECIAL+5) +#define IMG_STRING (IMG_SPECIAL+6) + +#define IMG_TCL (1<<9) +#define IMG_OBJS (1<<10) +#define IMG_PERL (1<<11) +#define IMG_UTF (1<<12) +#define IMG_NEWPHOTO (1<<13) + +/* + *---------------------------------------------------------------------------- + * Function prototypes for publically accessible routines + *---------------------------------------------------------------------------- + */ + +#include "tkimgDecls.h" + +/* + * Convenience macro dealing with the 8.3 / 8.4 difference regarding + * the signature of Tk_PhotoPutBlock [TIP 98]. + * + * Note: The current implementation makes this a compile time decision. + * In the future we might realize a runtime decision instead. + */ + +#if (TK_MAJOR_VERSION > 8) || ((TK_MAJOR_VERSION == 8) && (TK_MINOR_VERSION > 4)) +/* TIP 116 */ +#define tkimg_PhotoPutBlockTk(interp,hdl,b,x,y,w,h) Tk_PhotoPutBlock(interp,hdl, b, x, y, w, h, TK_PHOTO_COMPOSITE_OVERLAY) +#elif (TK_MAJOR_VERSION > 8) || ((TK_MAJOR_VERSION == 8) && (TK_MINOR_VERSION > 3)) +#define tkimg_PhotoPutBlockTk(interp,hdl,b,x,y,w,h) Tk_PhotoPutBlock(hdl, b, x, y, w, h, TK_PHOTO_COMPOSITE_OVERLAY) +#else +#define tkimg_PhotoPutBlockTk(interp,hdl,b,x,y,w,h) Tk_PhotoPutBlock(hdl, b, x, y, w, h) +#endif + +#if (TK_MAJOR_VERSION > 8) || ((TK_MAJOR_VERSION == 8) && (TK_MINOR_VERSION > 4)) +#define tkimg_PhotoExpand(hdl,interp,w,h) Tk_PhotoExpand(interp, hdl, w, h) +#define tkimg_PhotoSetSize(interp,hdl,w,h) Tk_PhotoSetSize(interp, hdl, w, h) +#else +#define tkimg_PhotoExpand(hdl,interp,w,h) Tk_PhotoExpand(hdl, w, h) +#define tkimg_PhotoSetSize(interp,hdl,w,h) Tk_PhotoSetSize(hdl, w, h) +#endif + +/* + *---------------------------------------------------------------------------- + * Function prototypes for stub initialization. + *---------------------------------------------------------------------------- + */ + +#ifdef USE_TKIMG_STUBS +EXTERN CONST char * +Tkimg_InitStubs _ANSI_ARGS_((Tcl_Interp *interp, CONST char *version, int exact)); +#else +/* + * When not using stubs, make it a macro. + */ + +#define Tkimg_InitStubs(interp, version, exact) \ + Tcl_PkgRequire(interp, "tkimg", version, exact) +#endif + +#undef TCL_STORAGE_CLASS +#define TCL_STORAGE_CLASS DLLIMPORT + +#endif /* RC_INVOKED */ +#endif /* __TKIMG_H__ */ diff --git a/mingw/include/tkimgDecls.h b/mingw/include/tkimgDecls.h new file mode 100644 index 00000000..83790d2a --- /dev/null +++ b/mingw/include/tkimgDecls.h @@ -0,0 +1,233 @@ +/* + * tkimgDecls.h -- + * + * Declarations of functions in the platform independent public TKIMG API. + * + */ + +#ifndef _TKIMGDECLS +#define _TKIMGDECLS + +/* + * WARNING: The contents of this file is automatically generated by the + * genStubs.tcl script. Any modifications to the function declarations + * below should be made in the tkimg.decls script. + */ + +#include + +/* !BEGIN!: Do not edit below this line. */ + +/* + * Exported function declarations: + */ + +/* 0 */ +EXTERN Tcl_Channel tkimg_OpenFileChannel _ANSI_ARGS_(( + Tcl_Interp * interp, CONST char * fileName, + int permissions)); +/* 1 */ +EXTERN int tkimg_ReadInit _ANSI_ARGS_((Tcl_Obj * data, int c, + tkimg_MFile * handle)); +/* 2 */ +EXTERN void tkimg_WriteInit _ANSI_ARGS_((Tcl_DString * buffer, + tkimg_MFile * handle)); +/* 3 */ +EXTERN int tkimg_Getc _ANSI_ARGS_((tkimg_MFile * handle)); +/* 4 */ +EXTERN int tkimg_Read _ANSI_ARGS_((tkimg_MFile * handle, + char * dst, int count)); +/* 5 */ +EXTERN int tkimg_Putc _ANSI_ARGS_((int c, tkimg_MFile * handle)); +/* 6 */ +EXTERN int tkimg_Write _ANSI_ARGS_((tkimg_MFile * handle, + CONST char * src, int count)); +/* 7 */ +EXTERN void tkimg_ReadBuffer _ANSI_ARGS_((int onOff)); +/* Slot 8 is reserved */ +/* Slot 9 is reserved */ +/* 10 */ +EXTERN int tkimg_PhotoPutBlock _ANSI_ARGS_(( + Tk_PhotoHandle handle, + Tk_PhotoImageBlock * blockPtr, int x, int y, + int width, int height)); +/* Slot 11 is reserved */ +/* Slot 12 is reserved */ +/* Slot 13 is reserved */ +/* Slot 14 is reserved */ +/* Slot 15 is reserved */ +/* Slot 16 is reserved */ +/* Slot 17 is reserved */ +/* Slot 18 is reserved */ +/* Slot 19 is reserved */ +/* 20 */ +EXTERN void tkimg_FixChanMatchProc _ANSI_ARGS_(( + Tcl_Interp ** interp, Tcl_Channel * chan, + CONST char ** file, Tcl_Obj ** format, + int ** width, int ** height)); +/* 21 */ +EXTERN void tkimg_FixObjMatchProc _ANSI_ARGS_(( + Tcl_Interp ** interp, Tcl_Obj ** data, + Tcl_Obj ** format, int ** width, + int ** height)); +/* 22 */ +EXTERN void tkimg_FixStringWriteProc _ANSI_ARGS_(( + Tcl_DString * data, Tcl_Interp ** interp, + Tcl_DString ** dataPtr, Tcl_Obj ** format, + Tk_PhotoImageBlock ** blockPtr)); +/* Slot 23 is reserved */ +/* Slot 24 is reserved */ +/* Slot 25 is reserved */ +/* Slot 26 is reserved */ +/* Slot 27 is reserved */ +/* Slot 28 is reserved */ +/* Slot 29 is reserved */ +/* 30 */ +EXTERN char* tkimg_GetStringFromObj _ANSI_ARGS_((Tcl_Obj * objPtr, + int * lengthPtr)); +/* 31 */ +EXTERN char* tkimg_GetByteArrayFromObj _ANSI_ARGS_(( + Tcl_Obj * objPtr, int * lengthPtr)); +/* 32 */ +EXTERN int tkimg_ListObjGetElements _ANSI_ARGS_(( + Tcl_Interp * interp, Tcl_Obj * objPtr, + int * argc, Tcl_Obj *** argv)); + +typedef struct TkimgStubs { + int magic; + struct TkimgStubHooks *hooks; + + Tcl_Channel (*tkimg_OpenFileChannel) _ANSI_ARGS_((Tcl_Interp * interp, CONST char * fileName, int permissions)); /* 0 */ + int (*tkimg_ReadInit) _ANSI_ARGS_((Tcl_Obj * data, int c, tkimg_MFile * handle)); /* 1 */ + void (*tkimg_WriteInit) _ANSI_ARGS_((Tcl_DString * buffer, tkimg_MFile * handle)); /* 2 */ + int (*tkimg_Getc) _ANSI_ARGS_((tkimg_MFile * handle)); /* 3 */ + int (*tkimg_Read) _ANSI_ARGS_((tkimg_MFile * handle, char * dst, int count)); /* 4 */ + int (*tkimg_Putc) _ANSI_ARGS_((int c, tkimg_MFile * handle)); /* 5 */ + int (*tkimg_Write) _ANSI_ARGS_((tkimg_MFile * handle, CONST char * src, int count)); /* 6 */ + void (*tkimg_ReadBuffer) _ANSI_ARGS_((int onOff)); /* 7 */ + void *reserved8; + void *reserved9; + int (*tkimg_PhotoPutBlock) _ANSI_ARGS_((Tk_PhotoHandle handle, Tk_PhotoImageBlock * blockPtr, int x, int y, int width, int height)); /* 10 */ + void *reserved11; + void *reserved12; + void *reserved13; + void *reserved14; + void *reserved15; + void *reserved16; + void *reserved17; + void *reserved18; + void *reserved19; + void (*tkimg_FixChanMatchProc) _ANSI_ARGS_((Tcl_Interp ** interp, Tcl_Channel * chan, CONST char ** file, Tcl_Obj ** format, int ** width, int ** height)); /* 20 */ + void (*tkimg_FixObjMatchProc) _ANSI_ARGS_((Tcl_Interp ** interp, Tcl_Obj ** data, Tcl_Obj ** format, int ** width, int ** height)); /* 21 */ + void (*tkimg_FixStringWriteProc) _ANSI_ARGS_((Tcl_DString * data, Tcl_Interp ** interp, Tcl_DString ** dataPtr, Tcl_Obj ** format, Tk_PhotoImageBlock ** blockPtr)); /* 22 */ + void *reserved23; + void *reserved24; + void *reserved25; + void *reserved26; + void *reserved27; + void *reserved28; + void *reserved29; + char* (*tkimg_GetStringFromObj) _ANSI_ARGS_((Tcl_Obj * objPtr, int * lengthPtr)); /* 30 */ + char* (*tkimg_GetByteArrayFromObj) _ANSI_ARGS_((Tcl_Obj * objPtr, int * lengthPtr)); /* 31 */ + int (*tkimg_ListObjGetElements) _ANSI_ARGS_((Tcl_Interp * interp, Tcl_Obj * objPtr, int * argc, Tcl_Obj *** argv)); /* 32 */ +} TkimgStubs; + +#ifdef __cplusplus +extern "C" { +#endif +extern TkimgStubs *tkimgStubsPtr; +#ifdef __cplusplus +} +#endif + +#if defined(USE_TKIMG_STUBS) && !defined(USE_TKIMG_STUB_PROCS) + +/* + * Inline function declarations: + */ + +#ifndef tkimg_OpenFileChannel +#define tkimg_OpenFileChannel \ + (tkimgStubsPtr->tkimg_OpenFileChannel) /* 0 */ +#endif +#ifndef tkimg_ReadInit +#define tkimg_ReadInit \ + (tkimgStubsPtr->tkimg_ReadInit) /* 1 */ +#endif +#ifndef tkimg_WriteInit +#define tkimg_WriteInit \ + (tkimgStubsPtr->tkimg_WriteInit) /* 2 */ +#endif +#ifndef tkimg_Getc +#define tkimg_Getc \ + (tkimgStubsPtr->tkimg_Getc) /* 3 */ +#endif +#ifndef tkimg_Read +#define tkimg_Read \ + (tkimgStubsPtr->tkimg_Read) /* 4 */ +#endif +#ifndef tkimg_Putc +#define tkimg_Putc \ + (tkimgStubsPtr->tkimg_Putc) /* 5 */ +#endif +#ifndef tkimg_Write +#define tkimg_Write \ + (tkimgStubsPtr->tkimg_Write) /* 6 */ +#endif +#ifndef tkimg_ReadBuffer +#define tkimg_ReadBuffer \ + (tkimgStubsPtr->tkimg_ReadBuffer) /* 7 */ +#endif +/* Slot 8 is reserved */ +/* Slot 9 is reserved */ +#ifndef tkimg_PhotoPutBlock +#define tkimg_PhotoPutBlock \ + (tkimgStubsPtr->tkimg_PhotoPutBlock) /* 10 */ +#endif +/* Slot 11 is reserved */ +/* Slot 12 is reserved */ +/* Slot 13 is reserved */ +/* Slot 14 is reserved */ +/* Slot 15 is reserved */ +/* Slot 16 is reserved */ +/* Slot 17 is reserved */ +/* Slot 18 is reserved */ +/* Slot 19 is reserved */ +#ifndef tkimg_FixChanMatchProc +#define tkimg_FixChanMatchProc \ + (tkimgStubsPtr->tkimg_FixChanMatchProc) /* 20 */ +#endif +#ifndef tkimg_FixObjMatchProc +#define tkimg_FixObjMatchProc \ + (tkimgStubsPtr->tkimg_FixObjMatchProc) /* 21 */ +#endif +#ifndef tkimg_FixStringWriteProc +#define tkimg_FixStringWriteProc \ + (tkimgStubsPtr->tkimg_FixStringWriteProc) /* 22 */ +#endif +/* Slot 23 is reserved */ +/* Slot 24 is reserved */ +/* Slot 25 is reserved */ +/* Slot 26 is reserved */ +/* Slot 27 is reserved */ +/* Slot 28 is reserved */ +/* Slot 29 is reserved */ +#ifndef tkimg_GetStringFromObj +#define tkimg_GetStringFromObj \ + (tkimgStubsPtr->tkimg_GetStringFromObj) /* 30 */ +#endif +#ifndef tkimg_GetByteArrayFromObj +#define tkimg_GetByteArrayFromObj \ + (tkimgStubsPtr->tkimg_GetByteArrayFromObj) /* 31 */ +#endif +#ifndef tkimg_ListObjGetElements +#define tkimg_ListObjGetElements \ + (tkimgStubsPtr->tkimg_ListObjGetElements) /* 32 */ +#endif + +#endif /* defined(USE_TKIMG_STUBS) && !defined(USE_TKIMG_STUB_PROCS) */ + +/* !END!: Do not edit above this line. */ + +#endif /* _TKIMGDECLS */ + diff --git a/mingw/include/zlibtcl.h b/mingw/include/zlibtcl.h new file mode 100644 index 00000000..8774d3b3 --- /dev/null +++ b/mingw/include/zlibtcl.h @@ -0,0 +1,156 @@ +/* + * zlibtcl.h -- + * + * Interface to libz. + * + * Copyright (c) 2002-2004 Andreas Kupries + * + * Zveno Pty Ltd makes this software and associated documentation + * available free of charge for any purpose. You may make copies + * of the software but you must include all of this notice on any copy. + * + * Zveno Pty Ltd does not warrant that this software is error free + * or fit for any purpose. Zveno Pty Ltd disclaims any liability for + * all claims, expenses, losses, damages and costs any user may incur + * as a result of using, copying or modifying the software. + * + * $Id: zlibtcl.h,v 1.3 2004/08/16 19:23:39 andreas_kupries Exp $ + * + */ + +#ifndef __ZLIBTCL_H__ +#define __ZLIBTCL_H__ + +#include "tcl.h" + +#define ZLIBTCL_MAJOR_VERSION 1 +#define ZLIBTCL_MINOR_VERSION 2 +#define ZLIBTCL_RELEASE_LEVEL TCL_RELEASE +#define ZLIBTCL_RELEASE_SERIAL 1 + +#define ZLIBTCL_VERSION "1.2.1" +#define ZLIBTCL_PATCH_LEVEL "1.2.1" + +/* + * Used to block the rest of this header file from resource compilers so + * we can just get the version info. + */ +#ifndef RC_INVOKED + +/* TIP 27 update. If CONST84 is not defined we are compiling against a + * core before 8.4 and have to disable some CONST'ness. + */ + +#ifndef CONST84 +# define CONST84 +#endif + +/* + * Fix the Borland bug that's in the EXTERN macro from tcl.h. + */ +#ifndef TCL_EXTERN +# undef DLLIMPORT +# undef DLLEXPORT +# if defined(STATIC_BUILD) +# define DLLIMPORT +# define DLLEXPORT +# elif (defined(__WIN32__) && (defined(_MSC_VER) || (__BORLANDC__ >= 0x0550) || (defined(__GNUC__) && defined(__declspec)))) || (defined(MAC_TCL) && FUNCTION_DECLSPEC) +# define DLLIMPORT __declspec(dllimport) +# define DLLEXPORT __declspec(dllexport) +# elif defined(__BORLANDC__) +# define OLDBORLAND 1 +# define DLLIMPORT __import +# define DLLEXPORT __export +# else +# define DLLIMPORT +# define DLLEXPORT +# endif + /* Avoid name mangling from C++ compilers. */ +# ifdef __cplusplus +# define TCL_EXTRNC extern "C" +# else +# define TCL_EXTRNC extern +# endif + /* Pre-5.5 Borland requires the attributes be placed after the */ + /* return type. */ +# ifdef OLDBORLAND +# define TCL_EXTERN(RTYPE) TCL_EXTRNC RTYPE TCL_STORAGE_CLASS +# else +# define TCL_EXTERN(RTYPE) TCL_EXTRNC TCL_STORAGE_CLASS RTYPE +# endif +#endif + + + +/* + * These macros are used to control whether functions are being declared for + * import or export in Windows, + * They map to no-op declarations on non-Windows systems. + * Assumes that tcl.h defines DLLEXPORT & DLLIMPORT correctly. + * The default build on windows is for a DLL, which causes the DLLIMPORT + * and DLLEXPORT macros to be nonempty. To build a static library, the + * macro STATIC_BUILD should be defined before the inclusion of tcl.h + * + * If a function is being declared while it is being built + * to be included in a shared library, then it should have the DLLEXPORT + * storage class. If is being declared for use by a module that is going to + * link against the shared library, then it should have the DLLIMPORT storage + * class. If the symbol is beind declared for a static build or for use from a + * stub library, then the storage class should be empty. + * + * The convention is that a macro called BUILD_xxxx, where xxxx is the + * name of a library we are building, is set on the compile line for sources + * that are to be placed in the library. When this macro is set, the + * storage class will be set to DLLEXPORT. At the end of the header file, the + * storage class will be reset to DLLIMPORt. + */ + +#undef TCL_STORAGE_CLASS +#ifdef BUILD_zlibtcl +# define TCL_STORAGE_CLASS DLLEXPORT +#else +# ifdef USE_ZLIBTCL_STUBS +# define TCL_STORAGE_CLASS +# else +# define TCL_STORAGE_CLASS DLLIMPORT +# endif +#endif + +/* + *---------------------------------------------------------------------------- + * C API for Zlibtcl generic layer + *---------------------------------------------------------------------------- + */ + +/* + *---------------------------------------------------------------------------- + * Function prototypes for publically accessible routines + *---------------------------------------------------------------------------- + */ + +#include "zlibtclDecls.h" + +/* + *---------------------------------------------------------------------------- + * Function prototypes for stub initialization. + *---------------------------------------------------------------------------- + */ + +#ifdef USE_ZLIBTCL_STUBS +EXTERN CONST char * +Zlibtcl_InitStubs _ANSI_ARGS_((Tcl_Interp *interp, CONST char *version, int exact)); +#else + +/* + * When not using stubs, make it a macro. + */ + +#define Zlibtcl_InitStubs(interp, version, exact) \ + Tcl_PkgRequire(interp, "zlibtcl", version, exact) +#endif + +#undef TCL_STORAGE_CLASS +#define TCL_STORAGE_CLASS DLLIMPORT + +#endif /* RC_INVOKED */ +#endif /* __ZLIBTCL_H__ */ diff --git a/mingw/include/zlibtclDecls.h b/mingw/include/zlibtclDecls.h new file mode 100644 index 00000000..e0200545 --- /dev/null +++ b/mingw/include/zlibtclDecls.h @@ -0,0 +1,373 @@ + +/* + * zlibtclDecls.h -- + * + * Declarations of functions in the platform independent public ZLIBTCL API. + * + */ + +#ifndef _ZLIBTCLDECLS +#define _ZLIBTCLDECLS + +/* + * WARNING: The contents of this file is automatically generated by the + * genStubs.tcl script. Any modifications to the function declarations + * below should be made in the zlibtcl.decls script. + */ + +#include +#include +#include <../zlib.h> +#include + +/* !BEGIN!: Do not edit below this line. */ + +/* + * Exported function declarations: + */ + +/* 0 */ +EXTERN CONST char* zlibVersion _ANSI_ARGS_((void)); +/* 1 */ +EXTERN CONST char* zError _ANSI_ARGS_((int err)); +/* 2 */ +EXTERN uLong crc32 _ANSI_ARGS_((uLong crc, const Bytef * buf, + uInt len)); +/* 3 */ +EXTERN uLong adler32 _ANSI_ARGS_((uLong adler, const Bytef * buf, + uInt len)); +/* Slot 4 is reserved */ +/* Slot 5 is reserved */ +/* Slot 6 is reserved */ +/* Slot 7 is reserved */ +/* Slot 8 is reserved */ +/* Slot 9 is reserved */ +/* 10 */ +EXTERN int deflateInit_ _ANSI_ARGS_((z_streamp stream, + int level, const char* version, + int stream_size)); +/* 11 */ +EXTERN int deflateInit2_ _ANSI_ARGS_((z_streamp stream, + int level, int method, int windowBits, + int memLevel, int strategy, + const char* version, int stream_size)); +/* 12 */ +EXTERN int deflate _ANSI_ARGS_((z_streamp stream, int flush)); +/* 13 */ +EXTERN int deflateEnd _ANSI_ARGS_((z_streamp stream)); +/* 14 */ +EXTERN int deflateSetDictionary _ANSI_ARGS_((z_streamp stream, + CONST Bytef* dict, uInt dictLength)); +/* 15 */ +EXTERN int deflateCopy _ANSI_ARGS_((z_streamp dst, + z_streamp src)); +/* 16 */ +EXTERN int deflateReset _ANSI_ARGS_((z_streamp stream)); +/* 17 */ +EXTERN int deflateParams _ANSI_ARGS_((z_streamp stream, + int level, int strategy)); +/* 18 */ +EXTERN int compress _ANSI_ARGS_((Bytef * dest, uLongf * destLen, + CONST Bytef * source, uLong sourceLen)); +/* 19 */ +EXTERN int compress2 _ANSI_ARGS_((Bytef * dest, + uLongf * destLen, CONST Bytef * source, + uLong sourceLen, int level)); +/* 20 */ +EXTERN int inflateInit_ _ANSI_ARGS_((z_streamp stream, + const char* version, int stream_size)); +/* 21 */ +EXTERN int inflateInit2_ _ANSI_ARGS_((z_streamp stream, + int windowBits, const char* version, + int stream_size)); +/* 22 */ +EXTERN int inflate _ANSI_ARGS_((z_streamp stream, int flush)); +/* 23 */ +EXTERN int inflateEnd _ANSI_ARGS_((z_streamp stream)); +/* 24 */ +EXTERN int inflateSetDictionary _ANSI_ARGS_((z_streamp stream, + CONST Bytef* dict, uInt dictLength)); +/* 25 */ +EXTERN int inflateSync _ANSI_ARGS_((z_streamp stream)); +/* 26 */ +EXTERN int inflateReset _ANSI_ARGS_((z_streamp stream)); +/* 27 */ +EXTERN int uncompress _ANSI_ARGS_((Bytef * dest, + uLongf * destLen, CONST Bytef * source, + uLong sourceLen)); +/* Slot 28 is reserved */ +/* Slot 29 is reserved */ +/* 30 */ +EXTERN gzFile gzopen _ANSI_ARGS_((const char * path, + const char * mode)); +/* 31 */ +EXTERN gzFile gzdopen _ANSI_ARGS_((int fd, const char * mode)); +/* 32 */ +EXTERN int gzsetparams _ANSI_ARGS_((gzFile file, int level, + int strategy)); +/* 33 */ +EXTERN int gzread _ANSI_ARGS_((gzFile file, voidp buf, + unsigned len)); +/* 34 */ +EXTERN int gzwrite _ANSI_ARGS_((gzFile file, const voidpc buf, + unsigned len)); +/* Slot 35 is reserved */ +/* 36 */ +EXTERN int gzputs _ANSI_ARGS_((gzFile file, const char * s)); +/* 37 */ +EXTERN char* gzgets _ANSI_ARGS_((gzFile file, char * buf, int len)); +/* 38 */ +EXTERN int gzputc _ANSI_ARGS_((gzFile file, int c)); +/* 39 */ +EXTERN int gzgetc _ANSI_ARGS_((gzFile file)); +/* 40 */ +EXTERN int gzflush _ANSI_ARGS_((gzFile file, int flush)); +/* 41 */ +EXTERN z_off_t gzseek _ANSI_ARGS_((gzFile file, z_off_t offset, + int whence)); +/* 42 */ +EXTERN int gzrewind _ANSI_ARGS_((gzFile file)); +/* 43 */ +EXTERN z_off_t gztell _ANSI_ARGS_((gzFile file)); +/* 44 */ +EXTERN int gzeof _ANSI_ARGS_((gzFile file)); +/* 45 */ +EXTERN int gzclose _ANSI_ARGS_((gzFile file)); +/* 46 */ +EXTERN const char* gzerror _ANSI_ARGS_((gzFile file, int * errnum)); + +typedef struct ZlibtclStubs { + int magic; + struct ZlibtclStubHooks *hooks; + + CONST char* (*zlibVersion) _ANSI_ARGS_((void)); /* 0 */ + CONST char* (*zError) _ANSI_ARGS_((int err)); /* 1 */ + uLong (*crc32) _ANSI_ARGS_((uLong crc, const Bytef * buf, uInt len)); /* 2 */ + uLong (*adler32) _ANSI_ARGS_((uLong adler, const Bytef * buf, uInt len)); /* 3 */ + void *reserved4; + void *reserved5; + void *reserved6; + void *reserved7; + void *reserved8; + void *reserved9; + int (*deflateInit_) _ANSI_ARGS_((z_streamp stream, int level, const char* version, int stream_size)); /* 10 */ + int (*deflateInit2_) _ANSI_ARGS_((z_streamp stream, int level, int method, int windowBits, int memLevel, int strategy, const char* version, int stream_size)); /* 11 */ + int (*deflate) _ANSI_ARGS_((z_streamp stream, int flush)); /* 12 */ + int (*deflateEnd) _ANSI_ARGS_((z_streamp stream)); /* 13 */ + int (*deflateSetDictionary) _ANSI_ARGS_((z_streamp stream, CONST Bytef* dict, uInt dictLength)); /* 14 */ + int (*deflateCopy) _ANSI_ARGS_((z_streamp dst, z_streamp src)); /* 15 */ + int (*deflateReset) _ANSI_ARGS_((z_streamp stream)); /* 16 */ + int (*deflateParams) _ANSI_ARGS_((z_streamp stream, int level, int strategy)); /* 17 */ + int (*compress) _ANSI_ARGS_((Bytef * dest, uLongf * destLen, CONST Bytef * source, uLong sourceLen)); /* 18 */ + int (*compress2) _ANSI_ARGS_((Bytef * dest, uLongf * destLen, CONST Bytef * source, uLong sourceLen, int level)); /* 19 */ + int (*inflateInit_) _ANSI_ARGS_((z_streamp stream, const char* version, int stream_size)); /* 20 */ + int (*inflateInit2_) _ANSI_ARGS_((z_streamp stream, int windowBits, const char* version, int stream_size)); /* 21 */ + int (*inflate) _ANSI_ARGS_((z_streamp stream, int flush)); /* 22 */ + int (*inflateEnd) _ANSI_ARGS_((z_streamp stream)); /* 23 */ + int (*inflateSetDictionary) _ANSI_ARGS_((z_streamp stream, CONST Bytef* dict, uInt dictLength)); /* 24 */ + int (*inflateSync) _ANSI_ARGS_((z_streamp stream)); /* 25 */ + int (*inflateReset) _ANSI_ARGS_((z_streamp stream)); /* 26 */ + int (*uncompress) _ANSI_ARGS_((Bytef * dest, uLongf * destLen, CONST Bytef * source, uLong sourceLen)); /* 27 */ + void *reserved28; + void *reserved29; + gzFile (*gzopen) _ANSI_ARGS_((const char * path, const char * mode)); /* 30 */ + gzFile (*gzdopen) _ANSI_ARGS_((int fd, const char * mode)); /* 31 */ + int (*gzsetparams) _ANSI_ARGS_((gzFile file, int level, int strategy)); /* 32 */ + int (*gzread) _ANSI_ARGS_((gzFile file, voidp buf, unsigned len)); /* 33 */ + int (*gzwrite) _ANSI_ARGS_((gzFile file, const voidpc buf, unsigned len)); /* 34 */ + void *reserved35; + int (*gzputs) _ANSI_ARGS_((gzFile file, const char * s)); /* 36 */ + char* (*gzgets) _ANSI_ARGS_((gzFile file, char * buf, int len)); /* 37 */ + int (*gzputc) _ANSI_ARGS_((gzFile file, int c)); /* 38 */ + int (*gzgetc) _ANSI_ARGS_((gzFile file)); /* 39 */ + int (*gzflush) _ANSI_ARGS_((gzFile file, int flush)); /* 40 */ + z_off_t (*gzseek) _ANSI_ARGS_((gzFile file, z_off_t offset, int whence)); /* 41 */ + int (*gzrewind) _ANSI_ARGS_((gzFile file)); /* 42 */ + z_off_t (*gztell) _ANSI_ARGS_((gzFile file)); /* 43 */ + int (*gzeof) _ANSI_ARGS_((gzFile file)); /* 44 */ + int (*gzclose) _ANSI_ARGS_((gzFile file)); /* 45 */ + const char* (*gzerror) _ANSI_ARGS_((gzFile file, int * errnum)); /* 46 */ +} ZlibtclStubs; + +#ifdef __cplusplus +extern "C" { +#endif +extern ZlibtclStubs *zlibtclStubsPtr; +#ifdef __cplusplus +} +#endif + +#if defined(USE_ZLIBTCL_STUBS) && !defined(USE_ZLIBTCL_STUB_PROCS) + +/* + * Inline function declarations: + */ + +#ifndef zlibVersion +#define zlibVersion \ + (zlibtclStubsPtr->zlibVersion) /* 0 */ +#endif +#ifndef zError +#define zError \ + (zlibtclStubsPtr->zError) /* 1 */ +#endif +#ifndef crc32 +#define crc32 \ + (zlibtclStubsPtr->crc32) /* 2 */ +#endif +#ifndef adler32 +#define adler32 \ + (zlibtclStubsPtr->adler32) /* 3 */ +#endif +/* Slot 4 is reserved */ +/* Slot 5 is reserved */ +/* Slot 6 is reserved */ +/* Slot 7 is reserved */ +/* Slot 8 is reserved */ +/* Slot 9 is reserved */ +#ifndef deflateInit_ +#define deflateInit_ \ + (zlibtclStubsPtr->deflateInit_) /* 10 */ +#endif +#ifndef deflateInit2_ +#define deflateInit2_ \ + (zlibtclStubsPtr->deflateInit2_) /* 11 */ +#endif +#ifndef deflate +#define deflate \ + (zlibtclStubsPtr->deflate) /* 12 */ +#endif +#ifndef deflateEnd +#define deflateEnd \ + (zlibtclStubsPtr->deflateEnd) /* 13 */ +#endif +#ifndef deflateSetDictionary +#define deflateSetDictionary \ + (zlibtclStubsPtr->deflateSetDictionary) /* 14 */ +#endif +#ifndef deflateCopy +#define deflateCopy \ + (zlibtclStubsPtr->deflateCopy) /* 15 */ +#endif +#ifndef deflateReset +#define deflateReset \ + (zlibtclStubsPtr->deflateReset) /* 16 */ +#endif +#ifndef deflateParams +#define deflateParams \ + (zlibtclStubsPtr->deflateParams) /* 17 */ +#endif +#ifndef compress +#define compress \ + (zlibtclStubsPtr->compress) /* 18 */ +#endif +#ifndef compress2 +#define compress2 \ + (zlibtclStubsPtr->compress2) /* 19 */ +#endif +#ifndef inflateInit_ +#define inflateInit_ \ + (zlibtclStubsPtr->inflateInit_) /* 20 */ +#endif +#ifndef inflateInit2_ +#define inflateInit2_ \ + (zlibtclStubsPtr->inflateInit2_) /* 21 */ +#endif +#ifndef inflate +#define inflate \ + (zlibtclStubsPtr->inflate) /* 22 */ +#endif +#ifndef inflateEnd +#define inflateEnd \ + (zlibtclStubsPtr->inflateEnd) /* 23 */ +#endif +#ifndef inflateSetDictionary +#define inflateSetDictionary \ + (zlibtclStubsPtr->inflateSetDictionary) /* 24 */ +#endif +#ifndef inflateSync +#define inflateSync \ + (zlibtclStubsPtr->inflateSync) /* 25 */ +#endif +#ifndef inflateReset +#define inflateReset \ + (zlibtclStubsPtr->inflateReset) /* 26 */ +#endif +#ifndef uncompress +#define uncompress \ + (zlibtclStubsPtr->uncompress) /* 27 */ +#endif +/* Slot 28 is reserved */ +/* Slot 29 is reserved */ +#ifndef gzopen +#define gzopen \ + (zlibtclStubsPtr->gzopen) /* 30 */ +#endif +#ifndef gzdopen +#define gzdopen \ + (zlibtclStubsPtr->gzdopen) /* 31 */ +#endif +#ifndef gzsetparams +#define gzsetparams \ + (zlibtclStubsPtr->gzsetparams) /* 32 */ +#endif +#ifndef gzread +#define gzread \ + (zlibtclStubsPtr->gzread) /* 33 */ +#endif +#ifndef gzwrite +#define gzwrite \ + (zlibtclStubsPtr->gzwrite) /* 34 */ +#endif +/* Slot 35 is reserved */ +#ifndef gzputs +#define gzputs \ + (zlibtclStubsPtr->gzputs) /* 36 */ +#endif +#ifndef gzgets +#define gzgets \ + (zlibtclStubsPtr->gzgets) /* 37 */ +#endif +#ifndef gzputc +#define gzputc \ + (zlibtclStubsPtr->gzputc) /* 38 */ +#endif +#ifndef gzgetc +#define gzgetc \ + (zlibtclStubsPtr->gzgetc) /* 39 */ +#endif +#ifndef gzflush +#define gzflush \ + (zlibtclStubsPtr->gzflush) /* 40 */ +#endif +#ifndef gzseek +#define gzseek \ + (zlibtclStubsPtr->gzseek) /* 41 */ +#endif +#ifndef gzrewind +#define gzrewind \ + (zlibtclStubsPtr->gzrewind) /* 42 */ +#endif +#ifndef gztell +#define gztell \ + (zlibtclStubsPtr->gztell) /* 43 */ +#endif +#ifndef gzeof +#define gzeof \ + (zlibtclStubsPtr->gzeof) /* 44 */ +#endif +#ifndef gzclose +#define gzclose \ + (zlibtclStubsPtr->gzclose) /* 45 */ +#endif +#ifndef gzerror +#define gzerror \ + (zlibtclStubsPtr->gzerror) /* 46 */ +#endif + +#endif /* defined(USE_ZLIBTCL_STUBS) && !defined(USE_ZLIBTCL_STUB_PROCS) */ + +/* !END!: Do not edit above this line. */ + +#endif /* _ZLIBTCLDECLS */ + diff --git a/mingw/include/zlibtclDeclsMask.h b/mingw/include/zlibtclDeclsMask.h new file mode 100644 index 00000000..d75b0cf6 --- /dev/null +++ b/mingw/include/zlibtclDeclsMask.h @@ -0,0 +1,48 @@ +#ifdef WIN32 +/* + * While the definitions in the original header are technically the + * same as the definitions in 'zlibDecls.h' on Windows they are not, + * in a small detail: DLLEXPORT vs. DLLIMPORT. As our artificial + * definitions do the right thing we use the macro definitions below + * to move the original definitionsd out of the way. We do retain the + * inclusion of all the type definitions, etc. + */ +#define zlibVersion __mask_zlibVersion +#define zError __mask_zError +#define crc32 __mask_crc32 +#define adler32 __mask_adler32 +#define deflateInit_ __mask_deflateInit_ +#define deflateInit2_ __mask_deflateInit2_ +#define deflate __mask_deflate +#define deflateEnd __mask_deflateEnd +#define deflateSetDictionary __mask_deflateSetDictionary +#define deflateCopy __mask_deflateCopy +#define deflateReset __mask_deflateReset +#define deflateParams __mask_deflateParams +#define compress __mask_compress +#define compress2 __mask_compress2 +#define inflateInit_ __mask_inflateInit_ +#define inflateInit2_ __mask_inflateInit2_ +#define inflate __mask_inflate +#define inflateEnd __mask_inflateEnd +#define inflateSetDictionary __mask_inflateSetDictionary +#define inflateSync __mask_inflateSync +#define inflateReset __mask_inflateReset +#define uncompress __mask_uncompress +#define gzopen __mask_gzopen +#define gzdopen __mask_gzdopen +#define gzsetparams __mask_gzsetparams +#define gzread __mask_gzread +#define gzwrite __mask_gzwrite +#define gzputs __mask_gzputs +#define gzgets __mask_gzgets +#define gzputc __mask_gzputc +#define gzgetc __mask_gzgetc +#define gzflush __mask_gzflush +#define gzseek __mask_gzseek +#define gzrewind __mask_gzrewind +#define gztell __mask_gztell +#define gzeof __mask_gzeof +#define gzclose __mask_gzclose +#define gzerror __mask_gzerror +#endif /* WIN32 */ diff --git a/mingw/include/zlibtclDeclsUnmask.h b/mingw/include/zlibtclDeclsUnmask.h new file mode 100644 index 00000000..6c5c2f68 --- /dev/null +++ b/mingw/include/zlibtclDeclsUnmask.h @@ -0,0 +1,41 @@ +#ifdef WIN32 +/* Restore the usage of the original names */ +#undef zlibVersion +#undef zError +#undef crc32 +#undef adler32 +#undef deflateInit_ +#undef deflateInit2_ +#undef deflate +#undef deflateEnd +#undef deflateSetDictionary +#undef deflateCopy +#undef deflateReset +#undef deflateParams +#undef compress +#undef compress2 +#undef inflateInit_ +#undef inflateInit2_ +#undef inflate +#undef inflateEnd +#undef inflateSetDictionary +#undef inflateSync +#undef inflateReset +#undef uncompress +#undef gzopen +#undef gzdopen +#undef gzsetparams +#undef gzread +#undef gzwrite +#undef gzputs +#undef gzgets +#undef gzputc +#undef gzgetc +#undef gzflush +#undef gzseek +#undef gzrewind +#undef gztell +#undef gzeof +#undef gzclose +#undef gzerror +#endif /* WIN32 */ diff --git a/mingw/lib/Img1.3/jpegtcl10.dll b/mingw/lib/Img1.3/jpegtcl10.dll new file mode 100644 index 00000000..4f494f95 Binary files /dev/null and b/mingw/lib/Img1.3/jpegtcl10.dll differ diff --git a/mingw/lib/Img1.3/jpegtclstub10.a b/mingw/lib/Img1.3/jpegtclstub10.a new file mode 100644 index 00000000..4c95b757 Binary files /dev/null and b/mingw/lib/Img1.3/jpegtclstub10.a differ diff --git a/mingw/lib/Img1.3/pkgIndex.tcl b/mingw/lib/Img1.3/pkgIndex.tcl new file mode 100644 index 00000000..6d8281d7 --- /dev/null +++ b/mingw/lib/Img1.3/pkgIndex.tcl @@ -0,0 +1,169 @@ +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/19 00:28:55 andreas_kupries Exp $ + +package ifneeded zlibtcl 1.2.1 [list load [file join $dir zlibtcl121.dll]] + +# distinguish static and dyn variants, later. +if {0} { +package ifneeded zlibtcl 1.2.1 [string map [list @dir@ $dir] \ +"if {[catch {load [file join @dir@ zlibtcl121.dll]}]} { + load [file join @dir@ zlibtcl121.dll] +}"] +} +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/19 00:28:55 andreas_kupries Exp $ + +package ifneeded zlibtcl 1.2.1 [list load [file join $dir zlibtcl121.dll]] + +# distinguish static and dyn variants, later. +if {0} { +package ifneeded zlibtcl 1.2.1 [string map [list @dir@ $dir] \ +"if {[catch {load [file join @dir@ zlibtcl121.dll]}]} { + load [file join @dir@ zlibtcl121.dll] +}"] +} +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/19 00:28:54 andreas_kupries Exp $ + +package ifneeded tifftcl 3.6.1 [list load [file join $dir tifftcl361.dll]] + +# distinguish static and dyn variants, later. +if {0} { +package ifneeded tifftcl 3.6.1 [string map [list @dir@ $dir] \ +"if {[catch {load [file join @dir@ tifftcl361.dll]}]} { + load [file join @dir@ tifftcl361.dll] +}"] +} +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/19 00:28:54 andreas_kupries Exp $ + +package ifneeded jpegtcl 1.0 [list load [file join $dir jpegtcl10.dll]] + +# distinguish static and dyn variants, later. +if {0} { +package ifneeded jpegtcl 1.0 [string map [list @dir@ $dir] \ +"if {[catch {load [file join @dir@ jpegtcl10.dll]}]} { + load [file join @dir@ jpegtcl10.dll] +}"] +} +# -*- tcl -*- Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.5 2003/03/09 17:13:07 obermeier Exp $ + +package ifneeded img::base 1.3 [list load [file join $dir tkimg13.dll]] + +package ifneeded Img 1.3 { + # Compatibility hack. When asking for the old name of the package + # then load all format handlers and base libraries provided by tkImg. + # Actually we ask only for the format handlers, the required base + # packages will be loaded automatically through the usual package + # mechanism. + + # When reading images without specifying it's format (option -format), + # the available formats are tried in reversed order as listed here. + # Therefore file formats with some "magic" identifier, which can be + # recognized safely, should be added at the end of this list. + + package require img::window + package require img::tga + package require img::ico + package require img::pcx + package require img::sgi + package require img::sun + package require img::xbm + package require img::xpm + package require img::ps + package require img::jpeg + package require img::png + package require img::tiff + package require img::bmp + package require img::ppm + package require img::gif + package require img::pixmap + + package provide Img 1.3 +} +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/21 07:20:23 andreas_kupries Exp $ + +package ifneeded "img::bmp" 1.3 [list load [file join $dir tkimgbmp13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/21 07:20:23 andreas_kupries Exp $ + +package ifneeded "img::gif" 1.3 [list load [file join $dir tkimggif13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 05:46:07 andreas_kupries Exp $ + +package ifneeded "img::ico" 1.3 [list load [file join $dir tkimgico13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 05:46:07 andreas_kupries Exp $ + +package ifneeded "img::ico" 1.3 [list load [file join $dir tkimgico13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 05:46:07 andreas_kupries Exp $ + +package ifneeded "img::pcx" 1.3 [list load [file join $dir tkimgpcx13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/12/05 07:08:42 andreas_kupries Exp $ + +package ifneeded "img::pixmap" 1.3 [list load [file join $dir tkimgpixmap13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/12/05 07:08:42 andreas_kupries Exp $ + +package ifneeded "img::pixmap" 1.3 [list load [file join $dir tkimgpixmap13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 05:46:07 andreas_kupries Exp $ + +package ifneeded "img::ppm" 1.3 [list load [file join $dir tkimgppm13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 05:46:07 andreas_kupries Exp $ + +package ifneeded "img::ps" 1.3 [list load [file join $dir tkimgps13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 05:46:08 andreas_kupries Exp $ + +package ifneeded "img::sgi" 1.3 [list load [file join $dir tkimgsgi13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 05:46:08 andreas_kupries Exp $ + +package ifneeded "img::sun" 1.3 [list load [file join $dir tkimgsun13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 05:46:08 andreas_kupries Exp $ + +package ifneeded "img::tga" 1.3 [list load [file join $dir tkimgtga13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 05:46:08 andreas_kupries Exp $ + +package ifneeded "img::tga" 1.3 [list load [file join $dir tkimgtga13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 08:57:56 andreas_kupries Exp $ + +package ifneeded "img::window" 1.3 [list load [file join $dir tkimgwindow13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 05:46:08 andreas_kupries Exp $ + +package ifneeded "img::xbm" 1.3 [list load [file join $dir tkimgxbm13.dll]] +# Tcl package index file - handcrafted +# +# $Id: pkgIndex.tcl.in,v 1.1 2002/11/29 05:46:08 andreas_kupries Exp $ + +package ifneeded "img::xpm" 1.3 [list load [file join $dir tkimgxpm13.dll]] diff --git a/mingw/lib/Img1.3/tifftcl361.dll b/mingw/lib/Img1.3/tifftcl361.dll new file mode 100644 index 00000000..50800bcd Binary files /dev/null and b/mingw/lib/Img1.3/tifftcl361.dll differ diff --git a/mingw/lib/Img1.3/tifftclstub361.a b/mingw/lib/Img1.3/tifftclstub361.a new file mode 100644 index 00000000..c041d80f Binary files /dev/null and b/mingw/lib/Img1.3/tifftclstub361.a differ diff --git a/mingw/lib/Img1.3/tkimg13.dll b/mingw/lib/Img1.3/tkimg13.dll new file mode 100644 index 00000000..badc8323 Binary files /dev/null and b/mingw/lib/Img1.3/tkimg13.dll differ diff --git a/mingw/lib/Img1.3/tkimgbmp13.dll b/mingw/lib/Img1.3/tkimgbmp13.dll new file mode 100644 index 00000000..c14fb887 Binary files /dev/null and b/mingw/lib/Img1.3/tkimgbmp13.dll differ diff --git a/mingw/lib/Img1.3/tkimggif13.dll b/mingw/lib/Img1.3/tkimggif13.dll new file mode 100644 index 00000000..d10f53c1 Binary files /dev/null and b/mingw/lib/Img1.3/tkimggif13.dll differ diff --git a/mingw/lib/Img1.3/tkimgico13.dll b/mingw/lib/Img1.3/tkimgico13.dll new file mode 100644 index 00000000..0f1297c2 Binary files /dev/null and b/mingw/lib/Img1.3/tkimgico13.dll differ diff --git a/mingw/lib/Img1.3/tkimgpcx13.dll b/mingw/lib/Img1.3/tkimgpcx13.dll new file mode 100644 index 00000000..b640b497 Binary files /dev/null and b/mingw/lib/Img1.3/tkimgpcx13.dll differ diff --git a/mingw/lib/Img1.3/tkimgpixmap13.dll b/mingw/lib/Img1.3/tkimgpixmap13.dll new file mode 100644 index 00000000..d8acaeea Binary files /dev/null and b/mingw/lib/Img1.3/tkimgpixmap13.dll differ diff --git a/mingw/lib/Img1.3/tkimgppm13.dll b/mingw/lib/Img1.3/tkimgppm13.dll new file mode 100644 index 00000000..3308d4c7 Binary files /dev/null and b/mingw/lib/Img1.3/tkimgppm13.dll differ diff --git a/mingw/lib/Img1.3/tkimgps13.dll b/mingw/lib/Img1.3/tkimgps13.dll new file mode 100644 index 00000000..cec00075 Binary files /dev/null and b/mingw/lib/Img1.3/tkimgps13.dll differ diff --git a/mingw/lib/Img1.3/tkimgsgi13.dll b/mingw/lib/Img1.3/tkimgsgi13.dll new file mode 100644 index 00000000..a5d477ac Binary files /dev/null and b/mingw/lib/Img1.3/tkimgsgi13.dll differ diff --git a/mingw/lib/Img1.3/tkimgstub13.a b/mingw/lib/Img1.3/tkimgstub13.a new file mode 100644 index 00000000..70109b86 Binary files /dev/null and b/mingw/lib/Img1.3/tkimgstub13.a differ diff --git a/mingw/lib/Img1.3/tkimgsun13.dll b/mingw/lib/Img1.3/tkimgsun13.dll new file mode 100644 index 00000000..92317d73 Binary files /dev/null and b/mingw/lib/Img1.3/tkimgsun13.dll differ diff --git a/mingw/lib/Img1.3/tkimgtga13.dll b/mingw/lib/Img1.3/tkimgtga13.dll new file mode 100644 index 00000000..7016c3c7 Binary files /dev/null and b/mingw/lib/Img1.3/tkimgtga13.dll differ diff --git a/mingw/lib/Img1.3/tkimgwindow13.dll b/mingw/lib/Img1.3/tkimgwindow13.dll new file mode 100644 index 00000000..46665408 Binary files /dev/null and b/mingw/lib/Img1.3/tkimgwindow13.dll differ diff --git a/mingw/lib/Img1.3/tkimgxbm13.dll b/mingw/lib/Img1.3/tkimgxbm13.dll new file mode 100644 index 00000000..8b876e2a Binary files /dev/null and b/mingw/lib/Img1.3/tkimgxbm13.dll differ diff --git a/mingw/lib/Img1.3/tkimgxpm13.dll b/mingw/lib/Img1.3/tkimgxpm13.dll new file mode 100644 index 00000000..6bde3a7b Binary files /dev/null and b/mingw/lib/Img1.3/tkimgxpm13.dll differ diff --git a/mingw/lib/Img1.3/zlibtcl121.dll b/mingw/lib/Img1.3/zlibtcl121.dll new file mode 100644 index 00000000..b16b146f Binary files /dev/null and b/mingw/lib/Img1.3/zlibtcl121.dll differ diff --git a/mingw/lib/Img1.3/zlibtclstub121.a b/mingw/lib/Img1.3/zlibtclstub121.a new file mode 100644 index 00000000..465fdb09 Binary files /dev/null and b/mingw/lib/Img1.3/zlibtclstub121.a differ diff --git a/mingw/lib/jpegtclConfig.sh b/mingw/lib/jpegtclConfig.sh new file mode 100644 index 00000000..8b3194b9 --- /dev/null +++ b/mingw/lib/jpegtclConfig.sh @@ -0,0 +1,57 @@ +# jpegtclConfig.sh -- +# +# This shell script (for sh) is generated automatically by jpegtcl's +# configure script. It will create shell variables for most of +# the configuration options discovered by the configure script. +# This script is intended to be included by the configure scripts +# for jpegtcl extensions so that they don't have to figure this all +# out for themselves. This file does not duplicate information +# already provided by tclConfig.sh, so you may need to use that +# file in addition to this one. +# +# The information in this file is specific to a single platform. + +# jpegtcl's version number. +jpegtcl_VERSION='1.0' +jpegtcl_MAJOR_VERSION='1' +jpegtcl_MINOR_VERSION='0' +jpegtcl_RELEASE_LEVEL='' + +# The name of the jpegtcl library (may be either a .a file or a shared library): +jpegtcl_LIB_FILE=jpegtcl10.dll + +# String to pass to linker to pick up the jpegtcl library from its +# build directory. +jpegtcl_BUILD_LIB_SPEC='-L/src/tcltk/tkimg1.3/libjpeg/tcl -ljpegtcl10' + +# String to pass to linker to pick up the jpegtcl library from its +# installed directory. +jpegtcl_LIB_SPEC='-L/mingw/lib/jpegtcl1.0 -ljpegtcl10' + +# The name of the jpegtcl stub library (a .a file): +jpegtcl_STUB_LIB_FILE=jpegtclstub10.a + +# String to pass to linker to pick up the jpegtcl stub library from its +# build directory. +jpegtcl_BUILD_STUB_LIB_SPEC='-L/src/tcltk/tkimg1.3/libjpeg/tcl -ljpegtclstub10' + +# String to pass to linker to pick up the jpegtcl stub library from its +# installed directory. +jpegtcl_STUB_LIB_SPEC='-L/mingw/lib/jpegtcl1.0 -ljpegtclstub10' + +# String to pass to linker to pick up the jpegtcl stub library from its +# build directory. +jpegtcl_BUILD_STUB_LIB_PATH='/src/tcltk/tkimg1.3/libjpeg/tcl/jpegtclstub10.a' + +# String to pass to linker to pick up the jpegtcl stub library from its +# installed directory. +jpegtcl_STUB_LIB_PATH='/mingw/lib/jpegtcl1.0/jpegtclstub10.a' + +# Location of the top-level source directories from which jpegtcl +# was built. This is the directory that contains generic, unix, etc. +# If jpegtcl was compiled in a different place than the directory +# containing the source files, this points to the location of the +# sources, not the location where jpegtcl was compiled. This can +# be relative to the build directory. + +jpegtcl_SRC_DIR='/src/tcltk/tkimg1.3/libjpeg/tcl' diff --git a/mingw/lib/tifftclConfig.sh b/mingw/lib/tifftclConfig.sh new file mode 100644 index 00000000..f758d2e1 --- /dev/null +++ b/mingw/lib/tifftclConfig.sh @@ -0,0 +1,57 @@ +# tifftclConfig.sh -- +# +# This shell script (for sh) is generated automatically by tifftcl's +# configure script. It will create shell variables for most of +# the configuration options discovered by the configure script. +# This script is intended to be included by the configure scripts +# for tifftcl extensions so that they don't have to figure this all +# out for themselves. This file does not duplicate information +# already provided by tclConfig.sh, so you may need to use that +# file in addition to this one. +# +# The information in this file is specific to a single platform. + +# tifftcl's version number. +tifftcl_VERSION='3.6.1' +tifftcl_MAJOR_VERSION='3' +tifftcl_MINOR_VERSION='6' +tifftcl_RELEASE_LEVEL='1' + +# The name of the tifftcl library (may be either a .a file or a shared library): +tifftcl_LIB_FILE=tifftcl361.dll + +# String to pass to linker to pick up the tifftcl library from its +# build directory. +tifftcl_BUILD_LIB_SPEC='-L/src/tcltk/tkimg1.3/libtiff/tcl -ltifftcl361' + +# String to pass to linker to pick up the tifftcl library from its +# installed directory. +tifftcl_LIB_SPEC='-L/mingw/lib/tifftcl3.6.1 -ltifftcl361' + +# The name of the tifftcl stub library (a .a file): +tifftcl_STUB_LIB_FILE=tifftclstub361.a + +# String to pass to linker to pick up the tifftcl stub library from its +# build directory. +tifftcl_BUILD_STUB_LIB_SPEC='-L/src/tcltk/tkimg1.3/libtiff/tcl -ltifftclstub361' + +# String to pass to linker to pick up the tifftcl stub library from its +# installed directory. +tifftcl_STUB_LIB_SPEC='-L/mingw/lib/tifftcl3.6.1 -ltifftclstub361' + +# String to pass to linker to pick up the tifftcl stub library from its +# build directory. +tifftcl_BUILD_STUB_LIB_PATH='/src/tcltk/tkimg1.3/libtiff/tcl/tifftclstub361.a' + +# String to pass to linker to pick up the tifftcl stub library from its +# installed directory. +tifftcl_STUB_LIB_PATH='/mingw/lib/tifftcl3.6.1/tifftclstub361.a' + +# Location of the top-level source directories from which tifftcl +# was built. This is the directory that contains generic, unix, etc. +# If tifftcl was compiled in a different place than the directory +# containing the source files, this points to the location of the +# sources, not the location where tifftcl was compiled. This can +# be relative to the build directory. + +tifftcl_SRC_DIR='/src/tcltk/tkimg1.3/libtiff/tcl' diff --git a/mingw/lib/tkimgConfig.sh b/mingw/lib/tkimgConfig.sh new file mode 100644 index 00000000..e0d48356 --- /dev/null +++ b/mingw/lib/tkimgConfig.sh @@ -0,0 +1,57 @@ +# tkimgConfig.sh -- +# +# This shell script (for sh) is generated automatically by tkimg's +# configure script. It will create shell variables for most of +# the configuration options discovered by the configure script. +# This script is intended to be included by the configure scripts +# for tkimg extensions so that they don't have to figure this all +# out for themselves. This file does not duplicate information +# already provided by tclConfig.sh, so you may need to use that +# file in addition to this one. +# +# The information in this file is specific to a single platform. + +# tkimg's version number. +tkimg_VERSION='1.3' +tkimg_MAJOR_VERSION='1' +tkimg_MINOR_VERSION='3' +tkimg_RELEASE_LEVEL='' + +# The name of the tkimg library (may be either a .a file or a shared library): +tkimg_LIB_FILE=tkimg13.dll + +# String to pass to linker to pick up the tkimg library from its +# build directory. +tkimg_BUILD_LIB_SPEC='-L/src/tcltk/tkimg1.3/base -ltkimg13' + +# String to pass to linker to pick up the tkimg library from its +# installed directory. +tkimg_LIB_SPEC='-L/mingw/lib/tkimg1.3 -ltkimg13' + +# The name of the tkimg stub library (a .a file): +tkimg_STUB_LIB_FILE=tkimgstub13.a + +# String to pass to linker to pick up the tkimg stub library from its +# build directory. +tkimg_BUILD_STUB_LIB_SPEC='-L/src/tcltk/tkimg1.3/base -ltkimgstub13' + +# String to pass to linker to pick up the tkimg stub library from its +# installed directory. +tkimg_STUB_LIB_SPEC='-L/mingw/lib/tkimg1.3 -ltkimgstub13' + +# String to pass to linker to pick up the tkimg stub library from its +# build directory. +tkimg_BUILD_STUB_LIB_PATH='/src/tcltk/tkimg1.3/base/tkimgstub13.a' + +# String to pass to linker to pick up the tkimg stub library from its +# installed directory. +tkimg_STUB_LIB_PATH='/mingw/lib/tkimg1.3/tkimgstub13.a' + +# Location of the top-level source directories from which tkimg +# was built. This is the directory that contains generic, unix, etc. +# If tkimg was compiled in a different place than the directory +# containing the source files, this points to the location of the +# sources, not the location where tkimg was compiled. This can +# be relative to the build directory. + +tkimg_SRC_DIR='/src/tcltk/tkimg1.3/base' diff --git a/mingw/lib/zlibtclConfig.sh b/mingw/lib/zlibtclConfig.sh new file mode 100644 index 00000000..1e4387b3 --- /dev/null +++ b/mingw/lib/zlibtclConfig.sh @@ -0,0 +1,57 @@ +# zlibtclConfig.sh -- +# +# This shell script (for sh) is generated automatically by zlibtcl's +# configure script. It will create shell variables for most of +# the configuration options discovered by the configure script. +# This script is intended to be included by the configure scripts +# for zlibtcl extensions so that they don't have to figure this all +# out for themselves. This file does not duplicate information +# already provided by tclConfig.sh, so you may need to use that +# file in addition to this one. +# +# The information in this file is specific to a single platform. + +# zlibtcl's version number. +zlibtcl_VERSION='1.2.1' +zlibtcl_MAJOR_VERSION='1' +zlibtcl_MINOR_VERSION='2' +zlibtcl_RELEASE_LEVEL='1' + +# The name of the zlibtcl library (may be either a .a file or a shared library): +zlibtcl_LIB_FILE=zlibtcl121.dll + +# String to pass to linker to pick up the zlibtcl library from its +# build directory. +zlibtcl_BUILD_LIB_SPEC='-L/src/tcltk/tkimg1.3/libz/tcl -lzlibtcl121' + +# String to pass to linker to pick up the zlibtcl library from its +# installed directory. +zlibtcl_LIB_SPEC='-L/mingw/lib/zlibtcl1.2.1 -lzlibtcl121' + +# The name of the zlibtcl stub library (a .a file): +zlibtcl_STUB_LIB_FILE=zlibtclstub121.a + +# String to pass to linker to pick up the zlibtcl stub library from its +# build directory. +zlibtcl_BUILD_STUB_LIB_SPEC='-L/src/tcltk/tkimg1.3/libz/tcl -lzlibtclstub121' + +# String to pass to linker to pick up the zlibtcl stub library from its +# installed directory. +zlibtcl_STUB_LIB_SPEC='-L/mingw/lib/zlibtcl1.2.1 -lzlibtclstub121' + +# String to pass to linker to pick up the zlibtcl stub library from its +# build directory. +zlibtcl_BUILD_STUB_LIB_PATH='/src/tcltk/tkimg1.3/libz/tcl/zlibtclstub121.a' + +# String to pass to linker to pick up the zlibtcl stub library from its +# installed directory. +zlibtcl_STUB_LIB_PATH='/mingw/lib/zlibtcl1.2.1/zlibtclstub121.a' + +# Location of the top-level source directories from which zlibtcl +# was built. This is the directory that contains generic, unix, etc. +# If zlibtcl was compiled in a different place than the directory +# containing the source files, this points to the location of the +# sources, not the location where zlibtcl was compiled. This can +# be relative to the build directory. + +zlibtcl_SRC_DIR='/src/tcltk/tkimg1.3/libz/tcl' diff --git a/src/tcltk/fileList-tkImg.txt b/src/tcltk/fileList-tkImg.txt index e69de29b..e1c4f1ef 100644 --- a/src/tcltk/fileList-tkImg.txt +++ b/src/tcltk/fileList-tkImg.txt @@ -0,0 +1,40 @@ +/mingw/include/jpegtcl.h +/mingw/include/jpegtclDecls.h +/mingw/include/jpegtclDeclsMask.h +/mingw/include/jpegtclDeclsUnmask.h +/mingw/include/tifftcl.h +/mingw/include/tifftclDecls.h +/mingw/include/tifftclDeclsMask.h +/mingw/include/tifftclDeclsUnmask.h +/mingw/include/tkimg.h +/mingw/include/tkimgDecls.h +/mingw/include/zlibtcl.h +/mingw/include/zlibtclDecls.h +/mingw/include/zlibtclDeclsMask.h +/mingw/include/zlibtclDeclsUnmask.h +/mingw/lib/Img1.3/jpegtcl10.dll +/mingw/lib/Img1.3/jpegtclstub10.a +/mingw/lib/Img1.3/pkgIndex.tcl +/mingw/lib/Img1.3/tifftcl361.dll +/mingw/lib/Img1.3/tifftclstub361.a +/mingw/lib/Img1.3/tkimg13.dll +/mingw/lib/Img1.3/tkimgbmp13.dll +/mingw/lib/Img1.3/tkimggif13.dll +/mingw/lib/Img1.3/tkimgico13.dll +/mingw/lib/Img1.3/tkimgpcx13.dll +/mingw/lib/Img1.3/tkimgpixmap13.dll +/mingw/lib/Img1.3/tkimgppm13.dll +/mingw/lib/Img1.3/tkimgps13.dll +/mingw/lib/Img1.3/tkimgsgi13.dll +/mingw/lib/Img1.3/tkimgstub13.a +/mingw/lib/Img1.3/tkimgsun13.dll +/mingw/lib/Img1.3/tkimgtga13.dll +/mingw/lib/Img1.3/tkimgwindow13.dll +/mingw/lib/Img1.3/tkimgxbm13.dll +/mingw/lib/Img1.3/tkimgxpm13.dll +/mingw/lib/Img1.3/zlibtcl121.dll +/mingw/lib/Img1.3/zlibtclstub121.a +/mingw/lib/jpegtclConfig.sh +/mingw/lib/tifftclConfig.sh +/mingw/lib/tkimgConfig.sh +/mingw/lib/zlibtclConfig.sh