File size: 4,127 Bytes
2409829 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 |
use crate::tiff::file::{Endian, TiffRead};
use crate::tiff::tags::{BitsPerSample, CfaPattern, CfaPatternDim, Compression, ImageLength, ImageWidth, SonyToneCurve, StripByteCounts, StripOffsets, Tag, WhiteBalanceRggbLevels};
use crate::tiff::values::CurveLookupTable;
use crate::tiff::{Ifd, TiffError};
use crate::{RawImage, SubtractBlack, Transform};
use rawkit_proc_macros::Tag;
use std::io::{Read, Seek};
#[allow(dead_code)]
#[derive(Tag)]
struct Arw2Ifd {
image_width: ImageWidth,
image_height: ImageLength,
bits_per_sample: BitsPerSample,
compression: Compression,
cfa_pattern: CfaPattern,
cfa_pattern_dim: CfaPatternDim,
strip_offsets: StripOffsets,
strip_byte_counts: StripByteCounts,
sony_tone_curve: SonyToneCurve,
white_balance_levels: Option<WhiteBalanceRggbLevels>,
}
pub fn decode<R: Read + Seek>(ifd: Ifd, file: &mut TiffRead<R>) -> RawImage {
let ifd = ifd.get_value::<Arw2Ifd, _>(file).unwrap();
assert!(ifd.strip_offsets.len() == ifd.strip_byte_counts.len());
assert!(ifd.strip_offsets.len() == 1);
assert!(ifd.compression == 32767);
let image_width: usize = ifd.image_width.try_into().unwrap();
let image_height: usize = ifd.image_height.try_into().unwrap();
let bits_per_sample: usize = ifd.bits_per_sample.into();
assert!(bits_per_sample == 12);
let [cfa_pattern_width, cfa_pattern_height] = ifd.cfa_pattern_dim;
assert!(cfa_pattern_width == 2 && cfa_pattern_height == 2);
file.seek_from_start(ifd.strip_offsets[0]).unwrap();
let mut image = sony_arw2_load_raw(image_width, image_height, ifd.sony_tone_curve, file).unwrap();
// Converting the bps from 12 to 14 so that ARW 2.3.1 and 2.3.5 have the same 14 bps.
image.iter_mut().for_each(|x| *x <<= 2);
RawImage {
data: image,
width: image_width,
height: image_height,
cfa_pattern: ifd.cfa_pattern.try_into().unwrap(),
maximum: (1 << 14) - 1,
black: SubtractBlack::CfaGrid([512, 512, 512, 512]), // TODO: Find the correct way to do this
transform: Transform::Horizontal,
camera_model: None,
camera_white_balance: ifd.white_balance_levels.map(|arr| arr.map(|x| x as f64)),
white_balance: None,
camera_to_rgb: None,
}
}
fn as_u32(buffer: &[u8], endian: Endian) -> Option<u32> {
Some(match endian {
Endian::Little => u32::from_le_bytes(buffer.try_into().ok()?),
Endian::Big => u32::from_be_bytes(buffer.try_into().ok()?),
})
}
fn as_u16(buffer: &[u8], endian: Endian) -> Option<u16> {
Some(match endian {
Endian::Little => u16::from_le_bytes(buffer.try_into().ok()?),
Endian::Big => u16::from_be_bytes(buffer.try_into().ok()?),
})
}
fn sony_arw2_load_raw<R: Read + Seek>(width: usize, height: usize, curve: CurveLookupTable, file: &mut TiffRead<R>) -> Option<Vec<u16>> {
let mut image = vec![0_u16; height * width];
let mut data = vec![0_u8; width + 1];
for row in 0..height {
file.read_exact(&mut data[0..width]).unwrap();
let mut column = 0;
let mut data_index = 0;
while column < width - 30 {
let data_value = as_u32(&data[data_index..][..4], file.endian()).unwrap();
let max = (0x7ff & data_value) as u16;
let min = (0x7ff & data_value >> 11) as u16;
let index_to_set_max = 0x0f & data_value >> 22;
let index_to_set_min = 0x0f & data_value >> 26;
let max_minus_min = max as i32 - min as i32;
let shift_by_bits = (0..4).find(|&shift| (0x80 << shift) > max_minus_min).unwrap_or(4);
let mut pixels = [0_u16; 16];
let mut bit = 30;
for (i, pixel) in pixels.iter_mut().enumerate() {
*pixel = match () {
_ if i as u32 == index_to_set_max => max,
_ if i as u32 == index_to_set_min => min,
_ => {
let result = as_u16(&data[(data_index + (bit >> 3))..][..2], file.endian()).unwrap();
let result = ((result >> (bit & 7)) & 0x07f) << shift_by_bits;
bit += 7;
(result + min).min(0x7ff)
}
};
}
for value in pixels {
image[row * width + column] = curve.get((value << 1).into()) >> 2;
// Skip between interlaced columns
column += 2;
}
// Switch to the opposite interlaced columns
column -= if column & 1 == 0 { 31 } else { 1 };
data_index += 16;
}
}
Some(image)
}
|