use super::*;
use crate::trap::TrapDispatcher;
use image::ImageEncoder;
#[test]
fn indexed_quicktime_preserves_source_colors_on_direct_destinations() {
let rle = [0, 0, 0, 13, 0, 0, 1, 1, 1, 1, 1, 1, 0xff];
let smc = [0, 0, 0, 6, 0x60, 1];
for (codec, compressed, height) in [(b"rle ", &rle[..], 1), (b"smc ", &smc[..], 4)] {
for depth in [8, 16, 32] {
let mut bus = MacMemoryBus::new(1024 * 1024);
let pos = 0x1000;
let description_size = 110;
bus.write_long(pos, 68 + description_size + compressed.len() as u32);
bus.write_word(pos + 4 + 52 + 4, height);
bus.write_word(pos + 4 + 52 + 6, 4);
let desc = pos + 4 + 68;
bus.write_long(desc, description_size);
bus.write_long(desc + 4, u32::from_be_bytes(*codec));
bus.write_word(desc + 32, 4);
bus.write_word(desc + 34, height);
bus.write_long(desc + 44, compressed.len() as u32);
bus.write_word(desc + 82, 8);
bus.write_word(desc + 92, 1); bus.write_word(desc + 102, 1);
bus.write_word(desc + 104, 0x1234);
bus.write_word(desc + 106, 0x5678);
bus.write_word(desc + 108, 0x9abc);
for (index, byte) in compressed.iter().enumerate() {
bus.write_byte(desc + description_size + index as u32, *byte);
}
let clut = TrapDispatcher::standard_mac_8bpp_clut();
let rb = 4 * u32::from(depth) / 8;
let clip = DstClip::new((0, 0, 1, 1), vec![]);
let clipped_pixel = 0x2000 + u32::from(depth) / 8;
bus.write_long(clipped_pixel, 0xdeadbeef);
parse_compressed_quicktime(
&mut bus,
pos,
0,
0,
0,
0,
1.0,
1.0,
(0x2000, rb, 4, height, depth),
&clut,
None,
Some(&clip),
);
match depth {
8 => assert_eq!(
bus.read_byte(0x2000),
closest_clut_index(0x1234, 0x5678, 0x9abc, &clut)
),
16 => assert_eq!(
bus.read_word(0x2000),
(0x1234 >> 11) << 10 | (0x5678 >> 11) << 5 | (0x9abcu16 >> 11)
),
32 => assert_eq!(bus.read_long(0x2000), 0x0012569a),
_ => unreachable!(),
}
assert_eq!(bus.read_long(clipped_pixel), 0xdeadbeef);
}
}
}
fn png_record(bus: &mut MacMemoryBus, damaged: bool) -> (u32, u32) {
let mut png = Vec::new();
image::codecs::png::PngEncoder::new(&mut png)
.write_image(
&[255, 0, 0, 0, 255, 0],
2,
1,
image::ExtendedColorType::Rgb8,
)
.unwrap();
if damaged {
png.fill(0);
}
let pos = 0x1000;
let payload = 68 + 86 + png.len() as u32;
bus.write_long(pos, payload);
bus.write_word(pos + 4 + 52 + 4, 1); bus.write_word(pos + 4 + 52 + 6, 2); let desc = pos + 4 + 68;
bus.write_long(desc, 86);
bus.write_long(desc + 4, u32::from_be_bytes(*b"png "));
bus.write_word(desc + 32, 2);
bus.write_word(desc + 34, 1);
bus.write_long(desc + 44, png.len() as u32);
bus.write_word(desc + 82, 24);
for (i, byte) in png.iter().enumerate() {
bus.write_byte(desc + 86 + i as u32, *byte);
}
let end = align_pict_pos(pos + 4 + payload);
bus.write_long(end, 0x0007_00AE);
bus.write_word(end + 4, 4);
(pos, end)
}
#[test]
fn quicktime_png_draws_direct_and_indexed_colours_and_suppresses_fallback() {
for depth in [8, 16, 32] {
let mut bus = MacMemoryBus::new(1024 * 1024);
let (pos, end) = png_record(&mut bus, false);
let base = 0x2000;
let clut = TrapDispatcher::standard_mac_8bpp_clut();
let rb = 4 * u32::from(depth) / 8;
let (next, palette) = parse_compressed_quicktime(
&mut bus,
pos,
0,
1,
0,
0,
1.0,
1.0,
(base, rb, 4, 2, depth),
&clut,
None,
None,
);
assert_eq!(next, end + 10);
assert!(palette.is_none());
match depth {
32 => {
assert_eq!(bus.read_long(base + 4), 0xFF0000);
assert_eq!(bus.read_long(base + 8), 0x00FF00);
}
16 => {
assert_eq!(bus.read_word(base + 2), 0x7C00);
assert_eq!(bus.read_word(base + 4), 0x03E0);
}
_ => {
assert_eq!(
bus.read_byte(base + 1),
closest_clut_index(65535, 0, 0, &clut)
);
assert_eq!(
bus.read_byte(base + 2),
closest_clut_index(0, 65535, 0, &clut)
);
}
}
assert_eq!(bus.read_byte(base), 0);
assert_eq!(bus.read_long(base + rb), 0);
}
}
#[test]
fn damaged_quicktime_png_preserves_destination_and_warning() {
let mut bus = MacMemoryBus::new(1024 * 1024);
let (pos, end) = png_record(&mut bus, true);
bus.write_long(0x2000, 0x12345678);
let (next, palette) = parse_compressed_quicktime(
&mut bus,
pos,
0,
0,
0,
0,
1.0,
1.0,
(0x2000, 16, 4, 2, 32),
&[[0; 3]; 256],
None,
None,
);
assert_eq!(next, end);
assert!(palette.is_none());
assert_eq!(bus.read_long(0x2000), 0x12345678);
}
#[test]
fn quicktime_png_obeys_source_crop_and_destination_clip() {
for crop_source in [false, true] {
let mut bus = MacMemoryBus::new(1024 * 1024);
let (pos, _) = png_record(&mut bus, false);
if crop_source {
bus.write_word(pos + 4 + 52 + 2, 1); }
bus.write_long(0x2000, 0x00112233);
bus.write_long(0x2004, 0x00445566);
let clip = DstClip::new((0, 1, 1, 2), vec![]);
parse_compressed_quicktime(
&mut bus,
pos,
0,
0,
0,
0,
1.0,
1.0,
(0x2000, 16, 4, 2, 32),
&[[0; 3]; 256],
None,
if crop_source { None } else { Some(&clip) },
);
assert_eq!(bus.read_long(0x2000), 0x00112233);
assert_eq!(bus.read_long(0x2004), 0x0000FF00);
}
}
#[test]
fn quicktime_matrix_translation_positions_pixels_in_picture_space() {
for depth in [8, 16, 32] {
let mut bus = MacMemoryBus::new(1024 * 1024);
let (pos, _) = png_record(&mut bus, false);
bus.write_long(pos + 4 + 2 + 24, 1 << 16);
bus.write_long(pos + 4 + 2 + 28, 1 << 16);
let base = 0x2000;
let rb = 4 * u32::from(depth) / 8;
let clut = TrapDispatcher::standard_mac_8bpp_clut();
parse_compressed_quicktime(
&mut bus, pos, 0, 0, 0, 0, 1.0, 1.0,
(base, rb, 4, 3, depth), &clut, None, None,
);
let red = base + rb + u32::from(depth) / 8;
let green = red + u32::from(depth) / 8;
match depth {
8 => {
assert_eq!(bus.read_byte(red), closest_clut_index(65535, 0, 0, &clut));
assert_eq!(bus.read_byte(green), closest_clut_index(0, 65535, 0, &clut));
}
16 => {
assert_eq!(bus.read_word(red), 0x7c00);
assert_eq!(bus.read_word(green), 0x03e0);
}
32 => {
assert_eq!(bus.read_long(red), 0x00ff0000);
assert_eq!(bus.read_long(green), 0x0000ff00);
}
_ => unreachable!(),
}
assert_eq!(bus.read_long(base), 0);
}
}
#[test]
fn quicktime_translation_precedes_picture_clip_and_destination_mapping() {
let mut bus = MacMemoryBus::new(1024 * 1024);
let (pos, _) = png_record(&mut bus, false);
bus.write_long(pos + 4 + 2 + 24, (-1i32 << 16) as u32);
bus.write_long(pos + 4 + 2 + 28, 1 << 16);
let picture_clip = PictureRegion { top: 1, left: 0, bottom: 2, right: 1, rows: vec![] };
parse_compressed_quicktime(
&mut bus, pos, 0, 1, 0, 0, 1.0, 1.0,
(0x2000, 16, 4, 3, 32), &[[0; 3]; 256], Some(&picture_clip), None,
);
assert_eq!(bus.read_long(0x2000 + 16), 0);
assert_eq!(bus.read_long(0x2000 + 16 + 4), 0x0000ff00);
}
#[test]
fn quicktime_warning_fingerprint_does_not_skip_other_bitmaps() {
let mut bus = MacMemoryBus::new(1024 * 1024);
let pos = 0x3000;
bus.write_word(pos, 0x0098);
bus.write_word(pos + 2, 10);
bus.write_long(pos + 8, 0x002c_0045);
bus.write_long(pos + 16, 0x002c_0045);
let mut fingerprint = 0xcbf2_9ce4_8422_2325u64;
for row in 0..44 {
let start = pos + 30 + row * 2;
bus.write_byte(start, 1);
bus.write_byte(start + 1, row as u8);
for byte in [1, row as u8] {
fingerprint ^= u64::from(byte);
fingerprint = fingerprint.wrapping_mul(0x100_0000_01b3);
}
}
assert_eq!(skip_quicktime_packbits_warning(&bus, pos, fingerprint), Some(pos + 118));
assert_eq!(skip_quicktime_packbits_warning(&bus, pos, fingerprint ^ 1), None);
bus.write_word(pos + 8, 43);
assert_eq!(skip_quicktime_packbits_warning(&bus, pos, fingerprint), None);
}