exiftool-rs 0.7.4

//! Fujifilm RAF file format reader.
//!
//! Parses RAF header and embedded JPEG/EXIF data.
//! Mirrors ExifTool's FujiFilm.pm ProcessRAF.
//!
//! RAF directory format (big-endian):
//!   4 bytes: entry count
//!   Per entry:
//!     2 bytes: tag_id
//!     2 bytes: data_len
//!     data_len bytes: raw data

use crate::error::{Error, Result};
use crate::tag::{Tag, TagGroup, TagId};
use crate::value::Value;

pub fn read_raf(data: &[u8]) -> Result<Vec<Tag>> {
    if data.len() < 100 || !data.starts_with(b"FUJIFILMCCD-RAW") {
        return Err(Error::InvalidData("not a Fujifilm RAF file".into()));
    }

    let mut tags = Vec::new();

    // FirmwareVersion at offset 0x3C (undef[4], e.g. "0106"). FujiFilm.pm:1229
    // (renamed from RAFVersion, ref forum17969).
    let version = crate::encoding::decode_utf8_or_latin1(&data[0x3C..0x40]).to_string();
    tags.push(mk(
        "FirmwareVersion",
        "Firmware Version",
        Value::String(version),
    ));

    // The RAF header carries the model name inside its 0x00 string (e.g.
    // "FUJIFILMCCD-RAW 0201FA392001FinePix S3Pro"), but ExifTool's RAFHeader table
    // (FujiFilm.pm:1223) does NOT extract it as a Model tag — Model comes solely
    // from the embedded EXIF IFD0 (with its s/\s+$// RawConv). Emit nothing here.

    // RAFCompression at 0x6c (if the first byte is 0x00, it's a valid compression tag)
    if data.len() >= 0x70 && data[0x6c] == 0 {
        let compression = u32::from_be_bytes([data[0x6c], data[0x6d], data[0x6e], data[0x6f]]);
        let comp_str = match compression {
            0 => "Uncompressed",
            2 => "Lossless",
            3 => "Lossy",
            _ => "Unknown",
        };
        tags.push(mk_loc(
            "RAFCompression",
            "RAF Compression",
            Value::U32(compression),
            comp_str.to_string(),
        ));
    }

    // JPEG offset at 0x54 (uint32 BE) and length at 0x58
    let jpeg_offset;
    let jpeg_length;
    if data.len() >= 0x5C {
        jpeg_offset = u32::from_be_bytes([data[0x54], data[0x55], data[0x56], data[0x57]]) as usize;
        jpeg_length = u32::from_be_bytes([data[0x58], data[0x59], data[0x5A], data[0x5B]]) as usize;
    } else {
        jpeg_offset = 0;
        jpeg_length = 0;
    }

    // Add PreviewImage tag (binary data of embedded JPEG)
    if jpeg_offset > 0 && jpeg_offset + jpeg_length <= data.len() && jpeg_length > 0 {
        let jpeg_data = &data[jpeg_offset..jpeg_offset + jpeg_length];
        // Add PreviewImage tag
        tags.push(Tag {
            id: TagId::Text("PreviewImage".into()),
            name: "PreviewImage".into(),
            description: "Preview Image".into(),
            // `$et->FoundTag('PreviewImage', \$jpeg)` (FujiFilm.pm line 1960):
            // a bare NAME, so it resolves through `%Image::ExifTool::Extra` —
            // File/File with `Groups => { 2 => 'Preview' }` (ExifTool.pm lines
            // 1781-1783) — not the RAF table.
            group: TagGroup {
                family0: "File".into(),
                family1: "File".into(),
                family2: "Preview".into(),
                family3: "Main".into(),
            },
            raw_value: Value::Binary(jpeg_data.to_vec()),
            print_value: format!(
                "(Binary data {} bytes, use -b option to extract)",
                jpeg_length
            ),
            priority: 0,
        });

        // Try to extract EXIF from embedded JPEG
        if jpeg_data.starts_with(&[0xFF, 0xD8, 0xFF]) {
            if let Ok(jpeg_tags) = crate::formats::jpeg::read_jpeg(jpeg_data) {
                for mut t in jpeg_tags {
                    // IsOffset tags from the embedded JPEG are JPEG-relative; ExifTool
                    // reports them as RAF-absolute, so add the JPEG's file position.
                    if matches!(
                        t.name.as_str(),
                        "ThumbnailOffset" | "PreviewImageStart" | "OtherImageStart"
                    ) {
                        if let Some(v) = t.raw_value.as_u64() {
                            let abs = v + jpeg_offset as u64;
                            t.raw_value = Value::U32(abs as u32);
                            t.print_value = abs.to_string();
                        }
                    }
                    tags.push(t);
                }
            }
        }
    }

    // ExifTool walks five header slots, not just one (FujiFilm.pm:1964):
    //   foreach $offset (0x48, 0x5c, 0x64, 0x78, 0x80)
    // Each slot holds an (offset, length) int32u pair:
    //   0x48 M-RAW header, 0x5c RAF directory, 0x64 FujiIFD directory,
    //   0x78 RAF1 directory, 0x80 FujiIFD1 directory (FujiFilm.pm:1242-1256).
    // The loop stops as soon as a slot reaches the embedded JPEG
    // (`last if $jpos and $offset >= $jpos`, FujiFilm.pm:1965) and skips empty
    // slots (`next unless $start`, FujiFilm.pm:1972).
    //
    // Successive RAF directories get family-1 groups RAF, RAF2, RAF3, ...
    // via `$$et{SET_GROUP1} = "RAF$rafNum"` with `$rafNum = ($rafNum || 1) + 1`
    // after each successful directory (FujiFilm.pm:2000-2010).
    let mut raf_num: u32 = 0;
    for offset in [0x48usize, 0x5c, 0x64, 0x78, 0x80] {
        if jpeg_offset != 0 && offset >= jpeg_offset {
            break;
        }
        if data.len() < offset + 8 {
            break;
        }
        let start = u32::from_be_bytes([
            data[offset],
            data[offset + 1],
            data[offset + 2],
            data[offset + 3],
        ]) as usize;
        let len = u32::from_be_bytes([
            data[offset + 4],
            data[offset + 5],
            data[offset + 6],
            data[offset + 7],
        ]) as usize;
        if start == 0 {
            continue;
        }
        // 0x48 (M-RAW header) and 0x64/0x80 (FujiIFD, TIFF-format data on some
        // models only — FujiFilm.pm:1973-1987) are not decoded here: no sample
        // in the corpus exercises them, and ExifTool itself reports nothing when
        // the FujiIFD parse fails.
        if offset == 0x48 || offset == 0x64 || offset == 0x80 {
            continue;
        }
        if start >= data.len() {
            continue;
        }
        let end = start.saturating_add(len).min(data.len());
        // raf_num == 0 stands for Perl's empty `$rafNum` suffix.
        let group1 = if raf_num == 0 {
            "RAF".to_string()
        } else {
            format!("RAF{}", raf_num)
        };
        if parse_raf_directory(&data[start..end], &mut tags, &group1) {
            raf_num = raf_num.max(1) + 1;
        }
    }

    Ok(tags)
}

/// Parse the RAF proprietary directory.
/// Format: 4-byte entry count (BE), then per entry: 2-byte tag_id, 2-byte data_len, data_len bytes of data.
/// `group1` is the family-1 group ExifTool assigns via SET_GROUP1 (RAF, RAF2, ...).
/// Returns true when the directory was parsed (ExifTool only bumps `$rafNum` then).
fn parse_raf_directory(data: &[u8], tags: &mut Vec<Tag>, group1: &str) -> bool {
    if data.len() < 4 {
        return false;
    }

    let num_entries = u32::from_be_bytes([data[0], data[1], data[2], data[3]]) as usize;
    if num_entries > 256 {
        return false; // Sanity check
    }

    let mut pos = 4;
    // FujiLayout flag: set by tag 0x130 if (first_byte & 0x80) != 0
    let mut fuji_layout = false;

    // First pass: determine FujiLayout from tag 0x130
    {
        let mut scan_pos = 4;
        for _ in 0..num_entries {
            if scan_pos + 4 > data.len() {
                break;
            }
            let tag_id = u16::from_be_bytes([data[scan_pos], data[scan_pos + 1]]);
            let data_len = u16::from_be_bytes([data[scan_pos + 2], data[scan_pos + 3]]) as usize;
            scan_pos += 4;
            if scan_pos + data_len > data.len() {
                break;
            }
            if tag_id == 0x130 && data_len >= 1 {
                fuji_layout = (data[scan_pos] & 0x80) != 0;
            }
            scan_pos += data_len;
        }
    }

    for _ in 0..num_entries {
        if pos + 4 > data.len() {
            break;
        }

        let tag_id = u16::from_be_bytes([data[pos], data[pos + 1]]);
        let data_len = u16::from_be_bytes([data[pos + 2], data[pos + 3]]) as usize;
        pos += 4;

        if pos + data_len > data.len() {
            break;
        }

        let val_data = &data[pos..pos + data_len];
        pos += data_len;

        if let Some(mut tag) = decode_raf_tag(tag_id, data_len, val_data, fuji_layout) {
            tag.group.family1 = group1.to_string();
            tags.push(tag);
        }
    }
    true
}

/// Decode a single RAF tag into a Tag struct.
fn decode_raf_tag(tag_id: u16, data_len: usize, val_data: &[u8], fuji_layout: bool) -> Option<Tag> {
    match tag_id {
        // RawImageFullSize: int16u[2], stored height-width, display width-height
        0x100 if data_len >= 4 => {
            let height = u16::from_be_bytes([val_data[0], val_data[1]]) as u32;
            let width = u16::from_be_bytes([val_data[2], val_data[3]]) as u32;
            let s = format!("{}x{}", width, height);
            Some(mk_loc(
                "RawImageFullSize",
                "Raw Image Full Size",
                Value::String(s.clone()),
                s,
            ))
        }
        // RawImageCropTopLeft: int16u[2] (top_margin, left_margin)
        0x110 if data_len >= 4 => {
            let top = u16::from_be_bytes([val_data[0], val_data[1]]);
            let left = u16::from_be_bytes([val_data[2], val_data[3]]);
            let s = format!("{} {}", top, left);
            Some(mk_loc(
                "RawImageCropTopLeft",
                "Raw Image Crop Top Left",
                Value::String(s.clone()),
                s,
            ))
        }
        // RawImageCroppedSize: int16u[2], stored height-width, display width-height
        0x111 if data_len >= 4 => {
            let height = u16::from_be_bytes([val_data[0], val_data[1]]) as u32;
            let width = u16::from_be_bytes([val_data[2], val_data[3]]) as u32;
            let s = format!("{}x{}", width, height);
            Some(mk_loc(
                "RawImageCroppedSize",
                "Raw Image Cropped Size",
                Value::String(s.clone()),
                s,
            ))
        }
        // RawImageSize: int16u[2], height then width, with FujiLayout adjustment
        0x121 if data_len >= 4 => {
            let mut height = u16::from_be_bytes([val_data[0], val_data[1]]) as u32;
            let mut width = u16::from_be_bytes([val_data[2], val_data[3]]) as u32;
            if fuji_layout {
                width /= 2;
                height *= 2;
            }
            let s = format!("{}x{}", width, height);
            Some(mk_loc(
                "RawImageSize",
                "Raw Image Size",
                Value::String(s.clone()),
                s,
            ))
        }
        // FujiLayout: int8u[4]
        0x130 => {
            let bytes: Vec<u8> = val_data[..data_len.min(4)].to_vec();
            let s = bytes
                .iter()
                .map(|b| b.to_string())
                .collect::<Vec<_>>()
                .join(" ");
            Some(mk_loc(
                "FujiLayout",
                "Fuji Layout",
                Value::String(s.clone()),
                s,
            ))
        }
        // WB_GRGBLevelsAuto: int16u[4] (take first 4 values only)
        0x2000 if data_len >= 8 => Some(decode_wb_grgb(
            val_data,
            "WB_GRGBLevelsAuto",
            "WB GRGB Levels Auto",
        )),
        // WB_GRGBLevelsDaylight
        0x2100 if data_len >= 8 => Some(decode_wb_grgb(
            val_data,
            "WB_GRGBLevelsDaylight",
            "WB GRGB Levels Daylight",
        )),
        // WB_GRGBLevelsCloudy
        0x2200 if data_len >= 8 => Some(decode_wb_grgb(
            val_data,
            "WB_GRGBLevelsCloudy",
            "WB GRGB Levels Cloudy",
        )),
        // WB_GRGBLevelsDaylightFluor
        0x2300 if data_len >= 8 => Some(decode_wb_grgb(
            val_data,
            "WB_GRGBLevelsDaylightFluor",
            "WB GRGB Levels Daylight Fluor",
        )),
        // WB_GRGBLevelsDayWhiteFluor
        0x2301 if data_len >= 8 => Some(decode_wb_grgb(
            val_data,
            "WB_GRGBLevelsDayWhiteFluor",
            "WB GRGB Levels Day White Fluor",
        )),
        // WB_GRGBLevelsWhiteFluorescent
        0x2302 if data_len >= 8 => Some(decode_wb_grgb(
            val_data,
            "WB_GRGBLevelsWhiteFluorescent",
            "WB GRGB Levels White Fluorescent",
        )),
        // WB_GRGBLevelsWarmWhiteFluor
        0x2310 if data_len >= 8 => Some(decode_wb_grgb(
            val_data,
            "WB_GRGBLevelsWarmWhiteFluor",
            "WB GRGB Levels Warm White Fluor",
        )),
        // WB_GRGBLevelsLivingRoomWarmWhiteFluor
        0x2311 if data_len >= 8 => Some(decode_wb_grgb(
            val_data,
            "WB_GRGBLevelsLivingRoomWarmWhiteFluor",
            "WB GRGB Levels Living Room Warm White Fluor",
        )),
        // WB_GRGBLevelsTungsten
        0x2400 if data_len >= 8 => Some(decode_wb_grgb(
            val_data,
            "WB_GRGBLevelsTungsten",
            "WB GRGB Levels Tungsten",
        )),
        // WB_GRGBLevelsFlash (FujiFilm.pm:1416)
        0x2410 if data_len >= 8 => Some(decode_wb_grgb(
            val_data,
            "WB_GRGBLevelsFlash",
            "WB GRGB Levels Flash",
        )),
        // WB_GRGBLevels
        0x2ff0 if data_len >= 8 => {
            Some(decode_wb_grgb(val_data, "WB_GRGBLevels", "WB GRGB Levels"))
        }
        // RelativeExposure: rational32s = int16s numerator + int16s denominator (4 bytes total)
        // ValueConv: log($val) / log(2); PrintConv: sprintf("%+.1f",$val) or 0
        0x9200 if data_len >= 4 => {
            let n = i16::from_be_bytes([val_data[0], val_data[1]]) as f64;
            let d = i16::from_be_bytes([val_data[2], val_data[3]]) as f64;
            if d != 0.0 {
                let ratio = n / d;
                let value = if ratio > 0.0 {
                    ratio.ln() / 2.0_f64.ln()
                } else if ratio == 0.0 {
                    0.0
                } else {
                    return None;
                };
                let print = if value == 0.0 {
                    "0".to_string()
                } else {
                    format!("{:+.1}", value)
                };
                Some(mk_loc(
                    "RelativeExposure",
                    "Relative Exposure",
                    Value::F64(value),
                    print,
                ))
            } else {
                None
            }
        }
        // RawExposureBias: rational32s = int16s/int16s (4 bytes)
        // PrintConv: sprintf("%+.1f",$val) or 0
        0x9650 if data_len >= 4 => {
            let n = i16::from_be_bytes([val_data[0], val_data[1]]) as f64;
            let d = i16::from_be_bytes([val_data[2], val_data[3]]) as f64;
            if d != 0.0 {
                let value = n / d;
                let print = if value == 0.0 {
                    "0".to_string()
                } else {
                    format!("{:+.1}", value)
                };
                Some(mk_loc(
                    "RawExposureBias",
                    "Raw Exposure Bias",
                    Value::F64(value),
                    print,
                ))
            } else {
                None
            }
        }
        _ => None, // Unknown or unhandled tag
    }
}

/// Decode a WB_GRGB tag from int16u[4] (big-endian).
/// Only takes the first 4 u16 values (G, R, G, B).
fn decode_wb_grgb(val_data: &[u8], name: &str, description: &str) -> Tag {
    let g1 = u16::from_be_bytes([val_data[0], val_data[1]]);
    let r = u16::from_be_bytes([val_data[2], val_data[3]]);
    let g2 = u16::from_be_bytes([val_data[4], val_data[5]]);
    let b = u16::from_be_bytes([val_data[6], val_data[7]]);
    let s = format!("{} {} {} {}", g1, r, g2, b);
    mk_loc(name, description, Value::String(s.clone()), s)
}

fn mk(name: &str, description: &str, value: Value) -> Tag {
    let pv = value.to_display_string();
    Tag {
        id: TagId::Text(name.to_string()),
        name: name.to_string(),
        description: description.to_string(),
        group: TagGroup {
            family0: "RAF".into(),
            family1: "RAF".into(),
            family2: "Camera".into(),
            family3: "Main".into(),
        },
        raw_value: value,
        print_value: pv,
        priority: 0,
    }
}

fn mk_loc(name: &str, description: &str, value: Value, print: String) -> Tag {
    Tag {
        id: TagId::Text(name.to_string()),
        name: name.to_string(),
        description: description.to_string(),
        group: TagGroup {
            family0: "RAF".into(),
            family1: "RAF".into(),
            family2: "Camera".into(),
            family3: "Main".into(),
        },
        raw_value: value,
        print_value: print,
        priority: 0,
    }
}