tif_tile.c File Reference

#include "tiffiop.h"

Include dependency graph for tif_tile.c:

Go to the source code of this file.

Functions
uint32_t	TIFFComputeTile (TIFF *tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
int	TIFFCheckTile (TIFF *tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
uint32_t	TIFFNumberOfTiles (TIFF *tif)
uint64_t	TIFFTileRowSize64 (TIFF *tif)
tmsize_t	TIFFTileRowSize (TIFF *tif)
uint64_t	TIFFVTileSize64 (TIFF *tif, uint32_t nrows)
tmsize_t	TIFFVTileSize (TIFF *tif, uint32_t nrows)
uint64_t	TIFFTileSize64 (TIFF *tif)
tmsize_t	TIFFTileSize (TIFF *tif)
void	TIFFDefaultTileSize (TIFF *tif, uint32_t *tw, uint32_t *th)
void	_TIFFDefaultTileSize (TIFF *tif, uint32_t *tw, uint32_t *th)

Function Documentation

_TIFFDefaultTileSize()

void _TIFFDefaultTileSize	(	TIFF *	tif,
		uint32_t *	tw,
		uint32_t *	th
	)

Definition at line 272 of file tif_tile.c.

{
    (void)tif;
    if (*(int32_t *)tw < 1)
        *tw = 256;
    if (*(int32_t *)th < 1)
        *th = 256;
    /* roundup to a multiple of 16 per the spec */
    if (*tw & 0xf)
        *tw = TIFFroundup_32(*tw, 16);
    if (*th & 0xf)
        *th = TIFFroundup_32(*th, 16);
}

Referenced by _TIFFSetDefaultCompressionState().

TIFFCheckTile()

int TIFFCheckTile	(	TIFF *	tif,
		uint32_t	x,
		uint32_t	y,
		uint32_t	z,
		uint16_t	s
	)

Definition at line 71 of file tif_tile.c.

{
    TIFFDirectory *td = &tif->tif_dir;
 
    if (x >= td->td_imagewidth)
    {
        TIFFErrorExtR(tif, tif->tif_name, "%lu: Col out of range, max %lu",
                      (unsigned long)x, (unsigned long)(td->td_imagewidth - 1));
        return (0);
    }
    if (y >= td->td_imagelength)
    {
        TIFFErrorExtR(tif, tif->tif_name, "%lu: Row out of range, max %lu",
                      (unsigned long)y,
                      (unsigned long)(td->td_imagelength - 1));
        return (0);
    }
    if (z >= td->td_imagedepth)
    {
        TIFFErrorExtR(tif, tif->tif_name, "%lu: Depth out of range, max %lu",
                      (unsigned long)z, (unsigned long)(td->td_imagedepth - 1));
        return (0);
    }
    if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
        s >= td->td_samplesperpixel)
    {
        TIFFErrorExtR(tif, tif->tif_name, "%lu: Sample out of range, max %lu",
                      (unsigned long)s,
                      (unsigned long)(td->td_samplesperpixel - 1));
        return (0);
    }
    return (1);
}

Referenced by _TIFFReadTileAndAllocBuffer(), TIFFReadTile(), and TIFFWriteTile().

TIFFComputeTile()

uint32_t TIFFComputeTile	(	TIFF *	tif,
		uint32_t	x,
		uint32_t	y,
		uint32_t	z,
		uint16_t	s
	)

Definition at line 35 of file tif_tile.c.

{
    TIFFDirectory *td = &tif->tif_dir;
    uint32_t dx = td->td_tilewidth;
    uint32_t dy = td->td_tilelength;
    uint32_t dz = td->td_tiledepth;
    uint32_t tile = 1;
 
    if (td->td_imagedepth == 1)
        z = 0;
    if (dx == (uint32_t)-1)
        dx = td->td_imagewidth;
    if (dy == (uint32_t)-1)
        dy = td->td_imagelength;
    if (dz == (uint32_t)-1)
        dz = td->td_imagedepth;
    if (dx != 0 && dy != 0 && dz != 0)
    {
        uint32_t xpt = TIFFhowmany_32(td->td_imagewidth, dx);
        uint32_t ypt = TIFFhowmany_32(td->td_imagelength, dy);
        uint32_t zpt = TIFFhowmany_32(td->td_imagedepth, dz);
 
        if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
            tile = (xpt * ypt * zpt) * s + (xpt * ypt) * (z / dz) +
                   xpt * (y / dy) + x / dx;
        else
            tile = (xpt * ypt) * (z / dz) + xpt * (y / dy) + x / dx;
    }
    return (tile);
}

Referenced by _TIFFReadTileAndAllocBuffer(), TIFFReadTile(), and TIFFWriteTile().

TIFFDefaultTileSize()

void TIFFDefaultTileSize	(	TIFF *	tif,
		uint32_t *	tw,
		uint32_t *	th
	)

Definition at line 267 of file tif_tile.c.

{
    (*tif->tif_deftilesize)(tif, tw, th);
}

TIFFNumberOfTiles()

uint32_t TIFFNumberOfTiles

(

TIFF *

tif

)

Definition at line 108 of file tif_tile.c.

{
    TIFFDirectory *td = &tif->tif_dir;
    uint32_t dx = td->td_tilewidth;
    uint32_t dy = td->td_tilelength;
    uint32_t dz = td->td_tiledepth;
    uint32_t ntiles;
 
    if (dx == (uint32_t)-1)
        dx = td->td_imagewidth;
    if (dy == (uint32_t)-1)
        dy = td->td_imagelength;
    if (dz == (uint32_t)-1)
        dz = td->td_imagedepth;
    ntiles =
        (dx == 0 || dy == 0 || dz == 0)
            ? 0
            : _TIFFMultiply32(
                  tif,
                  _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
                                  TIFFhowmany_32(td->td_imagelength, dy),
                                  "TIFFNumberOfTiles"),
                  TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
    if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
        ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
                                 "TIFFNumberOfTiles");
    return (ntiles);
}

Referenced by TIFFReadDirectory(), and TIFFSetupStrips().

TIFFTileRowSize()

tmsize_t TIFFTileRowSize

(

TIFF *

tif

)

Definition at line 177 of file tif_tile.c.

{
    static const char module[] = "TIFFTileRowSize";
    uint64_t m;
    m = TIFFTileRowSize64(tif);
    return _TIFFCastUInt64ToSSize(tif, m, module);
}

Referenced by gtTileContig(), gtTileSeparate(), and PredictorSetup().

TIFFTileRowSize64()

uint64_t TIFFTileRowSize64

(

TIFF *

tif

)

Definition at line 140 of file tif_tile.c.

{
    static const char module[] = "TIFFTileRowSize64";
    TIFFDirectory *td = &tif->tif_dir;
    uint64_t rowsize;
    uint64_t tilerowsize;
 
    if (td->td_tilelength == 0)
    {
        TIFFErrorExtR(tif, module, "Tile length is zero");
        return 0;
    }
    if (td->td_tilewidth == 0)
    {
        TIFFErrorExtR(tif, module, "Tile width is zero");
        return (0);
    }
    rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
                              "TIFFTileRowSize");
    if (td->td_planarconfig == PLANARCONFIG_CONTIG)
    {
        if (td->td_samplesperpixel == 0)
        {
            TIFFErrorExtR(tif, module, "Samples per pixel is zero");
            return 0;
        }
        rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
                                  "TIFFTileRowSize");
    }
    tilerowsize = TIFFhowmany8_64(rowsize);
    if (tilerowsize == 0)
    {
        TIFFErrorExtR(tif, module, "Computed tile row size is zero");
        return 0;
    }
    return (tilerowsize);
}

Referenced by TIFFTileRowSize(), and TIFFVTileSize64().

TIFFTileSize()

tmsize_t TIFFTileSize

(

TIFF *

tif

)

Definition at line 253 of file tif_tile.c.

{
    static const char module[] = "TIFFTileSize";
    uint64_t m;
    m = TIFFTileSize64(tif);
    return _TIFFCastUInt64ToSSize(tif, m, module);
}

Referenced by gtTileContig(), gtTileSeparate(), TIFFFillTile(), TIFFReadDirectory(), and TIFFWriteCheck().

TIFFTileSize64()

uint64_t TIFFTileSize64

(

TIFF *

tif

)

Definition at line 249 of file tif_tile.c.

{
    return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
}

Referenced by _TIFFRewriteField(), EstimateStripByteCounts(), TIFFTileSize(), and TIFFWriteDirectoryTagLongLong8Array().

TIFFVTileSize()

tmsize_t TIFFVTileSize	(	TIFF *	tif,
		uint32_t	nrows
	)

Definition at line 238 of file tif_tile.c.

{
    static const char module[] = "TIFFVTileSize";
    uint64_t m;
    m = TIFFVTileSize64(tif, nrows);
    return _TIFFCastUInt64ToSSize(tif, m, module);
}

TIFFVTileSize64()

uint64_t TIFFVTileSize64	(	TIFF *	tif,
		uint32_t	nrows
	)

Definition at line 188 of file tif_tile.c.

{
    static const char module[] = "TIFFVTileSize64";
    TIFFDirectory *td = &tif->tif_dir;
    if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
        td->td_tiledepth == 0)
        return (0);
    if ((td->td_planarconfig == PLANARCONFIG_CONTIG) &&
        (td->td_photometric == PHOTOMETRIC_YCBCR) &&
        (td->td_samplesperpixel == 3) && (!isUpSampled(tif)))
    {
        /*
         * Packed YCbCr data contain one Cb+Cr for every
         * HorizontalSampling*VerticalSampling Y values.
         * Must also roundup width and height when calculating
         * since images that are not a multiple of the
         * horizontal/vertical subsampling area include
         * YCbCr data for the extended image.
         */
        uint16_t ycbcrsubsampling[2];
        uint16_t samplingblock_samples;
        uint32_t samplingblocks_hor;
        uint32_t samplingblocks_ver;
        uint64_t samplingrow_samples;
        uint64_t samplingrow_size;
        TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
                              ycbcrsubsampling + 0, ycbcrsubsampling + 1);
        if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
             ycbcrsubsampling[0] != 4) ||
            (ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
             ycbcrsubsampling[1] != 4))
        {
            TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling (%dx%d)",
                          ycbcrsubsampling[0], ycbcrsubsampling[1]);
            return 0;
        }
        samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
        samplingblocks_hor =
            TIFFhowmany_32(td->td_tilewidth, ycbcrsubsampling[0]);
        samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
        samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
                                              samplingblock_samples, module);
        samplingrow_size = TIFFhowmany8_64(_TIFFMultiply64(
            tif, samplingrow_samples, td->td_bitspersample, module));
        return (
            _TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
    }
    else
        return (_TIFFMultiply64(tif, nrows, TIFFTileRowSize64(tif), module));
}

Referenced by ChopUpSingleUncompressedStrip(), TIFFTileSize64(), and TIFFVTileSize().