LibTIFF

https://libtiff.gitlab.io/libtiff/
Admin
LibTIFF is a library and collection of tools for reading, writing, and manipulating TIFF (Tag Image...
Tokens:155,697
Snippets:2,057
Trust Score:7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Write EXIF Directory Pointer

Source: https://libtiff.gitlab.io/libtiff/functions/TIFFCustomDirectory.html

Example of returning to the main directory and linking a custom EXIF directory offset.

```c
 /* Go back to the first directory, and add the EXIFIFD pointer. */
TIFFSetDirectory(tif, 0);
TIFFSetField(tif, TIFFTAG_EXIFIFD, pdiroff);
```

--------------------------------

### Initialize Tiled Image Read

Source: https://libtiff.gitlab.io/libtiff/_sources/libtiff.rst.txt

Setup variables for reading a tiled TIFF image.

```c
main()
{
    TIFF* tif = TIFFOpen("myfile.tif", "r");
    if (tif) {
        uint32_t imageWidth, imageLength;
        uint32_t tileWidth, tileLength;
        uint32_t x, y;
        void *buf;
```

--------------------------------

### Standard Build Process

Source: https://libtiff.gitlab.io/libtiff/_sources/build.rst.txt

The basic sequence of commands to configure, build, test, and install the software from the source directory.

```shell
% cd ./tiff-4.0.5
% ./configure
    ...lots of messages...
% make
    ...lots of messages...
% make check
    ...lots of messages...
# make install
```

--------------------------------

### Initialize and Use YCbCr to RGB Conversion

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFcolor.rst.txt

Example demonstrating memory allocation, initialization, and conversion loop for YCbCr to RGB.

```c
float *luma, *refBlackWhite;
uint16_t hs, vs;

/* Initialize structures */
TIFFYCbCrToRGB *ycbcr = (TIFFYCbCrToRGB*)
    _TIFFmalloc(TIFFroundup(sizeof(TIFFYCbCrToRGB), sizeof(long))
        + 4*256*sizeof(TIFFRGBValue)
        + 2*256*sizeof(int)
        + 3*256*sizeof(int32_t));
if (ycbcr == NULL) {
    TIFFError("YCbCr->RGB",
    "No space for YCbCr->RGB conversion state");
    exit(0);
}

TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRCOEFFICIENTS, &luma);
TIFFGetFieldDefaulted(tif, TIFFTAG_REFERENCEBLACKWHITE, &refBlackWhite);
if (TIFFYCbCrToRGBInit(ycbcr, luma, refBlackWhite) < 0) {
    exit(0);
}

/* Start conversion */
uint32_t r, g, b;
uint32_t Y;
int32_t Cb, Cr;

for each pixel in image {
    TIFFYCbCrtoRGB(img->ycbcr, Y, Cb, Cr, &r, &g, &b);
}

/* Free state structure */
_TIFFfree(ycbcr);
```

--------------------------------

### Build libtiff from source

Source: https://libtiff.gitlab.io/libtiff/build.html

Standard sequence of commands to configure, build, test, and install the software in the source directory.

```shell
% cd ./tiff-4.0.5
% ./configure
    ...lots of messages...
% make
    ...lots of messages...
% make check
    ...lots of messages...
# make install

```

--------------------------------

### Build TIFF on UNIX with CMake

Source: https://libtiff.gitlab.io/libtiff/_sources/build.rst.txt

Standard workflow for configuring, building, testing, and installing the software on a UNIX system.

```shell
$ cd ./tiff-4.0.5
$ cmake
    ...lots of messages...
$ make
    ...lots of messages...
$ make test
    ...lots of messages...
# make install
```

--------------------------------

### Custom Raster Put Method Example

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFRGBAImage.rst.txt

Example of overriding TIFFRGBAImage put methods to store raster data in a custom format, shown with simultaneous display logic.

```c
static void
putContigAndDraw(TIFFRGBAImage* img, uint32_t* raster,
    uint32_t x, uint32_t y, uint32_t w, uint32_t h,
    int32_t fromskew, int32_t toskew,
    unsigned char* cp)
{
    (*putContig)(img, raster, x, y, w, h, fromskew, toskew, cp);
    if (x+w == width) {
	w = width;
	if (img->orientation == ORIENTATION_TOPLEFT)

```

--------------------------------

### Configuring TIFFOpenOptions with Custom Error Handler

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFOpenOptions.rst.txt

Example demonstrating the allocation of TIFFOpenOptions, setting memory limits, and registering a custom re-entrant error handler with user data.

```c
#include "tiffio.h"

typedef struct MyErrorHandlerUserDataStruct
{
    /* ... any user data structure ... */
} MyErrorHandlerUserDataStruct;

static int myErrorHandler(TIFF *tiff, void *user_data, const char *module,
                      const char *fmt, va_list ap)
{
    MyErrorHandlerUserDataStruct *errorhandler_user_data =
        (MyErrorHandlerUserDataStruct *)user_data;
    /*... code of myErrorHandler ...*/
    return 1;
}


main()
{
    tmsize_t limit = (256 * 1024 * 1024);
    MyErrorHandlerUserDataStruct user_data = { /* ... any data ... */};

    TIFFOpenOptions *opts = TIFFOpenOptionsAlloc();
    TIFFOpenOptionsSetMaxSingleMemAlloc(opts, limit);
    TIFFOpenOptionsSetErrorHandlerExtR(opts, myErrorHandler, &user_data);
    TIFF *tif = TIFFOpenExt("foo.tif", "r", opts);
    TIFFOpenOptionsFree(opts);
    /* ... go on here ... */

    TIFFClose(tif);
}
```

--------------------------------

### Read Multi-Page and SubIFD TIFF

Source: https://libtiff.gitlab.io/libtiff/_sources/multi_page.rst.txt

This example shows how to read multi-page TIFF files and SubIFDs. It iterates through directories, checks for SubIFDs, and navigates the SubIFD chain. The TIFF file must be opened in read mode.

```c
/* Reading of multi-page and SubIFD images (subfiles) */
    if (!(tiff = TIFFOpen(filename, "r"))) 
        return 1;

    tdir_t currentDirNumber = TIFFCurrentDirectory(tiff);

    /* The first directory is already read through TIFFOpen() */
    int blnRead = 0;
    do
    {
        /*Check if there are SubIFD subfiles */
        void *ptr;
        if (TIFFGetField(tiff, TIFFTAG_SUBIFD, &number_of_sub_IFDs, &ptr))
        {
            /* Copy SubIFD array from pointer */
            memcpy(sub_IFDs_offsets, ptr,
                   number_of_sub_IFDs * sizeof(sub_IFDs_offsets[0]));

            for (int i = 0; i < number_of_sub_IFDs; i++)
            {
                /* Read first SubIFD directory */
                if (!TIFFSetSubDirectory(tiff, sub_IFDs_offsets[i]))
                    return 1;
                /* Check if there is a SubIFD chain behind the first one from
                 * the array, as specified by Adobe */
                while (TIFFReadDirectory(tiff))
                    /* analyse subfile */
                    ;
            }
            /* Go back to main-IFD chain and re-read that main-IFD directory */
            if (!TIFFSetDirectory(tiff, currentDirNumber))
                return 1;
        }
        /* Read next main-IFD directory (subfile) */
        blnRead = TIFFReadDirectory(tiff);
        currentDirNumber = TIFFCurrentDirectory(tiff);
    } while (blnRead);
    TIFFClose(tiff);

```

--------------------------------

### Build with MSBuild on Windows

Source: https://libtiff.gitlab.io/libtiff/_sources/build.rst.txt

Configuring and building using Visual Studio 2013 for a 64-bit Release build.

```shell
cmake -G "Visual Studio 12 2013 Win64"
cmake --build . --config Release
ctest -V -C Release
cmake --build . --config Release --target install
```

--------------------------------

### Incorrect Scanline Read Order

Source: https://libtiff.gitlab.io/libtiff/_sources/libtiff.rst.txt

An example of an incorrect loop order for PLANARCONFIG_SEPARATE that causes issues with compressed strips.

```c
            for (row = 0; row < imagelength; row++)
                for (s = 0; s < nsamples; s++)
                    TIFFReadScanline(tif, buf, row, s);
```

--------------------------------

### Read TIFF Scanlines

Source: https://libtiff.gitlab.io/libtiff/_sources/libtiff.rst.txt

Provides examples for reading scanline-organized TIFF files, including handling planar configurations.

```c
#include "tiffio.h"
    main()
    {
        TIFF* tif = TIFFOpen("myfile.tif", "r");
        if (tif) {
            uint32_t imagelength;
            void *buf;
            uint32_t row;
            
            TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &imagelength);
            buf = _TIFFmalloc(TIFFScanlineSize(tif));
            for (row = 0; row < imagelength; row++)
                TIFFReadScanline(tif, buf, row, 0);
            _TIFFfree(buf);
            TIFFClose(tif);
        }
    }
```

```c
#include "tiffio.h"
    main()
    {
        TIFF* tif = TIFFOpen("myfile.tif", "r");
        if (tif) {
            uint32_t imagelength;
            void *buf;
            uint32_t row;
            
            TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &imagelength);
            TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &config);
            buf = _TIFFmalloc(TIFFScanlineSize(tif));
```

--------------------------------

### Configure and build in source tree

Source: https://libtiff.gitlab.io/libtiff/build.html

Builds the software directly within the source directory structure.

```shell
% gzip -dc tiff-4.0.5.tar.gz | tar -xf -
% cd ./tiff-4.0.5
% ./configure
% make
% make check
% make install

```

--------------------------------

### Generate version.h using mkversion

Source: https://libtiff.gitlab.io/libtiff/_sources/build.rst.txt

Use this sequence to compile and execute the mkversion utility to generate the version.h header file.

```shell
cd libtiff
cc -o mkversion mkversion.c
rm -f version.h
./mkversion -v ../VERSION -a ../dist/tiff.alpha version.h
```

--------------------------------

### TIFFCreateEXIFDirectory

Source: https://libtiff.gitlab.io/libtiff/functions/TIFFCustomDirectory.html

Sets up an EXIF directory and sets the context of the TIFF-handle to that directory.

```APIDOC
## int TIFFCreateEXIFDirectory(TIFF *tif)

### Description
Sets up a predefined EXIF directory and sets the context of the TIFF-handle `tif` to that directory.

### Parameters
- **tif** (TIFF*) - The TIFF handle.
```

--------------------------------

### TIFFCIELabToRGBInit

Source: https://libtiff.gitlab.io/libtiff/functions/TIFFcolor.html

Initializes the CIE L*a*b* 1976 to RGB conversion state.

```APIDOC
## int TIFFCIELabToRGBInit(TIFFCIELabToRGB *cielab, const TIFFDisplay *displayw, float *refWhite)

### Description
Initializes the state structure required for CIE L*a*b* to RGB color conversion.

### Parameters
- **cielab** (TIFFCIELabToRGB*) - Pointer to the conversion state structure.
- **displayw** (TIFFDisplay*) - Pointer to the display device description.
- **refWhite** (float*) - Pointer to the reference white point values.
```

--------------------------------

### Initialize Tag Extender

Source: https://libtiff.gitlab.io/libtiff/addingtags.html

Set up a tag extender callback to ensure custom tags are registered during the TIFF setup process.

```c
static TIFFExtendProc _ParentExtender = NULL;

static
void _XTIFFInitialize(void)
{
    static int first_time=1;

    if (! first_time) return; /* Been there. Done that. */
    first_time = 0;

    /* Grab the inherited method and install */
    _ParentExtender = TIFFSetTagExtender(_XTIFFDefaultDirectory);
}
```

--------------------------------

### Retrieve custom tag list information

Source: https://libtiff.gitlab.io/libtiff/functions/TIFFCustomTagList.html

Functions to get the number of custom tags and the tag number at a specific index.

```c
int TIFFGetTagListCount(TIFF *tif)
```

```c
uint32_t TIFFGetTagListEntry(TIFF *tif, int tag_index)
```

--------------------------------

### In-Source Build Configuration

Source: https://libtiff.gitlab.io/libtiff/_sources/build.rst.txt

Configuring and building the software directly within the source code directory.

```shell
% gzip -dc tiff-4.0.5.tar.gz | tar -xf -
% cd ./tiff-4.0.5
% ./configure
% make
% make check
% make install
```

--------------------------------

### Validate BitsPerSample in JPEG Setup

Source: https://libtiff.gitlab.io/libtiff/_sources/releases/v4.0.8.rst.txt

Ensures BitsPerSample is validated in JPEGSetupEncode to prevent undefined behavior from invalid shift exponents. Fixes bugzilla:2648.

```c
/* validate BitsPerSample in JPEGSetupEncode to avoid undefined behaviour caused by invalid shift exponent. Fixes bugzilla:2648 */
```

--------------------------------

### TIFFCreateCustomDirectory

Source: https://libtiff.gitlab.io/libtiff/functions/TIFFCustomDirectory.html

Sets up a custom directory and sets the context of the TIFF-handle to that directory.

```APIDOC
## int TIFFCreateCustomDirectory(TIFF *tif, const TIFFFieldArray *infoarray)

### Description
Sets up a custom directory and sets the context of the TIFF-handle `tif` to that custom directory for functions like `TIFFSetField()`.

### Parameters
- **tif** (TIFF*) - The TIFF handle.
- **infoarray** (const TIFFFieldArray*) - The field array definition for the custom directory.
```

--------------------------------

### Write Custom Directory and Get Offset

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFCustomDirectory.rst.txt

Write the custom directory to the file using TIFFWriteCustomDirectory. The offset to this directory in the file is returned in the provided pointer.

```c
TIFFWriteCustomDirectory(tiffOut, &dir_offset);
```

--------------------------------

### Get TIFF Field by Tag

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFFieldQuery.rst.txt

Retrieves a pointer to the TIFF field information structure using the tag number. Returns NULL if the tag is not registered.

```c
#include <tiffio.h>

const TIFFField* TIFFFieldWithTag(TIFF* tif, uint32_t tag)
```

--------------------------------

### Create Custom or GPS Directory

Source: https://libtiff.gitlab.io/libtiff/functions/TIFFCustomDirectory.html

Initialize a new custom or GPS directory structure. The infoarray must be defined in private headers for custom directories.

```c
TIFFCreateCustomDirectory(tiffOut, infoarray);        /* for a real custom directory */
/* or alternatively, use GPS or EXIF with pre-defined TIFFFieldArray IFD field structure */
TIFFCreateGPSDirectory(tiffOut);
TIFFSetField(tiffOut, GPSTAG_VERSIONID, gpsVersion);  /* set fields of the custom directory */
```

--------------------------------

### Get TIFF Library Version

Source: https://libtiff.gitlab.io/libtiff/_sources/libtiff.rst.txt

Retrieve the software version information of the TIFF library. This can be checked at compile time using TIFFLIB_VERSION or at runtime using TIFFGetVersion.

```shell
cat VERSION
cat dist/tiff.alpha
```

```c
#include <tiffio.h>

// ...
const char *version_string = TIFFGetVersion();
// TIFFLIB_VERSION can be used for compile-time checks
```

--------------------------------

### In-Source Build Scheme

Source: https://libtiff.gitlab.io/libtiff/_sources/build.rst.txt

Configuring and building the software within the source code directory.

```shell
$ gzip -dc tiff-4.0.5.tar.gz | tar -xf -
$ cd ./tiff-4.0.5
$ cmake
$ make
$ make test
$ make install
```

--------------------------------

### Build with Ninja Generator

Source: https://libtiff.gitlab.io/libtiff/_sources/build.rst.txt

Using the Ninja build system for cross-platform builds.

```shell
cmake -G Ninja
cmake --build .
ctest -V
cmake --build . --target install
```

--------------------------------

### Get TIFF Field by Name

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFFieldQuery.rst.txt

Retrieves a pointer to the TIFF field information structure using the field's name. Returns NULL if the tag is not registered.

```c
#include <tiffio.h>

const TIFFField* TIFFFieldWithName(TIFF* tif, const char *field_name)
```

--------------------------------

### TIFFCreateGPSDirectory

Source: https://libtiff.gitlab.io/libtiff/functions/TIFFCustomDirectory.html

Sets up a GPS directory and sets the context of the TIFF-handle to that directory.

```APIDOC
## int TIFFCreateGPSDirectory(TIFF *tif)

### Description
Sets up a predefined GPS directory and sets the context of the TIFF-handle `tif` to that directory.

### Parameters
- **tif** (TIFF*) - The TIFF handle.
```

--------------------------------

### Access TIFFTagMethods

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFAccessTagMethods.rst.txt

Use this function to get read/write access to the TIFFTagMethods structure associated with a TIFF file. Ensure the TIFF structure is properly opened before calling.

```c
#include <tiffio.h>

TIFFTagMethods *TIFFAccessTagMethods(TIFF* tif)
```

--------------------------------

### Define Codec Entry Points

Source: https://libtiff.gitlab.io/libtiff/internals.html

List of required and optional function entry points for implementing a new compression codec in LibTIFF.

```c
TIFFInitfoo(tif, scheme) /* initialize scheme and setup entry points in tif */
fooSetupDecode(tif) /* called once per IFD after tags has been frozen */
fooPreDecode(tif, sample) /* called once per strip/tile, after data is read,
                             but before the first row is decoded */
fooDecode*(tif, bp, cc, sample) /* decode cc bytes of data into the buffer */
    fooDecodeRow(...)       /* called to decode a single scanline */
    fooDecodeStrip(...)     /* called to decode an entire strip */
    fooDecodeTile(...)      /* called to decode an entire tile */
    fooSetupEncode(tif)     /* called once per IFD after tags has been frozen */
    fooPreEncode(tif, sample) /* called once per strip/tile, before the first row in
                                 a strip/tile is encoded */
fooEncode*(tif, bp, cc, sample)/* encode cc bytes of user data (bp) */
    fooEncodeRow(...)       /* called to decode a single scanline */
    fooEncodeStrip(...)     /* called to decode an entire strip */
    fooEncodeTile(...)      /* called to decode an entire tile */
fooPostEncode(tif)  /* called once per strip/tile, just before data is written */
fooSeek(tif, row)   /* seek forwards row scanlines from the beginning
                       of a strip (row will always be <0 and >rows/strip */
fooCleanup(tif) /* called when compression scheme is replaced by user */
```

--------------------------------

### Override put method for simultaneous display

Source: https://libtiff.gitlab.io/libtiff/functions/TIFFRGBAImage.html

Example of a custom put method that updates a display while filling the raster, using the original library routine for the actual storage.

```c
static void
putContigAndDraw(TIFFRGBAImage* img, uint32_t* raster,
    uint32_t x, uint32_t y, uint32_t w, uint32_t h,
    int32_t fromskew, int32_t toskew,
    unsigned char* cp)
{
    (*putContig)(img, raster, x, y, w, h, fromskew, toskew, cp);
    if (x+w == width) {
        w = width;
        if (img->orientation == ORIENTATION_TOPLEFT)
            lrectwrite(0, y-(h-1), w-1, y, raster-x-(h-1)*w);
        else
            lrectwrite(0, y, w-1, y+h-1, raster);
    }
}
```

--------------------------------

### Initialize Tag Extender Callback

Source: https://libtiff.gitlab.io/libtiff/_sources/addingtags.rst.txt

Initializes the tag extender callback mechanism by grabbing the inherited method and installing a new default. This ensures custom tags are processed.

```c
static TIFFExtendProc _ParentExtender = NULL;

    static
    void _XTIFFInitialize(void)
    {
        static int first_time=1;
	
        if (! first_time) return; /* Been there. Done that. */
        first_time = 0;
	
        /* Grab the inherited method and install */
        _ParentExtender = TIFFSetTagExtender(_XTIFFDefaultDirectory);
    }
```

--------------------------------

### Get Client Info Data in C

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFClientInfo.rst.txt

Retrieves user-defined data associated with a specific name from the TIFF client info list. Returns NULL if the name is not found.

```c
#include <tiffio.h>

void *TIFFGetClientInfo(TIFF* tif, const char *name)
```

--------------------------------

### Create and Set Fields for Custom/GPS Directory

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFCustomDirectory.rst.txt

Create a custom directory using TIFFCreateCustomDirectory or a predefined one like GPS using TIFFCreateGPSDirectory. Subsequently, set fields for this new directory using TIFFSetField.

```c
TIFFCreateCustomDirectory(tiffOut, infoarray);        /* for a real custom directory */
    /* or alternatively, use GPS or EXIF with pre-defined TIFFFieldArray IFD field structure */
    TIFFCreateGPSDirectory(tiffOut);
    TIFFSetField(tiffOut, GPSTAG_VERSIONID, gpsVersion);  /* set fields of the custom directory */
```

--------------------------------

### Open and Read a TIFF File

Source: https://libtiff.gitlab.io/libtiff/libtiff.html

Demonstrates opening an existing TIFF file for reading and closing the handle after processing.

```c
#include "tiffio.h"
main()
{
    TIFF* tif = TIFFOpen("foo.tif", "r");
    /* ... do stuff ... */
    TIFFClose(tif);
}
```

--------------------------------

### Write and Get Current Directory Number

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFCustomDirectory.rst.txt

Save the current TIFF directory to the file using TIFFWriteDirectory. Remember the number of the current directory using TIFFCurrentDirectory for later retrieval.

```c
TIFFWriteDirectory(tiffOut);
    dirNum = TIFFCurrentDirectory(tiffOut);
```

--------------------------------

### Initialize CIE L*a*b* to RGB Conversion

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFcolor.rst.txt

Initializes the CIE L*a*b* to RGB conversion state. Requires TIFFTAG_WHITEPOINT field and a display structure. Ensure to free the allocated state upon completion.

```c
float   *whitePoint;
float   refWhite[3];

/* Initialize structures */
img->cielab = (TIFFCIELabToRGB *) 
    _TIFFmalloc(sizeof(TIFFCIELabToRGB));
if (!cielab) {
    TIFFError("CIE L*a*b*->RGB",
        "No space for CIE L*a*b*->RGB conversion state.");
    exit(0);
}

TIFFGetFieldDefaulted(tif, TIFFTAG_WHITEPOINT, &whitePoint);
refWhite[1] = 100.0F;
refWhite[0] = whitePoint[0] / whitePoint[1] * refWhite[1];
refWhite[2] = (1.0F - whitePoint[0] - whitePoint[1])
    / whitePoint[1] * refWhite[1];
if (TIFFCIELabToRGBInit(cielab, &display_sRGB, refWhite) < 0) {
    TIFFError("CIE L*a*b*->RGB",
        "Failed to initialize CIE L*a*b*->RGB conversion state.");
    _TIFFfree(cielab);
    exit(0);
}
```

--------------------------------

### Get TIFF Field Name

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFFieldName.rst.txt

Use TIFFFieldName to retrieve the string name of a TIFF field. The input 'fip' must be a valid TIFFField pointer obtained from functions like TIFFFindField.

```c
#include <tiffio.h>

const char* TIFFFieldName(const TIFFField* fip)
```

--------------------------------

### Override Default Compression Configuration

Source: https://libtiff.gitlab.io/libtiff/internals.html

Use these defines to manually specify which compression schemes to include in the build, overriding the default set.

```c
#define COMPRESSION_SUPPORT
#define CCITT_SUPPORT
#define PACKBITS_SUPPORT
```

--------------------------------

### Fix Memory Leak on Codec Setup Failure

Source: https://libtiff.gitlab.io/libtiff/_sources/releases/v4.0.8.rst.txt

Resolves memory leaks that occur when an underlying codec's setupdecode method succeeds, but PredictorSetup fails in tif_zip.c, tif_pixarlog.c, and tif_predict.c. Credit to OSS-Fuzz.

```c
/* fix memory leak when the underlying codec (ZIP, PixarLog) succeeds its setupdecode method, but PredictorSetup fails. Credit to OSS-Fuzz (locally run, on GDAL) */
```

--------------------------------

### Parallel Build Tree Configuration

Source: https://libtiff.gitlab.io/libtiff/_sources/build.rst.txt

Configuring and building the software in a separate directory from the source tree, useful for multi-target builds or read-only source trees.

```shell
% gzip -dc tiff-4.0.5.tar.gz | tar -xf -
% mkdir tiff-4.0.5-build
% cd ./tiff-4.0.5-build
% ../tiff-4.0.5/configure
% make
% make check
% make install
```

--------------------------------

### Get TIFF Field Count Parameter Size

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFFieldQuery.rst.txt

Returns the size of the 'count' parameter for TIFFSetField and TIFFGetField, and indicates if it is required. 0 means none, 2 means uint16_t, and 4 means uint32_t.

```c
#include <tiffio.h>

int TIFFFieldSetGetCountSize(const TIFFField* fip)
```

--------------------------------

### TIFFYCbCrToRGBInit

Source: https://libtiff.gitlab.io/libtiff/functions/TIFFcolor.html

Initializes the YCbCr to RGB conversion state.

```APIDOC
## int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *ycbcr, float *luma, float *refBlackWhite)

### Description
Initializes the state structure required for YCbCr to RGB color conversion. The caller is responsible for allocating the memory for the TIFFYCbCrToRGB structure.

### Parameters
- **ycbcr** (TIFFYCbCrToRGB*) - Pointer to the conversion state structure.
- **luma** (float*) - Array of three values representing proportions of red, green, and blue in luminance.
- **refBlackWhite** (float*) - Array of 6 values specifying headroom and footroom image data values.
```

--------------------------------

### Standard Make Targets

Source: https://libtiff.gitlab.io/libtiff/_sources/build.rst.txt

Commonly available targets for the make utility.

```shell
make [all]      build stuff
make test       run the test suite
make install    build and install stuff
make clean      remove object files, executables and cruft
```

--------------------------------

### Read Custom Tag Data with TIFFGetField

Source: https://libtiff.gitlab.io/libtiff/_sources/functions/TIFFGetField.rst.txt

Use TIFFGetField to read values for custom or non-standard TIFF tags. You must know the data type of the tag to correctly interpret the retrieved data. This example shows reading a LONG and an ASCII string.

```c
uint32_t  count;
    void    *data;

    TIFFGetField(tiff, 33424, &count, &data);
    printf("Tag %d: %d, count %d\n", 33424, *(uint32_t *)data, count);
    TIFFGetField(tiff, 36867, &count, &data);
    printf("Tag %d: %s, count %d\n", 36867, (char *)data, count);
```

--------------------------------

### Write Custom Directory

Source: https://libtiff.gitlab.io/libtiff/functions/TIFFCustomDirectory.html

Commit the custom directory to the file and retrieve its offset.

```c
TIFFWriteCustomDirectory(tiffOut, &dir_offset);
```
Tokens:
Raw