jpeg

type APPMarkerHints struct {
	// JFIFVersion is the JFIF version from APP0 marker (e.g., "1.01", "1.02").
	JFIFVersion string

	// HasJFIFThumbnail indicates whether the JFIF marker contains a thumbnail.
	HasJFIFThumbnail bool

	// ExifMake is the camera manufacturer from APP1 EXIF Make tag.
	ExifMake string

	// ExifModel is the camera model from APP1 EXIF Model tag.
	ExifModel string

	// ExifSoftware is the software field from APP1 EXIF Software tag.
	ExifSoftware string

	// HasICCProfile indicates whether an APP2 ICC profile marker is present.
	HasICCProfile bool

	// HasPhotoshopMarker indicates whether an APP13 Photoshop marker is present.
	HasPhotoshopMarker bool

	// PhotoshopVersion is the Photoshop version extracted from APP13 marker.
	PhotoshopVersion string

	// Has8BIMResources indicates whether 8BIM resource blocks were found.
	Has8BIMResources bool

	// HasAdobeMarker indicates whether an APP14 Adobe marker is present.
	HasAdobeMarker bool

	// AdobeDCTVersion is the DCTEncodeVersion from APP14 Adobe marker.
	AdobeDCTVersion int

	// AdobeColorTransform is the ColorTransform value from APP14 Adobe marker.
	// Values: 0=Unknown, 1=YCbCr, 2=YCCK
	AdobeColorTransform int

	// CommentStrings contains all COM marker comment strings.
	CommentStrings []string

	// RawAPPMarkers contains all raw APP marker segments for further analysis.
	RawAPPMarkers []RawAPPMarker
}

type APPSegment struct {
	AppType    int    // APP marker type (0-15)
	Identifier string // Application identifier (e.g., "JFIF", "Exif")
	Data       []byte // Application-specific data
}

type AlgorithmConfig struct {
	// LeastSquares configures the least-squares matching algorithm.
	LeastSquares AlgorithmSettings

	// ScaleFactor configures the scale factor reverse engineering algorithm.
	ScaleFactor AlgorithmSettings

	// DCTHistogram configures the DCT coefficient histogram analysis algorithm.
	DCTHistogram AlgorithmSettings
}

type AlgorithmResult struct {
	// Method identifies which algorithm produced this result.
	Method EstimationMethod

	// Quality is the estimated quality level (1-100).
	Quality int

	// Confidence is the confidence level of this algorithm's estimate (0.0-1.0).
	Confidence float64

	// Weight is the configured weight for this algorithm.
	Weight float64
}

type AlgorithmSettings struct {
	// Enabled indicates whether this algorithm should be used.
	Enabled bool

	// Weight is the relative weight of this algorithm in the combined estimate.
	// Higher weights give the algorithm more influence on the final quality value.
	Weight float64
}

type ArithmeticLosslessEncoder struct {
	// contains filtered or unexported fields
}

type ArithmeticProgressiveEncoder struct {
	// contains filtered or unexported fields
}

type ArithmeticSequentialEncoder struct {
	// contains filtered or unexported fields
}

type AsyncEventReader interface {
	// StartReading begins asynchronous event reading.
	StartReading(r io.Reader) error

	// ReadEvent reads the next event without blocking.
	// Returns io.EOF when no more events are available.
	ReadEvent() (*VisualEvent, error)

	// StopReading terminates the reading session.
	StopReading() error
}

type BaselineCoeffEncoder struct {
	// contains filtered or unexported fields
}

type BasicFormatInfo struct {
	Name        string
	Description string
}

type BatchDetector interface {
	// DetectBatch detects formats for multiple byte slices concurrently.
	// Returns results in the same order as input.
	DetectBatch(files [][]byte) []DetectionResult

	// DetectBatchWithInfo detects formats with detailed info for multiple files.
	DetectBatchWithInfo(files [][]byte) []DetectionResult
}

type BitStreamReader struct {
	// contains filtered or unexported fields
}

type BitStreamWriter struct {
	// contains filtered or unexported fields
}

type BlockReconstructor struct {
	// contains filtered or unexported fields
}

type BufferError struct {
	Operation  string // The operation that failed (e.g., "read", "write", "allocate")
	Position   int    // Position in the buffer where error occurred
	Expected   int    // Expected buffer size or position
	Actual     int    // Actual buffer size or position
	BufferName string // Name of the buffer (e.g., "pixel buffer", "output buffer")
	Cause      error  // Underlying cause
}

type ByteReader interface {
	// ReadByte reads and returns the next byte.
	// Returns error if no more bytes available.
	ReadByte() (byte, error)

	// Position returns the current read position.
	Position() int

	// SetPosition sets the read position.
	SetPosition(pos int)

	// Remaining returns the number of unread bytes.
	Remaining() int

	// Len returns the total length of the data.
	Len() int
}

type CODMarker struct {
	CodingStyle                byte // Coding style flags
	ProgressionOrder           int  // Progression order
	QualityLayers              int  // Number of layers
	MultipleComponentTransform bool // MCT used
	DecompositionLevels        int  // Number of decomposition levels
	CodeBlockWidth             int  // Code-block width exponent
	CodeBlockHeight            int  // Code-block height exponent
	CodeBlockStyle             byte // Code-block style
	Transformation             int  // Wavelet transformation (0=9-7, 1=5-3)
}

type ChromaSubsampler interface {
	// Subsample applies chroma subsampling to YCbCr image data.
	// Returns Y plane and subsampled Cb, Cr planes.
	Subsample(img *ImageData) (y, cb, cr []byte, cbWidth, cbHeight int)

	// Mode returns the subsampling mode.
	Mode() ChromaSubsampling
}

type ChromaSubsampling int

type ChromaSubsamplingMode int

type ChromaUpsampler interface {
	// Upsample upsamples chroma planes (Cb, Cr) to match luma (Y) resolution.
	// Input: y, cb, cr are the plane data with their respective dimensions.
	// Output: yOut, cbOut, crOut are the planes at full luma resolution.
	// The Y plane passes through unchanged; Cb and Cr are upsampled.
	Upsample(y, cb, cr []byte, yWidth, yHeight, cbWidth, cbHeight int) (yOut, cbOut, crOut []byte)

	// Mode returns the chroma subsampling mode this upsampler handles.
	Mode() ChromaSubsampling
}

type CodestreamParser interface {
	// ParseSIZ parses Image and Tile Size marker.
	ParseSIZ(data []byte) (*SIZMarker, error)

	// ParseCOD parses Coding Style Default marker.
	ParseCOD(data []byte) (*CODMarker, error)

	// ParseQCD parses Quantization Default marker.
	ParseQCD(data []byte) (*QCDMarker, error)

	// ParseSOT parses Start of Tile-part marker.
	ParseSOT(data []byte) (*SOTMarker, error)
}

type CoeffEncoder interface {
	// EncodeCoefficients creates a JPEG from pre-computed DCT coefficients.
	// This is useful for steganography where coefficients are modified in-place.
	EncodeCoefficients(coefficients []int, meta *CoeffEncoderMetadata) ([]byte, error)
}

type CoeffEncoderMetadata struct {
	// Image dimensions
	Width  int
	Height int

	// Number of components (1 for grayscale, 3 for YCbCr)
	ComponentCount int

	// Chroma subsampling mode (for YCbCr images)
	Subsampling ChromaSubsampling

	// Quantization tables (map from table ID to 64-element table in zigzag order)
	// If nil, standard tables at quality 75 will be used
	QuantTables map[int][64]int

	// Quality (0-100) - used if QuantTables is nil
	Quality int
}

type CoefficientExtractor interface {
	// Extract extracts quantized DCT coefficients from JPEG image data.
	// Returns coefficients with frequency mode information (row, col, component).
	Extract(data []byte) ([]DCTCoefficient, error)

	// GetImageDimensions returns the width and height of the decoded image.
	GetImageDimensions() (width, height int)

	// GetComponentCount returns the number of color components (typically 3 for YCbCr).
	GetComponentCount() int
}

type CoefficientRatio struct {
	// Position is the coefficient index in the quantization table (0-63).
	Position int

	// ExpectedRatio is the expected value of table[Position] / table[0].
	ExpectedRatio float64

	// Weight is the importance of this ratio in signature matching.
	// Higher weight means more significant for identification.
	Weight float64
}

type ColorConversionStandard int

type ColorConverter interface {
	// RGBToYCbCr converts RGB to YCbCr using specified standard.
	RGBToYCbCr(r, g, b uint8) (y, cb, cr uint8)

	// YCbCrToRGB converts YCbCr to RGB using specified standard.
	YCbCrToRGB(y, cb, cr uint8) (r, g, b uint8)

	// Standard returns the color conversion standard name.
	Standard() string
}

type ColorSpace int

type ComponentError struct {
	ComponentID int    // Component ID (1=Y, 2=Cb, 3=Cr, etc.)
	Operation   string // Operation that failed
	Message     string // Error message
	Cause       error  // Underlying cause
}

type ComponentReconstructor struct {
	// contains filtered or unexported fields
}

type ComponentSpec struct {
	BitDepth             int  // Bit depth (with sign bit in MSB)
	Signed               bool // True if signed samples
	HorizontalSeparation int  // Horizontal sub-sampling
	VerticalSeparation   int  // Vertical sub-sampling
}

type ConfidenceBreakdown struct {
	// QuantizationTableScore is the confidence from quantization table matching (0.0-1.0).
	// This is weighted at 0.5 in the final calculation.
	QuantizationTableScore float64

	// APPMarkerScore is the confidence from APP marker analysis (0.0-1.0).
	// This is weighted at 0.3 in the final calculation.
	APPMarkerScore float64

	// HuffmanTableScore is the confidence from Huffman table analysis (0.0-1.0).
	// This is weighted at 0.2 in the final calculation.
	HuffmanTableScore float64

	// ContradictionPenalty is a multiplier penalty for conflicting signals (0.0-1.0).
	// A value of 0.0 means no penalty, 0.5 means 50% reduction, 1.0 means zero confidence.
	ContradictionPenalty float64

	// FinalConfidence is the calculated final confidence after applying weights and penalties.
	FinalConfidence float64

	// ContradictionDetails lists specific contradictions detected.
	// Examples: ["adobe-marker-with-camera-exif", "incompatible-table-source"]
	ContradictionDetails []string
}

type ConfidenceCalculator struct {
	// contains filtered or unexported fields
}

type Configurable interface {
	// GetOptions returns the current configuration options.
	GetOptions() *EncoderOptions

	// SetOptions sets new configuration options.
	// Returns an error if the options are invalid.
	SetOptions(opts *EncoderOptions) error
}

type DCPredictor struct {
	// contains filtered or unexported fields
}

type DCTCoefficient struct {
	// Value is the quantized DCT coefficient value
	Value int16

	// Row is the row position in the 8x8 DCT block (0-7)
	Row int

	// Col is the column position in the 8x8 DCT block (0-7)
	Col int

	// Component is the color component index (0=Y, 1=Cb, 2=Cr)
	Component int

	// BlockX is the horizontal block index in the image
	BlockX int

	// BlockY is the vertical block index in the image
	BlockY int
}

type DCTHistogramAnalyzer struct {
	// contains filtered or unexported fields
}

type DCTHistogramResult struct {
	// EstimatedQuality is the estimated JPEG quality (1-100) based on histogram analysis.
	EstimatedQuality int

	// Confidence is the confidence level of the quality estimate (0.0-1.0).
	Confidence float64

	// ACHistogram is the histogram of AC coefficients.
	ACHistogram []HistogramBucket

	// DCHistogram is the histogram of DC coefficients.
	DCHistogram []HistogramBucket

	// Spread is the standard deviation of the coefficient distribution.
	Spread float64

	// ZeroPercentage is the percentage of zero coefficients (0.0-1.0).
	ZeroPercentage float64

	// Kurtosis is the kurtosis of the distribution (peakedness).
	Kurtosis float64
}

type DCTImplementation int

type DCTTransformer interface {
	// Forward performs forward DCT on an 8x8 block.
	// Input values should be level-shifted (subtracted by 128 for 8-bit).
	Forward(block *[BlockSize2]float64)

	// Inverse performs inverse DCT on an 8x8 block.
	// Output values need to be level-shifted back (add 128 for 8-bit).
	Inverse(block *[BlockSize2]float64)
}

type DHTSegment struct {
	TableClass int     // 0 = DC table, 1 = AC table
	TableID    int     // Table destination identifier (0-3)
	Bits       [16]int // Number of codes of each length
	Values     []byte  // Symbol values
}

type DQTSegment struct {
	Precision int        // 0 = 8-bit, 1 = 16-bit
	TableID   int        // Table destination identifier (0-3)
	Values    [64]uint16 // Quantization values in zigzag order
}

type DecodeMetadata struct {
	// HDRMetadata contains HDR-specific metadata (JPEG XT)
	HDR *HDRDecodeMetadata

	// LightFieldMetadata contains light field metadata (JPEG Pleno)
	LightField *LightFieldDecodeMetadata

	// TrustMetadata contains trust/provenance metadata (JPEG Trust)
	Trust *TrustDecodeMetadata
}

type DecodeResult struct {
	// Format is the detected JPEG format
	Format Format

	// Image is the decoded image for standard JPEG formats
	// This is nil for non-image formats like point clouds
	Image image.Image

	// HDRData contains HDR pixel data when HDROutputFloat32 is used
	// Each value is a linear light float32 in range [0, +inf)
	HDRData []float32

	// HDRUint16Data contains HDR pixel data when HDROutputUint16 is used
	// Each value is a 16-bit unsigned integer
	HDRUint16Data []uint16

	// LightFieldViews contains decoded light field views for JPEG Pleno
	// Each view is indexed by (u, v) coordinates
	LightFieldViews map[[2]int]image.Image

	// PointCloud contains decoded point cloud data for JPEG Pleno
	PointCloud *PointCloudResult

	// EventStream contains decoded events for JPEG XE
	EventStream *EventStreamResult

	// Metadata contains format-specific metadata
	Metadata *DecodeMetadata

	// Width and Height of the decoded image/data
	Width  int
	Height int

	// ComponentCount is the number of color components
	ComponentCount int
}

type Decoder struct {
	// contains filtered or unexported fields
}

type DecoderOptions struct {
	// DCT specifies which DCT implementation to use.
	// Default: DCTDefault (AAN fast DCT)
	DCT DCTImplementation

	// ColorConversion specifies the YCbCr to RGB conversion standard.
	// Default: ColorConversionBT601
	ColorConversion ColorConversionStandard

	// ChromaUpsampling specifies the chroma upsampling quality.
	// Default: UpsamplingNearestNeighbor (faster)
	// Set to UpsamplingBilinear for higher quality at the cost of speed.
	ChromaUpsampling UpsamplingMode

	// HDROutput specifies how HDR data should be output.
	// Default: HDROutputSDR (tone-mapped to 8-bit)
	// Only applies to JPEG XT and other HDR-capable formats.
	HDROutput HDROutputMode

	// HDRIgnoreExtension when true ignores HDR extension data.
	// Only decodes the base layer for backward compatibility.
	// Default: false (decode full HDR)
	HDRIgnoreExtension bool

	// LightFieldView specifies which views to extract from light fields.
	// Default: LightFieldViewCenter (extract center view only)
	LightFieldView LightFieldViewMode

	// LightFieldViewU specifies the U coordinate for LightFieldViewSpecific mode.
	// Default: 0
	LightFieldViewU int

	// LightFieldViewV specifies the V coordinate for LightFieldViewSpecific mode.
	// Default: 0
	LightFieldViewV int

	// PointCloudFormat specifies the output format for point cloud data.
	// Default: PointCloudRaw
	PointCloudFormat PointCloudOutputFormat

	// PointCloudIncludeNormals when true includes surface normals if available.
	// Default: false
	PointCloudIncludeNormals bool

	// PointCloudIncludeColors when true includes color information if available.
	// Default: true
	PointCloudIncludeColors bool

	// LowLatencyMode when true enables line-by-line decoding for minimal latency.
	// Only applies to JPEG XS format.
	// Default: false (decode complete frame)
	LowLatencyMode bool
}

type DefaultValidator struct{}

type DetectionResult struct {
	Data   []byte      // Original data reference
	Format Format      // Detected format
	Info   *FormatInfo // Detailed format information (optional)
	Error  error       // Any error that occurred
}

type DifferentialEncodingMode int

type DifferentialLosslessEncoder struct {
	// contains filtered or unexported fields
}

type DifferentialProgressiveEncoder struct {
	// contains filtered or unexported fields
}

type DifferentialSequentialEncoder struct {
	// contains filtered or unexported fields
}

type EXIFMetadataParser interface {
	// Parse extracts EXIF metadata from APP1 marker data.
	// Returns Data struct with all available fields populated, or error if parsing fails.
	Parse(data []byte) (*exif.Data, error)
}

type EXIFParser struct {
	// contains filtered or unexported fields
}

type Encoder interface {
	// Encode encodes raw pixel data to JPEG bytes.
	Encode(img *ImageData) ([]byte, error)

	// EncodeImage encodes Go's image.Image to JPEG bytes.
	EncodeImage(img image.Image) ([]byte, error)

	// Format returns the target encoding format.
	Format() Format

	// SetQuality sets encoding quality (0-100, format-dependent).
	SetQuality(quality int) error
}

type EncoderBitWriter struct {
	// contains filtered or unexported fields
}

type EncoderComponentSpec struct {
	// ID is the component identifier (1-255, typically 1=Y, 2=Cb, 3=Cr).
	ID int

	// HSampling is the horizontal sampling factor (1-4).
	// This determines how many 8x8 blocks of this component are in each MCU
	// in the horizontal direction.
	HSampling int

	// VSampling is the vertical sampling factor (1-4).
	// This determines how many 8x8 blocks of this component are in each MCU
	// in the vertical direction.
	VSampling int

	// QuantTableID is the quantization table selector (0-3).
	// Specifies which DQT table to use for this component.
	QuantTableID int

	// DCTableID is the DC Huffman table selector (0-3) for encoding.
	// Only used when building the scan; not written to SOF marker.
	DCTableID int

	// ACTableID is the AC Huffman table selector (0-3) for encoding.
	// Only used when building the scan; not written to SOF marker.
	ACTableID int
}

type EncoderDetector interface {
	// DetectEncoder analyzes raw JPEG file bytes to detect the encoder.
	// It parses DQT markers and APP markers from the JPEG structure and
	// analyzes patterns to identify the software, device, or library
	// that produced the image.
	//
	// Returns:
	//   - *EncoderSignature: Comprehensive encoder identification
	//   - error: If data is not valid JPEG or lacks required markers
	//
	// Errors returned for:
	//   - Non-JPEG data (missing SOI marker 0xFFD8)
	//   - JPEG without DQT markers
	//   - Lossless JPEG (SOF3) where encoder detection is not applicable
	DetectEncoder(data []byte) (*EncoderSignature, error)

	// DetectEncoderFromTables detects the encoder from pre-parsed quantization tables.
	// This is useful when JPEG data has already been partially parsed.
	//
	// Parameters:
	//   - tables: Map of quantization tables indexed by table ID (0-3)
	//     - ID 0: Typically luminance (Y) table
	//     - ID 1: Typically chrominance (Cb/Cr) table
	//
	// Returns:
	//   - *EncoderSignature: Comprehensive encoder identification
	//   - error: If tables map is empty or contains invalid data
	DetectEncoderFromTables(tables map[int][64]int) (*EncoderSignature, error)
}

type EncoderError struct {
	Format  Format // The encoding format that failed
	Phase   string // The encoding phase (e.g., "DCT", "quantization", "entropy")
	Message string // Human-readable error description
	Cause   error  // Underlying cause of the error
}

type EncoderFamily int

type EncoderOptions struct {
	Quality           int               // Quality level 0-100 (default 75)
	ChromaSubsampling ChromaSubsampling // Chroma subsampling mode
	Progressive       bool              // Use progressive encoding if supported
	OptimizeHuffman   bool              // Generate optimized Huffman tables
	Lossless          bool              // Use lossless mode if supported
	RestartInterval   int               // MCU rows between restart markers (0 = disabled)
	Comment           string            // Comment to embed in JPEG (empty = use default)
	DisableComment    bool              // Set to true to disable comment embedding

	// LuminanceQuantTable, when non-nil, overrides the scalar-Quality-derived
	// luminance quantization table for baseline encoding. The table must be in
	// NATURAL (row-major) order — the same order as StandardLuminanceQuantTable
	// and the output of ScaleQuantTable. Use ZigzagToNatural to convert a table
	// obtained from Decoder.QuantizationTable (which is in zigzag order).
	//
	// This exists so a re-compression step can reuse the SOURCE image's actual
	// quantization table instead of a standard table scaled by an estimated
	// scalar quality — required by Fridrich §3.2 cover-histogram estimation.
	// When nil (default), behavior is unchanged: ScaleQuantTable(standard, Quality).
	LuminanceQuantTable *[BlockSize2]int

	// ChrominanceQuantTable, when non-nil, overrides the chrominance
	// quantization table. Natural (row-major) order, same conventions as
	// LuminanceQuantTable. Ignored for grayscale encodes.
	ChrominanceQuantTable *[BlockSize2]int
}

type EncoderQualityMapping struct {
	// Name is the human-readable name of the encoder.
	Name string

	// Curve is the function that generates quantization tables for this encoder.
	Curve QualityCurve

	// ScaleMin is the minimum quality value for this encoder's native scale.
	ScaleMin int

	// ScaleMax is the maximum quality value for this encoder's native scale.
	ScaleMax int

	// UsesLibjpegScale indicates whether this encoder uses the standard
	// libjpeg 1-100 quality scale.
	UsesLibjpegScale bool
}

type EncoderSignature struct {
	// EncoderFamily is the broad encoder category.
	// Possible values: "libjpeg", "adobe", "camera", "mobile", "unknown"
	EncoderFamily string

	// EncoderName is the specific identification.
	// Examples: "libjpeg-turbo", "Photoshop CS6", "Canon EOS R5", "iPhone 15 Pro"
	EncoderName string

	// EncoderVersion is the version when detectable from APP markers or table patterns.
	EncoderVersion string

	// Confidence indicates identification reliability (0.0-1.0).
	// A value of 1.0 indicates high confidence match,
	// while lower values indicate uncertainty.
	Confidence float64

	// MatchMethod describes how identification was made.
	// Possible values: "quantization-table", "app-marker", "huffman-signature", "combined"
	MatchMethod string

	// TableSignatureHash is the SHA-256 hash of quantization tables for database lookup.
	TableSignatureHash string

	// DetectedPatterns lists all matched signature patterns.
	// Examples: ["ijg-standard-lum-q75", "ijg-standard-chrom-q75"]
	DetectedPatterns []string
}

type EncoderWithConfig interface {
	Encoder
	Configurable
}

type EncoderWithValidation interface {
	Encoder
	Validatable
}

type EstimationMethod int

type EventStreamDecoder interface {
	// DecodeEvents decodes all events from the stream.
	DecodeEvents(r io.Reader) ([]VisualEvent, *EventStreamInfo, error)
}

type EventStreamInfo struct {
	Width          int    // Sensor width in pixels
	Height         int    // Sensor height in pixels
	EventCount     uint64 // Total number of events
	StartTimestamp uint64 // First event timestamp
	EndTimestamp   uint64 // Last event timestamp
	SensorType     string // Sensor type identifier
}

type EventStreamResult struct {
	// Events contains the decoded visual events
	Events []VisualEventData

	// SensorWidth is the width of the event sensor
	SensorWidth int

	// SensorHeight is the height of the event sensor
	SensorHeight int

	// Duration is the total duration of the event stream in microseconds
	Duration uint64
}

type ExtendedEncoder struct {
	// contains filtered or unexported fields
}

type Format int

type FormatAnalyzer interface {
	FormatDetector

	// Analyze extracts comprehensive format information from raw data.
	// Returns FormatInfo with dimensions, components, and format details.
	Analyze(data []byte) (*FormatInfo, error)
}

type FormatDetector interface {
	// Detect identifies the JPEG format from raw byte data.
	// Returns the detected Format and any error encountered.
	Detect(data []byte) (Format, error)
}

type FormatInfo struct {
	Format         Format
	Width          int
	Height         int
	Components     int
	BitsPerSample  int
	IsJPEG2000     bool
	IsJPEGXT       bool
	IsJPEGXS       bool
	IsJPEGPleno    bool
	IsJPEGAI       bool
	IsJPEGXE       bool
	IsJPEG2000Ext  bool // True for JPX, MJ2, JPM, HTJ2K, JPSEC, JPIP, JP3D, JPWL
	HasThumbnail   bool
	HasHDR         bool
	HasTrust       bool // True if JPEG Trust metadata present
	HasJUMBF       bool // True if JUMBF metadata present
	Has360Metadata bool // True if 360 metadata present
	HasLinks       bool // True if JLINK references present
}

type FrameDifferencer struct {
	// Reference image (upsampled from previous level)
	Reference *ImageData

	// Target image (current level)
	Target *ImageData

	// Differential image (residuals)
	Differential *ImageData
}

type FullEncoder interface {
	Encoder
	Validatable
	Configurable
}

type HDRDecodeMetadata struct {
	Profile         int     // JPEG XT profile (A, B, C, D)
	DynamicRange    float64 // Dynamic range in stops
	MaxLuminance    float64 // Maximum luminance in cd/m^2
	MinLuminance    float64 // Minimum luminance in cd/m^2
	ToneMapOperator string  // Name of embedded tone mapping operator
}

type HDRDecoder interface {
	// DecodeHDR decodes HDR image data from a reader.
	// Returns pixel data as float32 values (typically in linear light space).
	DecodeHDR(r io.Reader) ([]float32, *HDRMetadata, error)
}

type HDREncoder interface {
	// EncodeHDR encodes HDR pixel data to a writer.
	// Pixels should be linear float32 values.
	// Returns the number of bytes written.
	EncodeHDR(w io.Writer, pixels []float32, metadata *HDRMetadata) (int, error)
}

type HDRInfoProvider interface {
	// GetHDRInfo extracts HDR metadata from image data.
	GetHDRInfo(data []byte) (*HDRMetadata, error)
}

type HDRMetadata struct {
	Profile          int     // HDR profile (A, B, C, D)
	DynamicRange     float64 // Dynamic range in stops
	MaxLuminance     float64 // Maximum luminance in cd/m^2
	MinLuminance     float64 // Minimum luminance in cd/m^2
	BitDepth         int     // Bit depth of HDR data (e.g., 16, 32)
	IsFloatingPoint  bool    // True if floating-point representation
	ToneMapOperator  string  // Name of embedded tone mapping operator
	RefinementLayers int     // Number of refinement layers
}

type HDROutputMode int

type HashLookupResult struct {
	// EncoderFamily is the registered encoder family for this hash.
	EncoderFamily string

	// Quality is the quality level associated with this hash.
	Quality int

	// TableType indicates the type of table this hash represents.
	TableType TableType
}

type HierarchicalFrameStructure struct {
	// Original full-resolution image
	Original *ImageData

	// Pyramid of image levels from lowest to highest resolution
	Levels []*HierarchicalLevel

	// Options for hierarchical encoding
	Options *HierarchicalOptions
}

type HierarchicalFrameType int

type HierarchicalLevel struct {
	// Width and height at this level
	Width  int
	Height int

	// Scale factor relative to full resolution (1 = full, 2 = half, etc.)
	ScaleFactor int

	// Frame type for this level
	FrameType HierarchicalFrameType

	// Image data at this level
	Data *ImageData
}

type HierarchicalOptions struct {
	// NumberOfLevels specifies how many resolution levels to encode (minimum 2)
	NumberOfLevels int

	// UseArithmetic enables arithmetic coding instead of Huffman
	UseArithmetic bool

	// BaseEncodingMode specifies the encoding mode for each level
	// Sequential, Progressive, or Lossless
	BaseEncodingMode DifferentialEncodingMode
}

type HistogramBucket struct {
	// Count is the number of coefficients in this bucket.
	Count int

	// RangeMin is the minimum value (inclusive) for this bucket.
	RangeMin int

	// RangeMax is the maximum value (inclusive) for this bucket.
	RangeMax int
}

type HologramData struct {
	Width       int         // Hologram width in pixels
	Height      int         // Hologram height in pixels
	Wavelength  float64     // Recording wavelength in meters
	PixelPitch  float64     // Pixel pitch in meters
	IsBinary    bool        // True if binary hologram, false if continuous-tone
	ComplexData []complex64 // Complex-valued hologram data (if applicable)
	RealData    []float32   // Real-valued hologram data (if binary)
}

type HologramDecoder interface {
	// DecodeHologram decodes holographic data from a reader.
	DecodeHologram(r io.Reader) (*HologramData, error)
}

type HuffTable struct {

	// Public fields for backward compatibility
	BITS     [17]int
	HUFFVAL  [256]int
	HUFFCODE [257]int
	HUFFSIZE [257]int
	MINCODE  [17]int
	MAXCODE  [18]int
	VALPTR   [17]int
	Ln       int
	SI       int
	I        int
	J        int
	K        int
	LASTK    int
	CODE     int
	// contains filtered or unexported fields
}