| /* |
| * Copyright 2026 Google LLC |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "rust/exif/FFI.h" |
| #include "rust/exif/FFI.rs.h" |
| #include "include/codec/SkEncodedOrigin.h" |
| #include "include/private/SkExif.h" |
| #include "tests/Test.h" |
| #include "tools/Resources.h" |
| |
| #include <cmath> |
| |
| // Helpers: build minimal EXIF blobs (big- and little-endian) for unit tests. |
| |
| // Writes a 2-byte big-endian u16 into `buf` at `off`. |
| static void write_u16_be(std::vector<uint8_t>& buf, size_t off, uint16_t v) { |
| buf[off] = static_cast<uint8_t>(v >> 8); |
| buf[off + 1] = static_cast<uint8_t>(v); |
| } |
| |
| // Writes a 4-byte big-endian u32 into `buf` at `off`. |
| static void write_u32_be(std::vector<uint8_t>& buf, size_t off, uint32_t v) { |
| buf[off] = static_cast<uint8_t>(v >> 24); |
| buf[off + 1] = static_cast<uint8_t>(v >> 16); |
| buf[off + 2] = static_cast<uint8_t>(v >> 8); |
| buf[off + 3] = static_cast<uint8_t>(v); |
| } |
| |
| // Writes a 2-byte little-endian u16 into `buf` at `off`. |
| static void write_u16_le(std::vector<uint8_t>& buf, size_t off, uint16_t v) { |
| buf[off] = static_cast<uint8_t>(v); |
| buf[off + 1] = static_cast<uint8_t>(v >> 8); |
| } |
| |
| // Writes a 4-byte little-endian u32 into `buf` at `off`. |
| static void write_u32_le(std::vector<uint8_t>& buf, size_t off, uint32_t v) { |
| buf[off] = static_cast<uint8_t>(v); |
| buf[off + 1] = static_cast<uint8_t>(v >> 8); |
| buf[off + 2] = static_cast<uint8_t>(v >> 16); |
| buf[off + 3] = static_cast<uint8_t>(v >> 24); |
| } |
| |
| // Returns a TIFF header (8 bytes, big-endian) pointing to IFD at `ifd_offset`. |
| static std::vector<uint8_t> tiff_header_be(uint32_t ifd_offset = 8) { |
| return {'M', 'M', 0x00, 0x2a, |
| static_cast<uint8_t>(ifd_offset >> 24), |
| static_cast<uint8_t>(ifd_offset >> 16), |
| static_cast<uint8_t>(ifd_offset >> 8), |
| static_cast<uint8_t>(ifd_offset)}; |
| } |
| |
| // Returns a TIFF header (8 bytes, little-endian) pointing to IFD at `ifd_offset`. |
| static std::vector<uint8_t> tiff_header_le(uint32_t ifd_offset = 8) { |
| return {'I', 'I', 0x2a, 0x00, |
| static_cast<uint8_t>(ifd_offset), |
| static_cast<uint8_t>(ifd_offset >> 8), |
| static_cast<uint8_t>(ifd_offset >> 16), |
| static_cast<uint8_t>(ifd_offset >> 24)}; |
| } |
| |
| // Builds a single-IFD little-endian EXIF blob containing only an Orientation tag. |
| static std::vector<uint8_t> make_orientation_exif_le(uint16_t orientation) { |
| std::vector<uint8_t> buf(26, 0); |
| auto hdr = tiff_header_le(8); |
| std::copy(hdr.begin(), hdr.end(), buf.begin()); |
| write_u16_le(buf, 8, 1); // IFD entry count = 1 |
| write_u16_le(buf, 10, 0x0112); // tag: Orientation |
| write_u16_le(buf, 12, 3); // type: SHORT |
| write_u32_le(buf, 14, 1); // count |
| write_u16_le(buf, 18, orientation); // value |
| write_u32_le(buf, 22, 0); // next IFD offset |
| return buf; |
| } |
| |
| // Builds a single-IFD EXIF blob containing only a SHORT Orientation tag. |
| static std::vector<uint8_t> make_orientation_exif_be(uint16_t orientation) { |
| // Header (8) + entry count (2) + 1 entry (12) + next IFD offset (4) = 26 bytes |
| std::vector<uint8_t> buf(26, 0); |
| // TIFF header pointing to IFD at offset 8. |
| auto hdr = tiff_header_be(8); |
| std::copy(hdr.begin(), hdr.end(), buf.begin()); |
| // IFD entry count = 1. |
| write_u16_be(buf, 8, 1); |
| // Entry: tag=0x0112 (Orientation), type=3 (SHORT), count=1, value=orientation. |
| write_u16_be(buf, 10, 0x0112); // tag |
| write_u16_be(buf, 12, 3); // type SHORT |
| write_u32_be(buf, 14, 1); // count |
| write_u16_be(buf, 18, orientation); // value (fits in 4 bytes inline, BE) |
| // next IFD = 0 (no more IFDs). |
| write_u32_be(buf, 22, 0); |
| return buf; |
| } |
| |
| // Builds a single-IFD EXIF blob with XResolution, YResolution, ResolutionUnit. |
| static std::vector<uint8_t> make_resolution_exif_be(float xres, float yres, uint16_t unit) { |
| // The RATIONAL values (8 bytes each) are stored after the IFD. |
| // Header=8, count=2, entries=3×12=36, next_ifd=4 → data at offset 52. |
| // XResolution → RATIONAL at offset 52, YResolution at 60. |
| const uint32_t xres_off = 52, yres_off = 60; |
| std::vector<uint8_t> buf(68, 0); |
| |
| auto hdr = tiff_header_be(8); |
| std::copy(hdr.begin(), hdr.end(), buf.begin()); |
| write_u16_be(buf, 8, 3); // 3 entries |
| |
| // Entry 0: ResolutionUnit (tag 0x0128, SHORT, 1, unit) |
| write_u16_be(buf, 10, 0x0128); |
| write_u16_be(buf, 12, 3); // SHORT |
| write_u32_be(buf, 14, 1); |
| write_u16_be(buf, 18, unit); |
| |
| // Entry 1: XResolution (tag 0x011a, RATIONAL, 1, offset) |
| write_u16_be(buf, 22, 0x011a); |
| write_u16_be(buf, 24, 5); // RATIONAL |
| write_u32_be(buf, 26, 1); |
| write_u32_be(buf, 30, xres_off); |
| |
| // Entry 2: YResolution (tag 0x011b, RATIONAL, 1, offset) |
| write_u16_be(buf, 34, 0x011b); |
| write_u16_be(buf, 36, 5); // RATIONAL |
| write_u32_be(buf, 38, 1); |
| write_u32_be(buf, 42, yres_off); |
| |
| // next IFD offset = 0 |
| write_u32_be(buf, 46, 0); |
| |
| // XResolution rational: (xres * 1000) / 1000 → numerator/denominator |
| auto xnum = static_cast<uint32_t>(xres * 1000.0f + 0.5f); |
| write_u32_be(buf, xres_off, xnum); |
| write_u32_be(buf, xres_off + 4, 1000); |
| |
| auto ynum = static_cast<uint32_t>(yres * 1000.0f + 0.5f); |
| write_u32_be(buf, yres_off, ynum); |
| write_u32_be(buf, yres_off + 4, 1000); |
| |
| return buf; |
| } |
| |
| // Unit tests: parse_exif() + ToSkExifMetadata() on synthetic EXIF data. |
| |
| DEF_TEST(RustExif_empty_data_returns_false, r) { |
| rust_exif::ExifMetadata meta; |
| bool ok = rust_exif::parse_exif(rust::Slice<const uint8_t>(nullptr, 0), meta); |
| REPORTER_ASSERT(r, !ok); |
| } |
| |
| DEF_TEST(RustExif_invalid_data_returns_false, r) { |
| rust_exif::ExifMetadata meta; |
| const uint8_t garbage[] = {'n', 'o', 't', ' ', 'e', 'x', 'i', 'f'}; |
| bool ok = rust_exif::parse_exif( |
| rust::Slice<const uint8_t>(garbage, sizeof(garbage)), meta); |
| REPORTER_ASSERT(r, !ok); |
| } |
| |
| DEF_TEST(RustExif_orientation_parsing, r) { |
| for (uint16_t orient = 1; orient <= 8; ++orient) { |
| auto blob = make_orientation_exif_be(orient); |
| rust_exif::ExifMetadata meta; |
| bool ok = rust_exif::parse_exif( |
| rust::Slice<const uint8_t>(blob.data(), blob.size()), meta); |
| REPORTER_ASSERT(r, ok); |
| REPORTER_ASSERT(r, meta.has_origin); |
| REPORTER_ASSERT(r, meta.origin == static_cast<uint32_t>(orient)); |
| |
| // Verify ToSkExifMetadata maps it to the right SkEncodedOrigin. |
| SkExif::Metadata sk_meta; |
| rust_exif::ToSkExifMetadata(meta, &sk_meta); |
| REPORTER_ASSERT(r, sk_meta.fOrigin.has_value()); |
| REPORTER_ASSERT(r, sk_meta.fOrigin.value() == static_cast<SkEncodedOrigin>(orient)); |
| } |
| } |
| |
| DEF_TEST(RustExif_orientation_out_of_range_ignored, r) { |
| // Orientation value 0 is invalid (EXIF spec says 1-8). |
| auto blob = make_orientation_exif_be(0); |
| rust_exif::ExifMetadata meta; |
| rust_exif::parse_exif(rust::Slice<const uint8_t>(blob.data(), blob.size()), meta); |
| REPORTER_ASSERT(r, !meta.has_origin); |
| |
| // Orientation value 9 is out of range. |
| blob = make_orientation_exif_be(9); |
| rust_exif::parse_exif(rust::Slice<const uint8_t>(blob.data(), blob.size()), meta); |
| REPORTER_ASSERT(r, !meta.has_origin); |
| } |
| |
| DEF_TEST(RustExif_little_endian_parsing, r) { |
| // EXIF supports both big-endian ('M','M') and little-endian ('I','I') byte order. |
| // Verify little-endian blobs are parsed correctly. |
| for (uint16_t orient = 1; orient <= 8; ++orient) { |
| auto blob = make_orientation_exif_le(orient); |
| rust_exif::ExifMetadata meta; |
| bool ok = rust_exif::parse_exif( |
| rust::Slice<const uint8_t>(blob.data(), blob.size()), meta); |
| REPORTER_ASSERT(r, ok); |
| REPORTER_ASSERT(r, meta.has_origin); |
| REPORTER_ASSERT(r, meta.origin == static_cast<uint32_t>(orient)); |
| } |
| } |
| |
| DEF_TEST(RustExif_resolution_parsing, r) { |
| constexpr float kEpsilon = 0.0001f; |
| auto blob = make_resolution_exif_be(72.0f, 72.0f, 2 /*inch*/); |
| rust_exif::ExifMetadata meta; |
| bool ok = rust_exif::parse_exif( |
| rust::Slice<const uint8_t>(blob.data(), blob.size()), meta); |
| REPORTER_ASSERT(r, ok); |
| REPORTER_ASSERT(r, meta.has_resolution_unit); |
| REPORTER_ASSERT(r, meta.resolution_unit == 2); |
| REPORTER_ASSERT(r, meta.has_x_resolution); |
| REPORTER_ASSERT(r, std::abs(meta.x_resolution - 72.0f) < kEpsilon); |
| REPORTER_ASSERT(r, meta.has_y_resolution); |
| REPORTER_ASSERT(r, std::abs(meta.y_resolution - 72.0f) < kEpsilon); |
| |
| // Verify ToSkExifMetadata conversion. |
| SkExif::Metadata sk_meta; |
| rust_exif::ToSkExifMetadata(meta, &sk_meta); |
| REPORTER_ASSERT(r, sk_meta.fResolutionUnit.has_value()); |
| REPORTER_ASSERT(r, sk_meta.fResolutionUnit.value() == 2); |
| REPORTER_ASSERT(r, sk_meta.fXResolution.has_value()); |
| REPORTER_ASSERT(r, std::abs(sk_meta.fXResolution.value() - 72.0f) < kEpsilon); |
| REPORTER_ASSERT(r, sk_meta.fYResolution.has_value()); |
| REPORTER_ASSERT(r, std::abs(sk_meta.fYResolution.value() - 72.0f) < kEpsilon); |
| } |
| |
| // Builds a single-IFD EXIF blob with PixelXDimension and PixelYDimension tags. |
| static std::vector<uint8_t> make_pixel_dimensions_exif_be(uint16_t width, uint16_t height) { |
| // Header=8, count=2, entries=2×12=24, next_ifd=4 → 38 bytes. |
| std::vector<uint8_t> buf(38, 0); |
| auto hdr = tiff_header_be(8); |
| std::copy(hdr.begin(), hdr.end(), buf.begin()); |
| write_u16_be(buf, 8, 2); // 2 entries |
| |
| // Entry 0: PixelXDimension (tag 0xa002, SHORT, 1, width) |
| write_u16_be(buf, 10, 0xa002); |
| write_u16_be(buf, 12, 3); // SHORT |
| write_u32_be(buf, 14, 1); |
| write_u16_be(buf, 18, width); |
| |
| // Entry 1: PixelYDimension (tag 0xa003, SHORT, 1, height) |
| write_u16_be(buf, 22, 0xa003); |
| write_u16_be(buf, 24, 3); // SHORT |
| write_u32_be(buf, 26, 1); |
| write_u16_be(buf, 30, height); |
| |
| // next IFD = 0 |
| write_u32_be(buf, 34, 0); |
| return buf; |
| } |
| |
| DEF_TEST(RustExif_pixel_dimensions_parsing, r) { |
| auto blob = make_pixel_dimensions_exif_be(1920, 1080); |
| rust_exif::ExifMetadata meta; |
| bool ok = rust_exif::parse_exif( |
| rust::Slice<const uint8_t>(blob.data(), blob.size()), meta); |
| REPORTER_ASSERT(r, ok); |
| REPORTER_ASSERT(r, meta.has_pixel_x_dimension); |
| REPORTER_ASSERT(r, meta.pixel_x_dimension == 1920u); |
| REPORTER_ASSERT(r, meta.has_pixel_y_dimension); |
| REPORTER_ASSERT(r, meta.pixel_y_dimension == 1080u); |
| |
| SkExif::Metadata sk_meta; |
| rust_exif::ToSkExifMetadata(meta, &sk_meta); |
| REPORTER_ASSERT(r, sk_meta.fPixelXDimension.has_value()); |
| REPORTER_ASSERT(r, sk_meta.fPixelXDimension.value() == 1920u); |
| REPORTER_ASSERT(r, sk_meta.fPixelYDimension.has_value()); |
| REPORTER_ASSERT(r, sk_meta.fPixelYDimension.value() == 1080u); |
| } |
| |
| // Equivalence tests: compare Rust parser against SkExif::Parse on real files. |
| |
| static bool approx_eq_f(float a, float b, float eps) { |
| return std::abs(a - b) < eps; |
| } |
| |
| // Compares a Rust-parsed ExifMetadata (converted to SkExif::Metadata) against |
| // the reference C++ SkExif::Parse result for the given resource EXIF file. |
| static void check_equivalence(skiatest::Reporter* r, const char* resource_path) { |
| sk_sp<SkData> data = GetResourceAsData(resource_path); |
| if (!data) { |
| INFOF(r, "Skipping equivalence test for %s: resource not available.", resource_path); |
| return; |
| } |
| |
| // C++ reference parse. |
| SkExif::Metadata cpp_meta; |
| SkExif::Parse(cpp_meta, data.get()); |
| |
| // Rust parse + conversion. |
| rust_exif::ExifMetadata rust_raw; |
| bool rust_ok = rust_exif::parse_exif( |
| rust::Slice<const uint8_t>( |
| reinterpret_cast<const uint8_t*>(data->data()), data->size()), |
| rust_raw); |
| SkExif::Metadata rust_meta; |
| if (rust_ok) { |
| rust_exif::ToSkExifMetadata(rust_raw, &rust_meta); |
| } |
| |
| constexpr float kEpsilon = 0.0001f; |
| |
| // fOrigin |
| REPORTER_ASSERT(r, |
| cpp_meta.fOrigin.has_value() == rust_meta.fOrigin.has_value(), |
| "[%s] fOrigin presence mismatch", resource_path); |
| if (cpp_meta.fOrigin.has_value() && rust_meta.fOrigin.has_value()) { |
| REPORTER_ASSERT(r, |
| cpp_meta.fOrigin.value() == rust_meta.fOrigin.value(), |
| "[%s] fOrigin value mismatch: cpp=%d rust=%d", |
| resource_path, |
| static_cast<int>(cpp_meta.fOrigin.value()), |
| static_cast<int>(rust_meta.fOrigin.value())); |
| } |
| |
| // fHdrHeadroom |
| REPORTER_ASSERT(r, |
| cpp_meta.fHdrHeadroom.has_value() == rust_meta.fHdrHeadroom.has_value(), |
| "[%s] fHdrHeadroom presence mismatch", resource_path); |
| if (cpp_meta.fHdrHeadroom.has_value() && rust_meta.fHdrHeadroom.has_value()) { |
| REPORTER_ASSERT(r, |
| approx_eq_f(cpp_meta.fHdrHeadroom.value(), |
| rust_meta.fHdrHeadroom.value(), |
| kEpsilon), |
| "[%s] fHdrHeadroom value mismatch: cpp=%f rust=%f", |
| resource_path, |
| cpp_meta.fHdrHeadroom.value(), |
| rust_meta.fHdrHeadroom.value()); |
| } |
| |
| // fResolutionUnit |
| REPORTER_ASSERT(r, |
| cpp_meta.fResolutionUnit.has_value() == rust_meta.fResolutionUnit.has_value(), |
| "[%s] fResolutionUnit presence mismatch", resource_path); |
| if (cpp_meta.fResolutionUnit.has_value() && rust_meta.fResolutionUnit.has_value()) { |
| REPORTER_ASSERT(r, |
| cpp_meta.fResolutionUnit.value() == rust_meta.fResolutionUnit.value(), |
| "[%s] fResolutionUnit value mismatch: cpp=%d rust=%d", |
| resource_path, |
| cpp_meta.fResolutionUnit.value(), |
| rust_meta.fResolutionUnit.value()); |
| } |
| |
| // fXResolution |
| REPORTER_ASSERT(r, |
| cpp_meta.fXResolution.has_value() == rust_meta.fXResolution.has_value(), |
| "[%s] fXResolution presence mismatch", resource_path); |
| if (cpp_meta.fXResolution.has_value() && rust_meta.fXResolution.has_value()) { |
| REPORTER_ASSERT(r, |
| approx_eq_f(cpp_meta.fXResolution.value(), |
| rust_meta.fXResolution.value(), |
| kEpsilon), |
| "[%s] fXResolution value mismatch: cpp=%f rust=%f", |
| resource_path, |
| cpp_meta.fXResolution.value(), |
| rust_meta.fXResolution.value()); |
| } |
| |
| // fYResolution |
| REPORTER_ASSERT(r, |
| cpp_meta.fYResolution.has_value() == rust_meta.fYResolution.has_value(), |
| "[%s] fYResolution presence mismatch", resource_path); |
| if (cpp_meta.fYResolution.has_value() && rust_meta.fYResolution.has_value()) { |
| REPORTER_ASSERT(r, |
| approx_eq_f(cpp_meta.fYResolution.value(), |
| rust_meta.fYResolution.value(), |
| kEpsilon), |
| "[%s] fYResolution value mismatch: cpp=%f rust=%f", |
| resource_path, |
| cpp_meta.fYResolution.value(), |
| rust_meta.fYResolution.value()); |
| } |
| |
| // fPixelXDimension |
| REPORTER_ASSERT(r, |
| cpp_meta.fPixelXDimension.has_value() == |
| rust_meta.fPixelXDimension.has_value(), |
| "[%s] fPixelXDimension presence mismatch", resource_path); |
| if (cpp_meta.fPixelXDimension.has_value() && rust_meta.fPixelXDimension.has_value()) { |
| REPORTER_ASSERT(r, |
| cpp_meta.fPixelXDimension.value() == |
| rust_meta.fPixelXDimension.value(), |
| "[%s] fPixelXDimension value mismatch: cpp=%u rust=%u", |
| resource_path, |
| cpp_meta.fPixelXDimension.value(), |
| rust_meta.fPixelXDimension.value()); |
| } |
| |
| // fPixelYDimension |
| REPORTER_ASSERT(r, |
| cpp_meta.fPixelYDimension.has_value() == |
| rust_meta.fPixelYDimension.has_value(), |
| "[%s] fPixelYDimension presence mismatch", resource_path); |
| if (cpp_meta.fPixelYDimension.has_value() && rust_meta.fPixelYDimension.has_value()) { |
| REPORTER_ASSERT(r, |
| cpp_meta.fPixelYDimension.value() == |
| rust_meta.fPixelYDimension.value(), |
| "[%s] fPixelYDimension value mismatch: cpp=%u rust=%u", |
| resource_path, |
| cpp_meta.fPixelYDimension.value(), |
| rust_meta.fPixelYDimension.value()); |
| } |
| } |
| |
| DEF_TEST(RustExif_equivalence_with_resource_files, r) { |
| // Test against the same EXIF files used in ExifTest.cpp. |
| check_equivalence(r, "images/test0-hdr.exif"); |
| check_equivalence(r, "images/test1-pixel32.exif"); |
| check_equivalence(r, "images/test2-nonuniform.exif"); |
| check_equivalence(r, "images/test3-little-endian.exif"); |
| } |
