TIFF (Tagged Image File Format)

Overview

TIFF (Tagged Image File Format) is a versatile raster graphics format that supports multiple compression methods, color spaces, and metadata. Known for its flexibility and high quality, TIFF is widely used in professional photography, medical imaging, and document archival.

File Details

• Extension: .tiff, .tif
• MIME Type: image/tiff
• Category: Image
• Binary/Text: Binary

Technical Specifications

File Structure

TIFF files use a tag-based structure with:

• Header: 8 bytes containing magic number and IFD offset
• IFD (Image File Directory): Tags describing image data
• Image Data: Actual pixel information
• Multiple IFDs: Support for multiple images per file

Header Format

Bytes 0-1: Byte order ("II" little-endian or "MM" big-endian)
Bytes 2-3: Magic number (42)
Bytes 4-7: Offset to first IFD

Supported Features

• Color Depths: 1, 4, 8, 16, 32, 64 bits per channel
• Compression: None, LZW, JPEG, ZIP, CCITT, PackBits
• Color Spaces: RGB, CMYK, YCbCr, CIE Lab*, Grayscale
• Transparency: Alpha channels supported

History

• 1986: Developed by Aldus Corporation
• 1988: TIFF 5.0 specification
• 1992: TIFF 6.0 final specification
• 1994: Adobe acquires Aldus
• 2002: LibTIFF becomes standard implementation
• Present: Maintained by various organizations

Structure Details

Tag Structure

Tag ID (2 bytes): Identifies the tag type
Data Type (2 bytes): Specifies data format
Count (4 bytes): Number of values
Value/Offset (4 bytes): Data or offset to data

Common Tags

• 254: NewSubfileType
• 256: ImageWidth
• 257: ImageLength
• 258: BitsPerSample
• 259: Compression
• 262: PhotometricInterpretation
• 273: StripOffsets
• 277: SamplesPerPixel

Code Examples

Python TIFF Reader

from PIL import Image, TiffImagePlugin
import struct

def read_tiff_info(filename):
    """Read TIFF file information"""
    with open(filename, 'rb') as f:
        # Read header
        header = f.read(8)
        
        # Check byte order
        if header[:2] == b'II':
            endian = '<'  # Little endian
        elif header[:2] == b'MM':
            endian = '>'  # Big endian
        else:
            raise ValueError("Invalid TIFF file")
        
        # Check magic number
        magic = struct.unpack(endian + 'H', header[2:4])[0]
        if magic != 42:
            raise ValueError("Invalid TIFF magic number")
        
        # Get first IFD offset
        ifd_offset = struct.unpack(endian + 'I', header[4:8])[0]
        
        return {
            'endian': 'little' if endian == '<' else 'big',
            'magic': magic,
            'first_ifd_offset': ifd_offset
        }

def read_tiff_tags(filename):
    """Read TIFF tags from first IFD"""
    with Image.open(filename) as img:
        tags = {}
        
        # Get TIFF tags
        if hasattr(img, 'tag_v2'):
            for tag_id, value in img.tag_v2.items():
                tag_name = TiffImagePlugin.TAGS_V2.get(tag_id, {}).get('name', f'Tag_{tag_id}')
                tags[tag_name] = value
        
        return {
            'size': img.size,
            'mode': img.mode,
            'format': img.format,
            'tags': tags
        }

def extract_tiff_metadata(filename):
    """Extract comprehensive TIFF metadata"""
    from PIL.ExifTags import TAGS
    
    with Image.open(filename) as img:
        metadata = {
            'basic_info': {
                'width': img.width,
                'height': img.height,
                'mode': img.mode,
                'format': img.format
            },
            'tiff_tags': {},
            'exif_data': {}
        }
        
        # Extract TIFF tags
        if hasattr(img, 'tag'):
            for tag_id, value in img.tag.items():
                tag_name = TiffImagePlugin.TAGS.get(tag_id, f'Tag_{tag_id}')
                metadata['tiff_tags'][tag_name] = value
        
        # Extract EXIF data if present
        if hasattr(img, '_getexif') and img._getexif():
            exif = img._getexif()
            for tag_id, value in exif.items():
                tag_name = TAGS.get(tag_id, tag_id)
                metadata['exif_data'][tag_name] = value
        
        return metadata

# Usage
info = read_tiff_info('image.tiff')
print(f"Byte order: {info['endian']}")

metadata = extract_tiff_metadata('image.tiff')
print(f"Image size: {metadata['basic_info']['width']}x{metadata['basic_info']['height']}")

Creating TIFF Images

import numpy as np
from PIL import Image

def create_tiff_image(width, height, filename, compression='lzw'):
    """Create a sample TIFF image"""
    # Create sample data
    data = np.random.randint(0, 256, (height, width, 3), dtype=np.uint8)
    
    # Create PIL Image
    img = Image.fromarray(data, mode='RGB')
    
    # Save with specific compression
    img.save(filename, format='TIFF', compression=compression)
    print(f"Created TIFF image: {filename}")

def convert_to_tiff(input_file, output_file, **options):
    """Convert image to TIFF with options"""
    with Image.open(input_file) as img:
        # Default TIFF options
        tiff_options = {
            'format': 'TIFF',
            'compression': 'lzw',
            'dpi': (300, 300)
        }
        
        # Update with user options
        tiff_options.update(options)
        
        img.save(output_file, **tiff_options)
        print(f"Converted {input_file} to {output_file}")

# Create sample images
create_tiff_image(800, 600, 'sample.tiff')
create_tiff_image(1200, 900, 'sample_uncompressed.tiff', compression=None)

# Convert with different options
convert_to_tiff('input.jpg', 'output.tiff', 
                compression='jpeg', quality=95, dpi=(600, 600))

C++ TIFF Processing

#include <tiffio.h>
#include <iostream>
#include <vector>

class TIFFProcessor {
public:
    bool readTIFF(const char* filename) {
        TIFF* tiff = TIFFOpen(filename, "r");
        if (!tiff) {
            std::cerr << "Cannot open TIFF file: " << filename << std::endl;
            return false;
        }
        
        // Get image dimensions
        TIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &width);
        TIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &height);
        TIFFGetField(tiff, TIFFTAG_SAMPLESPERPIXEL, &samplesPerPixel);
        TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bitsPerSample);
        
        // Read image data
        size_t npixels = width * height;
        imageData.resize(npixels * 4); // RGBA
        
        if (TIFFReadRGBAImage(tiff, width, height, 
                              reinterpret_cast<uint32*>(imageData.data()), 0)) {
            std::cout << "Successfully read TIFF image" << std::endl;
            std::cout << "Size: " << width << "x" << height << std::endl;
            std::cout << "Samples per pixel: " << samplesPerPixel << std::endl;
        } else {
            std::cerr << "Failed to read TIFF image data" << std::endl;
            TIFFClose(tiff);
            return false;
        }
        
        TIFFClose(tiff);
        return true;
    }
    
    bool writeTIFF(const char* filename) {
        TIFF* tiff = TIFFOpen(filename, "w");
        if (!tiff) {
            std::cerr << "Cannot create TIFF file: " << filename << std::endl;
            return false;
        }
        
        // Set TIFF tags
        TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, width);
        TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, height);
        TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 3);
        TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8);
        TIFFSetField(tiff, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
        TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
        TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
        TIFFSetField(tiff, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
        
        // Write image data
        for (int row = 0; row < height; row++) {
            if (TIFFWriteScanline(tiff, &imageData[row * width * 3], row, 0) < 0) {
                std::cerr << "Error writing scanline " << row << std::endl;
                TIFFClose(tiff);
                return false;
            }
        }
        
        TIFFClose(tiff);
        std::cout << "Successfully wrote TIFF image: " << filename << std::endl;
        return true;
    }
    
private:
    uint32 width, height;
    uint16 samplesPerPixel, bitsPerSample;
    std::vector<uint8> imageData;
};

Tools and Applications

Image Editors

• Adobe Photoshop: Professional TIFF support
• GIMP: Open-source with full TIFF capabilities
• Paint.NET: Windows image editor
• Krita: Digital painting application

Viewers and Converters

• IrfanView: Lightweight Windows viewer
• XnView: Cross-platform image viewer
• ImageMagick: Command-line image processing
• GraphicsMagick: Fork of ImageMagick

Professional Applications

• Adobe Lightroom: RAW processing and export
• Capture One: Professional photo software
• Phase One: Medium format camera software
• Medical imaging: DICOM conversion tools

Command Line Tools

# ImageMagick examples
convert image.jpg -compress lzw image.tiff
convert image.tiff -strip image_no_metadata.tiff
identify -verbose image.tiff

# GraphicsMagick
gm convert image.jpg -compress zip image.tiff
gm identify -ping image.tiff

# LibTIFF tools
tiffinfo image.tiff
tiffdump image.tiff
tiffcp -c lzw input.tiff output.tiff

Best Practices

Compression Selection

• LZW: Good for images with large uniform areas
• ZIP/Deflate: Better compression for most images
• JPEG: Only for photographic content
• None: Maximum quality, larger files

Color Management

• Include ICC profiles for accurate color
• Use appropriate color spaces
• Maintain bit depth for editing
• Consider gamma correction

Metadata Preservation

def preserve_metadata_conversion(input_file, output_file):
    """Convert while preserving all metadata"""
    with Image.open(input_file) as img:
        # Preserve EXIF data
        exif = img.info.get('exif')
        
        # Save with metadata
        save_options = {'format': 'TIFF', 'compression': 'lzw'}
        if exif:
            save_options['exif'] = exif
        
        img.save(output_file, **save_options)

Security Considerations

Vulnerability Prevention

def safe_tiff_processing(filename, max_pixels=50000000):
    """Safely process TIFF files"""
    try:
        with Image.open(filename) as img:
            # Check image size
            width, height = img.size
            if width * height > max_pixels:
                raise ValueError("Image too large")
            
            # Validate format
            if img.format != 'TIFF':
                raise ValueError("Not a TIFF file")
            
            # Check for suspicious tags
            if hasattr(img, 'tag'):
                for tag_id, value in img.tag.items():
                    if isinstance(value, (list, tuple)) and len(value) > 10000:
                        raise ValueError("Suspicious tag data")
            
            return img
    except Exception as e:
        print(f"Error processing TIFF: {e}")
        return None

Common Vulnerabilities

• Buffer overflow in parsers
• Integer overflow in size calculations
• Malformed tag exploitation
• Infinite loop in compressed data

Modern Considerations

Web Usage

• Large file sizes problematic for web
• Limited browser support
• Consider WebP or AVIF alternatives
• Use progressive JPEG for web display

Archival Standards

• TIFF/A for long-term preservation
• Uncompressed or lossless compression
• Embedded metadata for cataloging
• Regular format validation

Cloud and Mobile

• Compression important for bandwidth
• Consider device processing capabilities
• Progressive loading strategies
• Format conversion for different devices

TIFF remains essential for professional imaging workflows, offering unmatched flexibility and quality preservation, though modern formats increasingly challenge its dominance in web and mobile applications.