exif_oxide/implementations/nikon/

af_processing.rs

//! Nikon AF (AutoFocus) system processing
//!
//! **Trust ExifTool**: This code translates ExifTool's Nikon AF processing verbatim.
//!
//! ExifTool Reference: lib/Image/ExifTool/Nikon.pm AF-related functions
//!
//! Nikon cameras have sophisticated AF systems ranging from 11-point (older cameras)
//! to 405-point (Z8/Z9) with various detection modes and grid layouts.
//!
//! This module handles:
//! - AF point extraction from binary data
//! - AF area mode processing
//! - Version-specific AF format handling
//! - Grid-based AF coordinate mapping (newer cameras)

use crate::exif::ExifReader;
use crate::types::{ExifError, Result, TagValue};
use tracing::{debug, trace};

/// AF system types for different Nikon camera generations
/// ExifTool: Various AF point hash references in Nikon.pm
#[derive(Debug, Clone, PartialEq)]
pub enum NikonAfSystem {
    /// 11-point AF system (older DSLRs)
    Points11,
    /// 39-point AF system (D7000 series)
    Points39,
    /// 51-point AF system (D7100, D7200, D750, etc.)
    Points51,
    /// 153-point AF system (D500, D850)
    Points153,
    /// 105-point AF system (D6)
    Points105,
    /// 405-point AF system (Z8, Z9)
    Points405,
    /// Unknown or unsupported AF system
    Unknown,
}

impl NikonAfSystem {
    /// Determine AF system from camera model
    /// ExifTool: Model-specific AF system detection logic
    pub fn from_camera_model(model: &str) -> Self {
        if model.contains("Z 8") || model.contains("Z 9") {
            NikonAfSystem::Points405
        } else if model.contains("D6") {
            NikonAfSystem::Points105
        } else if model.contains("D500") || model.contains("D850") {
            NikonAfSystem::Points153
        } else if model.contains("D7100") || model.contains("D7200") || model.contains("D750") {
            NikonAfSystem::Points51
        } else if model.contains("D7000") {
            NikonAfSystem::Points39
        } else {
            // Default to 11-point for older cameras
            NikonAfSystem::Points11
        }
    }

    /// Get the number of AF points for this system
    pub fn point_count(&self) -> usize {
        match self {
            NikonAfSystem::Points11 => 11,
            NikonAfSystem::Points39 => 39,
            NikonAfSystem::Points51 => 51,
            NikonAfSystem::Points153 => 153,
            NikonAfSystem::Points105 => 105,
            NikonAfSystem::Points405 => 405,
            NikonAfSystem::Unknown => 0,
        }
    }
}

/// Process Nikon AF Info data from maker notes
/// ExifTool: Nikon.pm AFInfo processing functions
pub fn process_nikon_af_info(
    reader: &mut ExifReader,
    data: &[u8],
    camera_model: &str,
) -> Result<()> {
    debug!("Processing Nikon AF Info for camera: {}", camera_model);

    if data.len() < 4 {
        return Err(ExifError::ParseError(format!(
            "AFInfo data too short: {} bytes",
            data.len()
        )));
    }

    // AF Info version detection
    // ExifTool: AFInfo version from first 2 bytes
    let version = u16::from_be_bytes([data[0], data[1]]);
    // Store AF Info version tag with proper tag source
    let tag_source = reader.create_tag_source_info("Nikon");
    reader.store_tag_with_precedence(0x0088, TagValue::U16(version), tag_source);

    debug!("AF Info version: 0x{:04x}", version);

    // Determine AF system from camera model
    let af_system = NikonAfSystem::from_camera_model(camera_model);
    debug!(
        "Detected AF system: {:?} ({} points)",
        af_system,
        af_system.point_count()
    );

    // Process version-specific AF info
    match version {
        0x0100 => process_af_info_v0100(reader, data, &af_system),
        0x0102 => process_af_info_v0102(reader, data, &af_system),
        0x0103 => process_af_info_v0103(reader, data, &af_system),
        0x0106 => process_af_info_v0106(reader, data, &af_system),
        0x0107 => process_af_info_v0107(reader, data, &af_system),
        0x0300 => process_af_info_v0300(reader, data, &af_system),
        _ => {
            debug!("Unknown AF Info version: 0x{:04x}", version);
            let tag_source = reader.create_tag_source_info("Nikon");
            reader.store_tag_with_precedence(
                0x0088,
                TagValue::string(format!("Unknown version 0x{version:04x}")),
                tag_source,
            );
            Ok(())
        }
    }
}

/// Process AF Info version 0100 (legacy cameras)
/// ExifTool: Nikon.pm AFInfo version 0100 processing
fn process_af_info_v0100(
    reader: &mut ExifReader,
    data: &[u8],
    af_system: &NikonAfSystem,
) -> Result<()> {
    debug!("Processing AF Info v0100 for {:?}", af_system);

    if data.len() < 8 {
        return Err(ExifError::ParseError(format!(
            "AFInfo v0100 data too short: {} bytes",
            data.len()
        )));
    }

    // Basic AF information for older cameras
    // ExifTool: Simple AF point extraction for legacy systems
    let af_point = data[4];
    let tag_source = reader.create_tag_source_info("Nikon");
    reader.store_tag_with_precedence(0x0089, TagValue::U8(af_point), tag_source.clone());

    if af_point > 0 && af_point <= af_system.point_count() as u8 {
        reader.store_tag_with_precedence(
            0x008A,
            TagValue::string(format!("Point {af_point}")),
            tag_source,
        );
    }

    Ok(())
}

/// Process AF Info version 0102 (D70, D50, etc.)
/// ExifTool: Nikon.pm AFInfo version 0102 processing
fn process_af_info_v0102(
    reader: &mut ExifReader,
    data: &[u8],
    af_system: &NikonAfSystem,
) -> Result<()> {
    debug!("Processing AF Info v0102 for {:?}", af_system);

    if data.len() < 16 {
        return Err(ExifError::ParseError(format!(
            "AFInfo v0102 data too short: {} bytes",
            data.len()
        )));
    }

    // AF area mode
    let af_area_mode = data[2];
    let tag_source = reader.create_tag_source_info("Nikon");
    reader.store_tag_with_precedence(0x008B, TagValue::U8(af_area_mode), tag_source.clone());

    // AF point in focus
    let af_point_in_focus = data[3];
    reader.store_tag_with_precedence(0x008C, TagValue::U8(af_point_in_focus), tag_source.clone());

    // AF point selected
    if data.len() >= 5 {
        let af_point_selected = data[4];
        reader.store_tag_with_precedence(0x008D, TagValue::U8(af_point_selected), tag_source);
    }

    Ok(())
}

/// Process AF Info version 0103 (D2X, D2Xs, D2H, D2Hs)
/// ExifTool: Nikon.pm AFInfo version 0103 processing
fn process_af_info_v0103(
    reader: &mut ExifReader,
    data: &[u8],
    af_system: &NikonAfSystem,
) -> Result<()> {
    debug!("Processing AF Info v0103 for {:?}", af_system);

    if data.len() < 16 {
        return Err(ExifError::ParseError(format!(
            "AFInfo v0103 data too short: {} bytes",
            data.len()
        )));
    }

    // AF area mode
    let af_area_mode = data[2];
    let tag_source = reader.create_tag_source_info("Nikon");
    reader.store_tag_with_precedence(0x008E, TagValue::U8(af_area_mode), tag_source.clone());

    // AF point in focus
    let af_point_in_focus = data[3];
    reader.store_tag_with_precedence(0x008F, TagValue::U8(af_point_in_focus), tag_source.clone());

    // AF points used (bitmask)
    if data.len() >= 6 {
        let af_points_used = u16::from_be_bytes([data[4], data[5]]);
        reader.store_tag_with_precedence(0x0090, TagValue::U16(af_points_used), tag_source.clone());

        // Convert bitmask to readable format
        let af_points_readable = print_af_points_bitmask(af_points_used, af_system);
        reader.store_tag_with_precedence(0x0091, TagValue::String(af_points_readable), tag_source);
    }

    Ok(())
}

/// Process AF Info version 0106 (D40, D40x, D80, D200)
/// ExifTool: Nikon.pm AFInfo version 0106 processing
fn process_af_info_v0106(
    reader: &mut ExifReader,
    data: &[u8],
    af_system: &NikonAfSystem,
) -> Result<()> {
    debug!("Processing AF Info v0106 for {:?}", af_system);

    if data.len() < 20 {
        return Err(ExifError::ParseError(format!(
            "AFInfo v0106 data too short: {} bytes",
            data.len()
        )));
    }

    // Phase detection AF
    if data.len() >= 4 {
        let phase_detect_af = data[2];
        let tag_source = reader.create_tag_source_info("Nikon");
        reader.store_tag_with_precedence(0x0092, TagValue::U8(phase_detect_af), tag_source);
    }

    // Contrast detect AF
    if data.len() >= 5 {
        let contrast_detect_af = data[3];
        let tag_source = reader.create_tag_source_info("Nikon");
        reader.store_tag_with_precedence(0x0093, TagValue::U8(contrast_detect_af), tag_source);
    }

    // AF area mode
    if data.len() >= 8 {
        let af_area_mode = data[6];
        let tag_source = reader.create_tag_source_info("Nikon");
        reader.store_tag_with_precedence(0x0094, TagValue::U8(af_area_mode), tag_source);
    }

    // AF point in focus
    if data.len() >= 9 {
        let af_point_in_focus = data[7];
        let tag_source = reader.create_tag_source_info("Nikon");
        reader.store_tag_with_precedence(0x0095, TagValue::U8(af_point_in_focus), tag_source);
    }

    Ok(())
}

/// Process AF Info version 0107 (newer DSLRs)
/// ExifTool: Nikon.pm AFInfo version 0107 processing
fn process_af_info_v0107(
    reader: &mut ExifReader,
    data: &[u8],
    af_system: &NikonAfSystem,
) -> Result<()> {
    debug!("Processing AF Info v0107 for {:?}", af_system);

    if data.len() < 30 {
        return Err(ExifError::ParseError(format!(
            "AFInfo v0107 data too short: {} bytes",
            data.len()
        )));
    }

    // Advanced AF information for newer cameras
    // AF area mode (enhanced)
    if data.len() >= 4 {
        let af_area_mode = data[2];
        let tag_source = reader.create_tag_source_info("Nikon");
        reader.store_tag_with_precedence(0x0094, TagValue::U8(af_area_mode), tag_source);
    }

    // Primary AF point
    if data.len() >= 5 {
        let primary_af_point = data[3];
        let tag_source = reader.create_tag_source_info("Nikon");
        reader.store_tag_with_precedence(0x0096, TagValue::U8(primary_af_point), tag_source);
    }

    // AF points in focus (extended bitmask for 51-point systems)
    if data.len() >= 10
        && matches!(
            af_system,
            NikonAfSystem::Points51 | NikonAfSystem::Points153
        )
    {
        let af_points_bytes = &data[4..10];
        let af_points_readable = print_af_points_extended(af_points_bytes, af_system);
        let tag_source = reader.create_tag_source_info("Nikon");
        reader.store_tag_with_precedence(0x0097, TagValue::String(af_points_readable), tag_source);
    }

    Ok(())
}

/// Process AF Info version 0300 (Z-series mirrorless)
/// ExifTool: Nikon.pm AFInfo version 0300 processing
fn process_af_info_v0300(
    reader: &mut ExifReader,
    data: &[u8],
    af_system: &NikonAfSystem,
) -> Result<()> {
    debug!("Processing AF Info v0300 (Z-series) for {:?}", af_system);

    if data.len() < 50 {
        return Err(ExifError::ParseError(format!(
            "AFInfo v0300 data too short: {} bytes",
            data.len()
        )));
    }

    // Z-series specific AF processing
    // Subject detection mode
    if data.len() >= 6 {
        let subject_detection = data[4];
        let tag_source = reader.create_tag_source_info("Nikon");
        reader.store_tag_with_precedence(
            0x0098,
            TagValue::U8(subject_detection),
            tag_source.clone(),
        );

        // Convert to readable format
        let detection_readable = match subject_detection {
            0 => "Off",
            1 => "Human",
            2 => "Animal",
            3 => "Vehicle",
            _ => "Unknown",
        };
        reader.store_tag_with_precedence(
            0x0099,
            TagValue::string(detection_readable.to_string()),
            tag_source,
        );
    }

    // AF area mode for Z-series
    if data.len() >= 8 {
        let af_area_mode = data[6];
        let tag_source = reader.create_tag_source_info("Nikon");
        reader.store_tag_with_precedence(0x0094, TagValue::U8(af_area_mode), tag_source);
    }

    // Grid-based AF coordinates for 405-point system
    if matches!(af_system, NikonAfSystem::Points405) && data.len() >= 20 {
        let _ = process_z_series_af_grid(reader, &data[10..20]);
    }

    Ok(())
}

/// Process Z-series AF grid coordinates
/// ExifTool: Z-series AF coordinate processing
fn process_z_series_af_grid(reader: &mut ExifReader, grid_data: &[u8]) -> Result<()> {
    debug!("Processing Z-series AF grid coordinates");

    if grid_data.len() < 8 {
        return Ok(());
    }

    // AF area position (grid coordinates)
    let af_x_position = i16::from_be_bytes([grid_data[0], grid_data[1]]);
    let af_y_position = i16::from_be_bytes([grid_data[2], grid_data[3]]);

    let tag_source = reader.create_tag_source_info("Nikon");
    reader.store_tag_with_precedence(0x009A, TagValue::I16(af_x_position), tag_source.clone());
    reader.store_tag_with_precedence(0x009B, TagValue::I16(af_y_position), tag_source.clone());

    // Convert to human-readable position
    let readable_position = format!("({af_x_position}, {af_y_position})");
    reader.store_tag_with_precedence(0x009C, TagValue::String(readable_position), tag_source);

    trace!("AF grid position: ({}, {})", af_x_position, af_y_position);

    Ok(())
}

/// Convert AF points bitmask to human-readable format
/// ExifTool: PrintAFPoints function equivalent
fn print_af_points_bitmask(bitmask: u16, af_system: &NikonAfSystem) -> String {
    let mut active_points = Vec::new();

    // Basic AF point mapping for legacy systems
    for i in 0..af_system.point_count() {
        if bitmask & (1 << i) != 0 {
            active_points.push(format!("Point {}", i + 1));
        }
    }

    if active_points.is_empty() {
        "None".to_string()
    } else if active_points.len() == 1 {
        active_points[0].clone()
    } else {
        format!("Multiple ({})", active_points.join(", "))
    }
}

/// Convert extended AF points data to human-readable format
/// ExifTool: Extended AF point processing for 51+ point systems
fn print_af_points_extended(af_data: &[u8], af_system: &NikonAfSystem) -> String {
    if af_data.len() < 6 {
        return "Unknown".to_string();
    }

    // For advanced AF systems, process multiple bytes of AF point data
    let mut active_points = Vec::new();

    // Process AF point bytes based on system type
    match af_system {
        NikonAfSystem::Points51 => {
            // 51-point system uses 7 bytes of AF data
            for (byte_idx, &byte_val) in af_data.iter().enumerate().take(7) {
                for bit in 0..8 {
                    if byte_val & (1 << bit) != 0 {
                        let point_num = byte_idx * 8 + bit + 1;
                        if point_num <= 51 {
                            active_points.push(format!("Point {point_num}"));
                        }
                    }
                }
            }
        }
        NikonAfSystem::Points153 => {
            // 153-point system - simplified representation
            let primary_point = af_data[0];
            if primary_point > 0 && primary_point <= 153 {
                active_points.push(format!("Point {primary_point} (of 153)"));
            }
        }
        _ => {
            // Fallback for other systems
            return format!("Unknown AF system: {af_system:?}");
        }
    }

    if active_points.is_empty() {
        "None".to_string()
    } else if active_points.len() == 1 {
        active_points[0].clone()
    } else if active_points.len() <= 5 {
        active_points.join(", ")
    } else {
        format!("{} points active", active_points.len())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::exif::ExifReader;

    #[test]
    fn test_af_system_detection() {
        assert_eq!(
            NikonAfSystem::from_camera_model("NIKON Z 9"),
            NikonAfSystem::Points405
        );
        assert_eq!(
            NikonAfSystem::from_camera_model("NIKON Z 8"),
            NikonAfSystem::Points405
        );
        assert_eq!(
            NikonAfSystem::from_camera_model("NIKON D6"),
            NikonAfSystem::Points105
        );
        assert_eq!(
            NikonAfSystem::from_camera_model("NIKON D850"),
            NikonAfSystem::Points153
        );
        assert_eq!(
            NikonAfSystem::from_camera_model("NIKON D500"),
            NikonAfSystem::Points153
        );
        assert_eq!(
            NikonAfSystem::from_camera_model("NIKON D7200"),
            NikonAfSystem::Points51
        );
        assert_eq!(
            NikonAfSystem::from_camera_model("NIKON D7000"),
            NikonAfSystem::Points39
        );
        assert_eq!(
            NikonAfSystem::from_camera_model("NIKON D3"),
            NikonAfSystem::Points11
        );
    }

    #[test]
    fn test_af_system_point_count() {
        assert_eq!(NikonAfSystem::Points405.point_count(), 405);
        assert_eq!(NikonAfSystem::Points153.point_count(), 153);
        assert_eq!(NikonAfSystem::Points51.point_count(), 51);
        assert_eq!(NikonAfSystem::Points39.point_count(), 39);
        assert_eq!(NikonAfSystem::Points11.point_count(), 11);
        assert_eq!(NikonAfSystem::Unknown.point_count(), 0);
    }

    #[test]
    fn test_af_info_version_extraction() {
        let mut reader = ExifReader::new();
        let af_data = [0x01, 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07];

        let result = process_nikon_af_info(&mut reader, &af_data, "NIKON D850");
        assert!(result.is_ok());

        // Check that version was extracted (tag 0x0088)
        assert!(reader.extracted_tags.contains_key(&0x0088));
    }

    #[test]
    fn test_af_points_bitmask() {
        let af_system = NikonAfSystem::Points11;

        // Test single point
        let result = print_af_points_bitmask(0b00000001, &af_system);
        assert_eq!(result, "Point 1");

        // Test multiple points
        let result = print_af_points_bitmask(0b00000101, &af_system);
        assert!(result.contains("Multiple"));
        assert!(result.contains("Point 1"));
        assert!(result.contains("Point 3"));

        // Test no points
        let result = print_af_points_bitmask(0, &af_system);
        assert_eq!(result, "None");
    }

    #[test]
    fn test_af_info_insufficient_data() {
        let mut reader = ExifReader::new();
        let short_data = [0x01]; // Too short

        let result = process_nikon_af_info(&mut reader, &short_data, "NIKON D850");
        assert!(result.is_err());
    }

    #[test]
    fn test_z_series_subject_detection() {
        let af_system = NikonAfSystem::Points405;
        let mut reader = ExifReader::new();

        // Mock AF Info v0300 data with subject detection
        let mut af_data = vec![0x03, 0x00]; // Version 0x0300
        af_data.extend_from_slice(&[0x00, 0x00]); // Reserved
        af_data.push(1); // Subject detection: Human
        af_data.extend_from_slice(&[0x00, 0x02]); // AF area mode
        af_data.resize(50, 0); // Pad to minimum size

        let result = process_af_info_v0300(&mut reader, &af_data, &af_system);
        assert!(result.is_ok());

        // Check subject detection was processed (tags 0x0098, 0x0099)
        assert!(reader.extracted_tags.contains_key(&0x0098));
        assert!(reader.extracted_tags.contains_key(&0x0099));
    }
}