~ubuntu-branches/ubuntu/jaunty/freeimage/jaunty

« back to all changes in this revision

Viewing changes to FreeImage/Source/LibTIFF/tiffio.h

  • Committer: Bazaar Package Importer
  • Author(s): Federico Di Gregorio
  • Date: 2007-05-07 15:35:21 UTC
  • Revision ID: james.westby@ubuntu.com-20070507153521-m4lx765bzxxug9qf
Tags: upstream-3.9.3
ImportĀ upstreamĀ versionĀ 3.9.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* $Id: tiffio.h,v 1.16 2006/10/28 19:36:43 drolon Exp $ */
 
2
 
 
3
/*
 
4
 * Copyright (c) 1988-1997 Sam Leffler
 
5
 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
 
6
 *
 
7
 * Permission to use, copy, modify, distribute, and sell this software and 
 
8
 * its documentation for any purpose is hereby granted without fee, provided
 
9
 * that (i) the above copyright notices and this permission notice appear in
 
10
 * all copies of the software and related documentation, and (ii) the names of
 
11
 * Sam Leffler and Silicon Graphics may not be used in any advertising or
 
12
 * publicity relating to the software without the specific, prior written
 
13
 * permission of Sam Leffler and Silicon Graphics.
 
14
 * 
 
15
 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
 
16
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
 
17
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
 
18
 * 
 
19
 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
 
20
 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
 
21
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 
22
 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
 
23
 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 
24
 * OF THIS SOFTWARE.
 
25
 */
 
26
 
 
27
#ifndef _TIFFIO_
 
28
#define _TIFFIO_
 
29
 
 
30
/*
 
31
 * TIFF I/O Library Definitions.
 
32
 */
 
33
#include "tiff.h"
 
34
#include "tiffvers.h"
 
35
 
 
36
/*
 
37
 * TIFF is defined as an incomplete type to hide the
 
38
 * library's internal data structures from clients.
 
39
 */
 
40
typedef struct tiff TIFF;
 
41
 
 
42
/*
 
43
 * The following typedefs define the intrinsic size of
 
44
 * data types used in the *exported* interfaces.  These
 
45
 * definitions depend on the proper definition of types
 
46
 * in tiff.h.  Note also that the varargs interface used
 
47
 * to pass tag types and values uses the types defined in
 
48
 * tiff.h directly.
 
49
 *
 
50
 * NB: ttag_t is unsigned int and not unsigned short because
 
51
 *     ANSI C requires that the type before the ellipsis be a
 
52
 *     promoted type (i.e. one of int, unsigned int, pointer,
 
53
 *     or double) and because we defined pseudo-tags that are
 
54
 *     outside the range of legal Aldus-assigned tags.
 
55
 * NB: tsize_t is int32 and not uint32 because some functions
 
56
 *     return -1.
 
57
 * NB: toff_t is not off_t for many reasons; TIFFs max out at
 
58
 *     32-bit file offsets being the most important, and to ensure
 
59
 *     that it is unsigned, rather than signed.
 
60
 */
 
61
typedef uint32 ttag_t;          /* directory tag */
 
62
typedef uint16 tdir_t;          /* directory index */
 
63
typedef uint16 tsample_t;       /* sample number */
 
64
typedef uint32 tstrile_t;       /* strip or tile number */
 
65
typedef tstrile_t tstrip_t;     /* strip number */
 
66
typedef tstrile_t ttile_t;      /* tile number */
 
67
typedef int32 tsize_t;          /* i/o size in bytes */
 
68
typedef void* tdata_t;          /* image data ref */
 
69
typedef uint32 toff_t;          /* file offset */
 
70
 
 
71
#if !defined(__WIN32__) && (defined(_WIN32) || defined(WIN32))
 
72
#define __WIN32__
 
73
#endif
 
74
 
 
75
/*
 
76
 * On windows you should define USE_WIN32_FILEIO if you are using tif_win32.c
 
77
 * or AVOID_WIN32_FILEIO if you are using something else (like tif_unix.c).
 
78
 *
 
79
 * By default tif_unix.c is assumed.
 
80
 */
 
81
 
 
82
#if defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows)
 
83
#  if !defined(__CYGWIN) && !defined(AVOID_WIN32_FILEIO) && !defined(USE_WIN32_FILEIO)
 
84
#    define AVOID_WIN32_FILEIO
 
85
#  endif
 
86
#endif
 
87
 
 
88
#if defined(USE_WIN32_FILEIO)
 
89
# define VC_EXTRALEAN
 
90
# include <windows.h>
 
91
# ifdef __WIN32__
 
92
DECLARE_HANDLE(thandle_t);      /* Win32 file handle */
 
93
# else
 
94
typedef HFILE thandle_t;        /* client data handle */
 
95
# endif /* __WIN32__ */
 
96
#else
 
97
typedef void* thandle_t;        /* client data handle */
 
98
#endif /* USE_WIN32_FILEIO */
 
99
 
 
100
/*
 
101
 * Flags to pass to TIFFPrintDirectory to control
 
102
 * printing of data structures that are potentially
 
103
 * very large.   Bit-or these flags to enable printing
 
104
 * multiple items.
 
105
 */
 
106
#define TIFFPRINT_NONE          0x0             /* no extra info */
 
107
#define TIFFPRINT_STRIPS        0x1             /* strips/tiles info */
 
108
#define TIFFPRINT_CURVES        0x2             /* color/gray response curves */
 
109
#define TIFFPRINT_COLORMAP      0x4             /* colormap */
 
110
#define TIFFPRINT_JPEGQTABLES   0x100           /* JPEG Q matrices */
 
111
#define TIFFPRINT_JPEGACTABLES  0x200           /* JPEG AC tables */
 
112
#define TIFFPRINT_JPEGDCTABLES  0x200           /* JPEG DC tables */
 
113
 
 
114
/* 
 
115
 * Colour conversion stuff
 
116
 */
 
117
 
 
118
/* reference white */
 
119
#define D65_X0 (95.0470F)
 
120
#define D65_Y0 (100.0F)
 
121
#define D65_Z0 (108.8827F)
 
122
 
 
123
#define D50_X0 (96.4250F)
 
124
#define D50_Y0 (100.0F)
 
125
#define D50_Z0 (82.4680F)
 
126
 
 
127
/* Structure for holding information about a display device. */
 
128
 
 
129
typedef unsigned char TIFFRGBValue;             /* 8-bit samples */
 
130
 
 
131
typedef struct {
 
132
        float d_mat[3][3];              /* XYZ -> luminance matrix */
 
133
        float d_YCR;                    /* Light o/p for reference white */
 
134
        float d_YCG;
 
135
        float d_YCB;
 
136
        uint32 d_Vrwr;                  /* Pixel values for ref. white */
 
137
        uint32 d_Vrwg;
 
138
        uint32 d_Vrwb;
 
139
        float d_Y0R;                    /* Residual light for black pixel */
 
140
        float d_Y0G;
 
141
        float d_Y0B;
 
142
        float d_gammaR;                 /* Gamma values for the three guns */
 
143
        float d_gammaG;
 
144
        float d_gammaB;
 
145
} TIFFDisplay;
 
146
 
 
147
typedef struct {                                /* YCbCr->RGB support */
 
148
        TIFFRGBValue* clamptab;                 /* range clamping table */
 
149
        int*    Cr_r_tab;
 
150
        int*    Cb_b_tab;
 
151
        int32*  Cr_g_tab;
 
152
        int32*  Cb_g_tab;
 
153
        int32*  Y_tab;
 
154
} TIFFYCbCrToRGB;
 
155
 
 
156
typedef struct {                                /* CIE Lab 1976->RGB support */
 
157
        int     range;                          /* Size of conversion table */
 
158
#define CIELABTORGB_TABLE_RANGE 1500
 
159
        float   rstep, gstep, bstep;
 
160
        float   X0, Y0, Z0;                     /* Reference white point */
 
161
        TIFFDisplay display;
 
162
        float   Yr2r[CIELABTORGB_TABLE_RANGE + 1];  /* Conversion of Yr to r */
 
163
        float   Yg2g[CIELABTORGB_TABLE_RANGE + 1];  /* Conversion of Yg to g */
 
164
        float   Yb2b[CIELABTORGB_TABLE_RANGE + 1];  /* Conversion of Yb to b */
 
165
} TIFFCIELabToRGB;
 
166
 
 
167
/*
 
168
 * RGBA-style image support.
 
169
 */
 
170
typedef struct _TIFFRGBAImage TIFFRGBAImage;
 
171
/*
 
172
 * The image reading and conversion routines invoke
 
173
 * ``put routines'' to copy/image/whatever tiles of
 
174
 * raw image data.  A default set of routines are 
 
175
 * provided to convert/copy raw image data to 8-bit
 
176
 * packed ABGR format rasters.  Applications can supply
 
177
 * alternate routines that unpack the data into a
 
178
 * different format or, for example, unpack the data
 
179
 * and draw the unpacked raster on the display.
 
180
 */
 
181
typedef void (*tileContigRoutine)
 
182
    (TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32,
 
183
        unsigned char*);
 
184
typedef void (*tileSeparateRoutine)
 
185
    (TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32,
 
186
        unsigned char*, unsigned char*, unsigned char*, unsigned char*);
 
187
/*
 
188
 * RGBA-reader state.
 
189
 */
 
190
struct _TIFFRGBAImage {
 
191
        TIFF*   tif;                            /* image handle */
 
192
        int     stoponerr;                      /* stop on read error */
 
193
        int     isContig;                       /* data is packed/separate */
 
194
        int     alpha;                          /* type of alpha data present */
 
195
        uint32  width;                          /* image width */
 
196
        uint32  height;                         /* image height */
 
197
        uint16  bitspersample;                  /* image bits/sample */
 
198
        uint16  samplesperpixel;                /* image samples/pixel */
 
199
        uint16  orientation;                    /* image orientation */
 
200
        uint16  req_orientation;                /* requested orientation */
 
201
        uint16  photometric;                    /* image photometric interp */
 
202
        uint16* redcmap;                        /* colormap pallete */
 
203
        uint16* greencmap;
 
204
        uint16* bluecmap;
 
205
                                                /* get image data routine */
 
206
        int     (*get)(TIFFRGBAImage*, uint32*, uint32, uint32);
 
207
        union {
 
208
            void (*any)(TIFFRGBAImage*);
 
209
            tileContigRoutine   contig;
 
210
            tileSeparateRoutine separate;
 
211
        } put;                                  /* put decoded strip/tile */
 
212
        TIFFRGBValue* Map;                      /* sample mapping array */
 
213
        uint32** BWmap;                         /* black&white map */
 
214
        uint32** PALmap;                        /* palette image map */
 
215
        TIFFYCbCrToRGB* ycbcr;                  /* YCbCr conversion state */
 
216
        TIFFCIELabToRGB* cielab;                /* CIE L*a*b conversion state */
 
217
 
 
218
        uint8* UaToAa;                          /* Unassociated alpha to associated alpha convertion LUT */
 
219
        uint8* Bitdepth16To8;                   /* LUT for conversion from 16bit to 8bit values */
 
220
 
 
221
        int     row_offset;
 
222
        int     col_offset;
 
223
};
 
224
 
 
225
/*
 
226
 * Macros for extracting components from the
 
227
 * packed ABGR form returned by TIFFReadRGBAImage.
 
228
 */
 
229
#define TIFFGetR(abgr)  ((abgr) & 0xff)
 
230
#define TIFFGetG(abgr)  (((abgr) >> 8) & 0xff)
 
231
#define TIFFGetB(abgr)  (((abgr) >> 16) & 0xff)
 
232
#define TIFFGetA(abgr)  (((abgr) >> 24) & 0xff)
 
233
 
 
234
/*
 
235
 * A CODEC is a software package that implements decoding,
 
236
 * encoding, or decoding+encoding of a compression algorithm.
 
237
 * The library provides a collection of builtin codecs.
 
238
 * More codecs may be registered through calls to the library
 
239
 * and/or the builtin implementations may be overridden.
 
240
 */
 
241
typedef int (*TIFFInitMethod)(TIFF*, int);
 
242
typedef struct {
 
243
        char*           name;
 
244
        uint16          scheme;
 
245
        TIFFInitMethod  init;
 
246
} TIFFCodec;
 
247
 
 
248
#include <stdio.h>
 
249
#include <stdarg.h>
 
250
 
 
251
/* share internal LogLuv conversion routines? */
 
252
#ifndef LOGLUV_PUBLIC
 
253
#define LOGLUV_PUBLIC           1
 
254
#endif
 
255
 
 
256
#if defined(c_plusplus) || defined(__cplusplus)
 
257
extern "C" {
 
258
#endif
 
259
typedef void (*TIFFErrorHandler)(const char*, const char*, va_list);
 
260
typedef void (*TIFFErrorHandlerExt)(thandle_t, const char*, const char*, va_list);
 
261
typedef tsize_t (*TIFFReadWriteProc)(thandle_t, tdata_t, tsize_t);
 
262
typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int);
 
263
typedef int (*TIFFCloseProc)(thandle_t);
 
264
typedef toff_t (*TIFFSizeProc)(thandle_t);
 
265
typedef int (*TIFFMapFileProc)(thandle_t, tdata_t*, toff_t*);
 
266
typedef void (*TIFFUnmapFileProc)(thandle_t, tdata_t, toff_t);
 
267
typedef void (*TIFFExtendProc)(TIFF*); 
 
268
 
 
269
extern  const char* TIFFGetVersion(void);
 
270
 
 
271
extern  const TIFFCodec* TIFFFindCODEC(uint16);
 
272
extern  TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod);
 
273
extern  void TIFFUnRegisterCODEC(TIFFCodec*);
 
274
extern  int TIFFIsCODECConfigured(uint16);
 
275
extern  TIFFCodec* TIFFGetConfiguredCODECs(void);
 
276
 
 
277
/*
 
278
 * Auxiliary functions.
 
279
 */
 
280
 
 
281
extern  tdata_t _TIFFmalloc(tsize_t);
 
282
extern  tdata_t _TIFFrealloc(tdata_t, tsize_t);
 
283
extern  void _TIFFmemset(tdata_t, int, tsize_t);
 
284
extern  void _TIFFmemcpy(tdata_t, const tdata_t, tsize_t);
 
285
extern  int _TIFFmemcmp(const tdata_t, const tdata_t, tsize_t);
 
286
extern  void _TIFFfree(tdata_t);
 
287
 
 
288
/*
 
289
** Stuff, related to tag handling and creating custom tags.
 
290
*/
 
291
extern  int  TIFFGetTagListCount( TIFF * );
 
292
extern  ttag_t TIFFGetTagListEntry( TIFF *, int tag_index );
 
293
    
 
294
#define TIFF_ANY        TIFF_NOTYPE     /* for field descriptor searching */
 
295
#define TIFF_VARIABLE   -1              /* marker for variable length tags */
 
296
#define TIFF_SPP        -2              /* marker for SamplesPerPixel tags */
 
297
#define TIFF_VARIABLE2  -3              /* marker for uint32 var-length tags */
 
298
 
 
299
#define FIELD_CUSTOM    65    
 
300
 
 
301
typedef struct {
 
302
        ttag_t  field_tag;              /* field's tag */
 
303
        short   field_readcount;        /* read count/TIFF_VARIABLE/TIFF_SPP */
 
304
        short   field_writecount;       /* write count/TIFF_VARIABLE */
 
305
        TIFFDataType field_type;        /* type of associated data */
 
306
        unsigned short field_bit;       /* bit in fieldsset bit vector */
 
307
        unsigned char field_oktochange; /* if true, can change while writing */
 
308
        unsigned char field_passcount;  /* if true, pass dir count on set */
 
309
        char    *field_name;            /* ASCII name */
 
310
} TIFFFieldInfo;
 
311
 
 
312
typedef struct _TIFFTagValue {
 
313
    const TIFFFieldInfo  *info;
 
314
    int             count;
 
315
    void           *value;
 
316
} TIFFTagValue;
 
317
 
 
318
extern  void TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], int);
 
319
extern  const TIFFFieldInfo* TIFFFindFieldInfo(TIFF*, ttag_t, TIFFDataType);
 
320
extern  const TIFFFieldInfo* TIFFFindFieldInfoByName(TIFF* , const char *,
 
321
                                                     TIFFDataType);
 
322
extern  const TIFFFieldInfo* TIFFFieldWithTag(TIFF*, ttag_t);
 
323
extern  const TIFFFieldInfo* TIFFFieldWithName(TIFF*, const char *);
 
324
 
 
325
typedef int (*TIFFVSetMethod)(TIFF*, ttag_t, va_list);
 
326
typedef int (*TIFFVGetMethod)(TIFF*, ttag_t, va_list);
 
327
typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long);
 
328
    
 
329
typedef struct {
 
330
    TIFFVSetMethod      vsetfield;      /* tag set routine */
 
331
    TIFFVGetMethod      vgetfield;      /* tag get routine */
 
332
    TIFFPrintMethod     printdir;       /* directory print routine */
 
333
} TIFFTagMethods;
 
334
        
 
335
extern  TIFFTagMethods *TIFFAccessTagMethods( TIFF * );
 
336
extern  void *TIFFGetClientInfo( TIFF *, const char * );
 
337
extern  void TIFFSetClientInfo( TIFF *, void *, const char * );
 
338
 
 
339
extern  void TIFFCleanup(TIFF*);
 
340
extern  void TIFFClose(TIFF*);
 
341
extern  int TIFFFlush(TIFF*);
 
342
extern  int TIFFFlushData(TIFF*);
 
343
extern  int TIFFGetField(TIFF*, ttag_t, ...);
 
344
extern  int TIFFVGetField(TIFF*, ttag_t, va_list);
 
345
extern  int TIFFGetFieldDefaulted(TIFF*, ttag_t, ...);
 
346
extern  int TIFFVGetFieldDefaulted(TIFF*, ttag_t, va_list);
 
347
extern  int TIFFReadDirectory(TIFF*);
 
348
extern  int TIFFReadCustomDirectory(TIFF*, toff_t, const TIFFFieldInfo[],
 
349
                                    size_t);
 
350
extern  int TIFFReadEXIFDirectory(TIFF*, toff_t);
 
351
extern  tsize_t TIFFScanlineSize(TIFF*);
 
352
extern  tsize_t TIFFOldScanlineSize(TIFF*);
 
353
extern  tsize_t TIFFNewScanlineSize(TIFF*);
 
354
extern  tsize_t TIFFRasterScanlineSize(TIFF*);
 
355
extern  tsize_t TIFFStripSize(TIFF*);
 
356
extern  tsize_t TIFFRawStripSize(TIFF*, tstrip_t);
 
357
extern  tsize_t TIFFVStripSize(TIFF*, uint32);
 
358
extern  tsize_t TIFFTileRowSize(TIFF*);
 
359
extern  tsize_t TIFFTileSize(TIFF*);
 
360
extern  tsize_t TIFFVTileSize(TIFF*, uint32);
 
361
extern  uint32 TIFFDefaultStripSize(TIFF*, uint32);
 
362
extern  void TIFFDefaultTileSize(TIFF*, uint32*, uint32*);
 
363
extern  int TIFFFileno(TIFF*);
 
364
extern  int TIFFSetFileno(TIFF*, int);
 
365
extern  thandle_t TIFFClientdata(TIFF*);
 
366
extern  thandle_t TIFFSetClientdata(TIFF*, thandle_t);
 
367
extern  int TIFFGetMode(TIFF*);
 
368
extern  int TIFFSetMode(TIFF*, int);
 
369
extern  int TIFFIsTiled(TIFF*);
 
370
extern  int TIFFIsByteSwapped(TIFF*);
 
371
extern  int TIFFIsUpSampled(TIFF*);
 
372
extern  int TIFFIsMSB2LSB(TIFF*);
 
373
extern  int TIFFIsBigEndian(TIFF*);
 
374
extern  TIFFReadWriteProc TIFFGetReadProc(TIFF*);
 
375
extern  TIFFReadWriteProc TIFFGetWriteProc(TIFF*);
 
376
extern  TIFFSeekProc TIFFGetSeekProc(TIFF*);
 
377
extern  TIFFCloseProc TIFFGetCloseProc(TIFF*);
 
378
extern  TIFFSizeProc TIFFGetSizeProc(TIFF*);
 
379
extern  TIFFMapFileProc TIFFGetMapFileProc(TIFF*);
 
380
extern  TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF*);
 
381
extern  uint32 TIFFCurrentRow(TIFF*);
 
382
extern  tdir_t TIFFCurrentDirectory(TIFF*);
 
383
extern  tdir_t TIFFNumberOfDirectories(TIFF*);
 
384
extern  uint32 TIFFCurrentDirOffset(TIFF*);
 
385
extern  tstrip_t TIFFCurrentStrip(TIFF*);
 
386
extern  ttile_t TIFFCurrentTile(TIFF*);
 
387
extern  int TIFFReadBufferSetup(TIFF*, tdata_t, tsize_t);
 
388
extern  int TIFFWriteBufferSetup(TIFF*, tdata_t, tsize_t);
 
389
extern  int TIFFSetupStrips(TIFF *);
 
390
extern  int TIFFWriteCheck(TIFF*, int, const char *);
 
391
extern  void TIFFFreeDirectory(TIFF*);
 
392
extern  int TIFFCreateDirectory(TIFF*);
 
393
extern  int TIFFLastDirectory(TIFF*);
 
394
extern  int TIFFSetDirectory(TIFF*, tdir_t);
 
395
extern  int TIFFSetSubDirectory(TIFF*, uint32);
 
396
extern  int TIFFUnlinkDirectory(TIFF*, tdir_t);
 
397
extern  int TIFFSetField(TIFF*, ttag_t, ...);
 
398
extern  int TIFFVSetField(TIFF*, ttag_t, va_list);
 
399
extern  int TIFFWriteDirectory(TIFF *);
 
400
extern  int TIFFCheckpointDirectory(TIFF *);
 
401
extern  int TIFFRewriteDirectory(TIFF *);
 
402
extern  int TIFFReassignTagToIgnore(enum TIFFIgnoreSense, int);
 
403
 
 
404
#if defined(c_plusplus) || defined(__cplusplus)
 
405
extern  void TIFFPrintDirectory(TIFF*, FILE*, long = 0);
 
406
extern  int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t = 0);
 
407
extern  int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t = 0);
 
408
extern  int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0);
 
409
extern  int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*,
 
410
                                      int = ORIENTATION_BOTLEFT, int = 0);
 
411
#else
 
412
extern  void TIFFPrintDirectory(TIFF*, FILE*, long);
 
413
extern  int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t);
 
414
extern  int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t);
 
415
extern  int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int);
 
416
extern  int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, int, int);
 
417
#endif
 
418
 
 
419
extern  int TIFFReadRGBAStrip(TIFF*, tstrip_t, uint32 * );
 
420
extern  int TIFFReadRGBATile(TIFF*, uint32, uint32, uint32 * );
 
421
extern  int TIFFRGBAImageOK(TIFF*, char [1024]);
 
422
extern  int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]);
 
423
extern  int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32);
 
424
extern  void TIFFRGBAImageEnd(TIFFRGBAImage*);
 
425
extern  TIFF* TIFFOpen(const char*, const char*);
 
426
# ifdef __WIN32__
 
427
extern  TIFF* TIFFOpenW(const wchar_t*, const char*);
 
428
# endif /* __WIN32__ */
 
429
extern  TIFF* TIFFFdOpen(int, const char*, const char*);
 
430
extern  TIFF* TIFFClientOpen(const char*, const char*,
 
431
            thandle_t,
 
432
            TIFFReadWriteProc, TIFFReadWriteProc,
 
433
            TIFFSeekProc, TIFFCloseProc,
 
434
            TIFFSizeProc,
 
435
            TIFFMapFileProc, TIFFUnmapFileProc);
 
436
extern  const char* TIFFFileName(TIFF*);
 
437
extern  const char* TIFFSetFileName(TIFF*, const char *);
 
438
extern  void TIFFError(const char*, const char*, ...);
 
439
extern  void TIFFErrorExt(thandle_t, const char*, const char*, ...);
 
440
extern  void TIFFWarning(const char*, const char*, ...);
 
441
extern  void TIFFWarningExt(thandle_t, const char*, const char*, ...);
 
442
extern  TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler);
 
443
extern  TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt);
 
444
extern  TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler);
 
445
extern  TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt);
 
446
extern  TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc);
 
447
extern  ttile_t TIFFComputeTile(TIFF*, uint32, uint32, uint32, tsample_t);
 
448
extern  int TIFFCheckTile(TIFF*, uint32, uint32, uint32, tsample_t);
 
449
extern  ttile_t TIFFNumberOfTiles(TIFF*);
 
450
extern  tsize_t TIFFReadTile(TIFF*,
 
451
            tdata_t, uint32, uint32, uint32, tsample_t);
 
452
extern  tsize_t TIFFWriteTile(TIFF*,
 
453
            tdata_t, uint32, uint32, uint32, tsample_t);
 
454
extern  tstrip_t TIFFComputeStrip(TIFF*, uint32, tsample_t);
 
455
extern  tstrip_t TIFFNumberOfStrips(TIFF*);
 
456
extern  tsize_t TIFFReadEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
 
457
extern  tsize_t TIFFReadRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
 
458
extern  tsize_t TIFFReadEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t);
 
459
extern  tsize_t TIFFReadRawTile(TIFF*, ttile_t, tdata_t, tsize_t);
 
460
extern  tsize_t TIFFWriteEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
 
461
extern  tsize_t TIFFWriteRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
 
462
extern  tsize_t TIFFWriteEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t);
 
463
extern  tsize_t TIFFWriteRawTile(TIFF*, ttile_t, tdata_t, tsize_t);
 
464
extern  int TIFFDataWidth(TIFFDataType);    /* table of tag datatype widths */
 
465
extern  void TIFFSetWriteOffset(TIFF*, toff_t);
 
466
extern  void TIFFSwabShort(uint16*);
 
467
extern  void TIFFSwabLong(uint32*);
 
468
extern  void TIFFSwabDouble(double*);
 
469
extern  void TIFFSwabArrayOfShort(uint16*, unsigned long);
 
470
extern  void TIFFSwabArrayOfTriples(uint8*, unsigned long);
 
471
extern  void TIFFSwabArrayOfLong(uint32*, unsigned long);
 
472
extern  void TIFFSwabArrayOfDouble(double*, unsigned long);
 
473
extern  void TIFFReverseBits(unsigned char *, unsigned long);
 
474
extern  const unsigned char* TIFFGetBitRevTable(int);
 
475
 
 
476
#ifdef LOGLUV_PUBLIC
 
477
#define U_NEU           0.210526316
 
478
#define V_NEU           0.473684211
 
479
#define UVSCALE         410.
 
480
extern  double LogL16toY(int);
 
481
extern  double LogL10toY(int);
 
482
extern  void XYZtoRGB24(float*, uint8*);
 
483
extern  int uv_decode(double*, double*, int);
 
484
extern  void LogLuv24toXYZ(uint32, float*);
 
485
extern  void LogLuv32toXYZ(uint32, float*);
 
486
#if defined(c_plusplus) || defined(__cplusplus)
 
487
extern  int LogL16fromY(double, int = SGILOGENCODE_NODITHER);
 
488
extern  int LogL10fromY(double, int = SGILOGENCODE_NODITHER);
 
489
extern  int uv_encode(double, double, int = SGILOGENCODE_NODITHER);
 
490
extern  uint32 LogLuv24fromXYZ(float*, int = SGILOGENCODE_NODITHER);
 
491
extern  uint32 LogLuv32fromXYZ(float*, int = SGILOGENCODE_NODITHER);
 
492
#else
 
493
extern  int LogL16fromY(double, int);
 
494
extern  int LogL10fromY(double, int);
 
495
extern  int uv_encode(double, double, int);
 
496
extern  uint32 LogLuv24fromXYZ(float*, int);
 
497
extern  uint32 LogLuv32fromXYZ(float*, int);
 
498
#endif
 
499
#endif /* LOGLUV_PUBLIC */
 
500
    
 
501
extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB*, TIFFDisplay *, float*);
 
502
extern void TIFFCIELabToXYZ(TIFFCIELabToRGB *, uint32, int32, int32,
 
503
                            float *, float *, float *);
 
504
extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float,
 
505
                         uint32 *, uint32 *, uint32 *);
 
506
 
 
507
extern int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB*, float*, float*);
 
508
extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32, int32, int32,
 
509
                           uint32 *, uint32 *, uint32 *);
 
510
 
 
511
#if defined(c_plusplus) || defined(__cplusplus)
 
512
}
 
513
#endif
 
514
 
 
515
#endif /* _TIFFIO_ */
 
516
 
 
517
/* vim: set ts=8 sts=8 sw=8 noet: */