| // Copyright 2018 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| #include "camera3_test/camera3_exif_validator.h" |
| |
| #include <algorithm> |
| #include <limits> |
| #include <string> |
| #include <vector> |
| |
| #include <gtest/gtest.h> |
| #include <jpeglib.h> |
| |
| namespace camera3_test { |
| |
| enum { |
| ORIENTATION_UNDEFINED, |
| ORIENTATION_NORMAL, |
| ORIENTATION_FLIP_HORIZONTAL, |
| ORIENTATION_ROTATE_180, |
| ORIENTATION_FLIP_VERTICAL, |
| ORIENTATION_TRANSPOSE, |
| ORIENTATION_ROTATE_90, |
| ORIENTATION_TRANSVERSE, |
| ORIENTATION_ROTATE_270, |
| }; |
| |
| static int32_t GetJpegInfo(uint8_t* data, |
| size_t size, |
| ResolutionInfo* resolution, |
| ExifData** exif_data) { |
| #define JPEG_APP1 (JPEG_APP0 + 1) |
| const unsigned int kMaxMarkerLength = 0xffff; |
| struct jpeg_decompress_struct jpeg_info; |
| struct jpeg_error_mgr jpeg_error; |
| jpeg_info.err = jpeg_std_error(&jpeg_error); |
| jpeg_create_decompress(&jpeg_info); |
| jpeg_mem_src(&jpeg_info, data, size); |
| jpeg_save_markers(&jpeg_info, JPEG_APP1, kMaxMarkerLength); |
| if (jpeg_read_header(&jpeg_info, TRUE) != JPEG_HEADER_OK) { |
| jpeg_destroy_decompress(&jpeg_info); |
| return -EINVAL; |
| } |
| if (resolution) { |
| *resolution = ResolutionInfo(jpeg_info.image_width, jpeg_info.image_height); |
| } |
| if (exif_data) { |
| for (auto marker = jpeg_info.marker_list; marker != nullptr; |
| marker = marker->next) { |
| if (marker->marker == JPEG_APP1) { |
| *exif_data = exif_data_new_from_data(marker->data, marker->data_length); |
| break; |
| } |
| } |
| } |
| jpeg_destroy_decompress(&jpeg_info); |
| return 0; |
| } |
| |
| static int32_t GetExifOrientationInDegree(int32_t exif_orientation) { |
| switch (exif_orientation) { |
| case ORIENTATION_NORMAL: |
| return 0; |
| case ORIENTATION_ROTATE_90: |
| return 90; |
| case ORIENTATION_ROTATE_180: |
| return 180; |
| case ORIENTATION_ROTATE_270: |
| return 270; |
| default: |
| ADD_FAILURE() << "It is impossible to get non 0, 90, 180, 270 degress " |
| "exif info based on the request orientation range"; |
| return 0; |
| } |
| } |
| |
| static int32_t GetExifTagInteger(const ExifData& exif_data, |
| const ExifIfd& ifd, |
| const ExifTag& tag, |
| const ExifByteOrder& byte_order) { |
| ExifEntry* entry = exif_data_get_entry((&exif_data), tag); |
| if (!entry) { |
| ADD_FAILURE() << "Failed to get EXIF tag " |
| << exif_tag_get_name_in_ifd(tag, ifd); |
| return -EINVAL; |
| } |
| switch (entry->format) { |
| case EXIF_FORMAT_SHORT: |
| return exif_get_short(entry->data, byte_order); |
| case EXIF_FORMAT_LONG: |
| return exif_get_long(entry->data, byte_order); |
| case EXIF_FORMAT_SLONG: |
| return exif_get_slong(entry->data, byte_order); |
| default: |
| ADD_FAILURE() << "Invalid EXIF entry format " << entry->format; |
| return -EINVAL; |
| } |
| } |
| |
| static const char* GetExifTagString(const ExifData& exif_data, |
| const ExifIfd& ifd, |
| const ExifTag& tag) { |
| ExifEntry* entry = exif_data_get_entry((&exif_data), tag); |
| if (!entry) { |
| ADD_FAILURE() << "Failed to get EXIF tag " |
| << exif_tag_get_name_in_ifd(tag, ifd); |
| return nullptr; |
| } |
| EXPECT_EQ(EXIF_FORMAT_ASCII, entry->format) |
| << "Invalid EXIF entry string format " << entry->format; |
| return reinterpret_cast<char*>(entry->data); |
| } |
| |
| static float GetExifTagFloat(const ExifData& exif_data, |
| const ExifIfd& ifd, |
| const ExifTag& tag, |
| const ExifByteOrder& byte_order) { |
| ExifEntry* entry = exif_data_get_entry((&exif_data), tag); |
| if (!entry) { |
| ADD_FAILURE() << "Failed to get EXIF tag " |
| << exif_tag_get_name_in_ifd(tag, ifd); |
| return -EINVAL; |
| } |
| switch (entry->format) { |
| case EXIF_FORMAT_RATIONAL: { |
| ExifRational rational = exif_get_rational(entry->data, byte_order); |
| return static_cast<float>(rational.numerator) / |
| static_cast<float>(rational.denominator); |
| } |
| case EXIF_FORMAT_SRATIONAL: { |
| ExifSRational srational = exif_get_srational(entry->data, byte_order); |
| return static_cast<float>(srational.numerator) / |
| static_cast<float>(srational.denominator); |
| } |
| default: |
| ADD_FAILURE() << "Invalid EXIF entry format " << entry->format; |
| return -EINVAL; |
| } |
| } |
| |
| Camera3ExifValidator::JpegExifInfo::JpegExifInfo( |
| const ScopedBufferHandle& buffer, size_t size) |
| : buffer_handle(buffer), |
| buffer_size(size), |
| buffer_addr(nullptr), |
| jpeg_resolution(ResolutionInfo(0, 0)), |
| exif_data(nullptr) { |
| // Get JPEG image address and size |
| if (Camera3TestGralloc::GetInstance()->Lock(*buffer_handle, 0, 0, 0, size, 1, |
| &buffer_addr) != 0 || |
| !buffer_addr) { |
| ADD_FAILURE() << "Failed to map buffer"; |
| } |
| } |
| |
| Camera3ExifValidator::JpegExifInfo::~JpegExifInfo() { |
| if (exif_data) { |
| exif_data_unref(exif_data); |
| } |
| Camera3TestGralloc::GetInstance()->Unlock(*buffer_handle); |
| } |
| |
| bool Camera3ExifValidator::JpegExifInfo::Initialize() { |
| if (!buffer_addr) { |
| return false; |
| } |
| auto jpeg_blob = reinterpret_cast<camera3_jpeg_blob_t*>( |
| static_cast<uint8_t*>(buffer_addr) + buffer_size - |
| sizeof(camera3_jpeg_blob_t)); |
| if (static_cast<void*>(jpeg_blob) < buffer_addr || |
| jpeg_blob->jpeg_blob_id != CAMERA3_JPEG_BLOB_ID) { |
| ADD_FAILURE() << "Invalid JPEG BLOB ID"; |
| return false; |
| } |
| if (GetJpegInfo(static_cast<uint8_t*>(buffer_addr), jpeg_blob->jpeg_size, |
| &jpeg_resolution, &exif_data) != 0) { |
| ADD_FAILURE() << "No valid JPEG image found in the buffer"; |
| return false; |
| } |
| return true; |
| } |
| |
| static ResolutionInfo GetMetadataThumbnailSize( |
| const camera_metadata_t& metadata) { |
| const size_t kNumOfElementsInSizeEntry = 2; |
| enum { SIZE_ENTRY_WIDTH_INDEX, SIZE_ENTRY_HEIGHT_INDEX }; |
| camera_metadata_ro_entry_t entry; |
| if (find_camera_metadata_ro_entry(&metadata, ANDROID_JPEG_THUMBNAIL_SIZE, |
| &entry)) { |
| ADD_FAILURE() << "Cannot find the metadata ANDROID_JPEG_THUMBNAIL_SIZE"; |
| return ResolutionInfo(-1, -1); |
| } |
| if (entry.count != kNumOfElementsInSizeEntry) { |
| ADD_FAILURE() |
| << "Invalid entry count of metadata ANDROID_JPEG_THUMBNAIL_SIZE (" |
| << entry.count << ")"; |
| return ResolutionInfo(-1, -1); |
| } |
| return ResolutionInfo(entry.data.i32[SIZE_ENTRY_WIDTH_INDEX], |
| entry.data.i32[SIZE_ENTRY_HEIGHT_INDEX]); |
| } |
| |
| static int64_t GetMetadataInteger(const camera_metadata_t& metadata, |
| int32_t key) { |
| camera_metadata_ro_entry_t entry; |
| if (find_camera_metadata_ro_entry(&metadata, key, &entry)) { |
| ADD_FAILURE() << "Cannot find the metadata " |
| << get_camera_metadata_tag_name(key); |
| return -EINVAL; |
| } |
| switch (entry.type) { |
| case TYPE_BYTE: |
| return entry.data.u8[0]; |
| case TYPE_INT32: |
| return entry.data.i32[0]; |
| case TYPE_INT64: |
| return entry.data.i64[0]; |
| default: |
| ADD_FAILURE() << "Unexpected metadata entry type " << entry.type; |
| return -EINVAL; |
| } |
| } |
| |
| static float GetMetadataKeyValueFloat(const camera_metadata_t& metadata, |
| int32_t key) { |
| camera_metadata_ro_entry_t entry; |
| if (find_camera_metadata_ro_entry(&metadata, key, &entry)) { |
| ADD_FAILURE() << "Cannot find the metadata " |
| << get_camera_metadata_tag_name(key); |
| return -EINVAL; |
| } |
| if (entry.type != TYPE_FLOAT) { |
| ADD_FAILURE() << "Unexpected metadata entry type " << entry.type; |
| return -EINVAL; |
| } |
| return entry.data.f[0]; |
| } |
| |
| void Camera3ExifValidator::ValidateExifKeys( |
| const ResolutionInfo& jpeg_resolution, |
| const ExifTestData& exif_test_data, |
| const ScopedBufferHandle& buffer, |
| size_t buffer_size, |
| const camera_metadata_t& metadata, |
| const time_t& date_time) const { |
| const int32_t kExifDateTimeStringLength = 19; |
| const double kExifDateTimeErrorMarginSeconds = 60; |
| const float kExifFocalLengthErrorMargin = 0.001f; |
| const float kExifExposureTimeErrorMarginRation = 0.05f; |
| const float kExifExposureTimeMinErrorMarginSeconds = 0.002f; |
| const float kOneNanoSecond = 1e-9; |
| const float kExifApertureErrorMargin = 0.001f; |
| auto GetClosestValueInArray = [](std::vector<float> values, float target) { |
| int min_idx = -1; |
| float min_distance = std::numeric_limits<float>::max(); |
| for (size_t i = 0; i < values.size(); i++) { |
| float distance = std::abs(values[i] - target); |
| if (min_distance > distance) { |
| min_distance = distance; |
| min_idx = i; |
| } |
| } |
| return (min_idx >= 0) ? values[min_idx] |
| : -std::numeric_limits<float>::max(); |
| }; |
| auto SwapWidthAndHeight = [](ResolutionInfo* resolution) { |
| *resolution = ResolutionInfo(resolution->Height(), resolution->Width()); |
| }; |
| |
| JpegExifInfo jpeg_exif_info(buffer, buffer_size); |
| ASSERT_TRUE(jpeg_exif_info.Initialize()); |
| ExifByteOrder byte_order = exif_data_get_byte_order(jpeg_exif_info.exif_data); |
| const ExifData& exif_data = *jpeg_exif_info.exif_data; |
| int32_t exif_orientation = GetExifTagInteger( |
| exif_data, EXIF_IFD_0, EXIF_TAG_ORIENTATION, byte_order); |
| EXPECT_LE(ORIENTATION_UNDEFINED, exif_orientation) |
| << "Invalid EXIF orientation value"; |
| EXPECT_GE(ORIENTATION_ROTATE_270, exif_orientation) |
| << "Invalid EXIF orientation value"; |
| EXPECT_TRUE(exif_orientation == ORIENTATION_UNDEFINED || |
| exif_test_data.orientation == |
| GetExifOrientationInDegree(exif_orientation)) |
| << "EXIF orientaiton should match requested orientation"; |
| |
| if (exif_test_data.thumbnail_resolution == ResolutionInfo(0, 0)) { |
| EXPECT_EQ(nullptr, exif_data.data) |
| << "JPEG shouldn't have thumbnail when thumbnail size is (0, 0)"; |
| } else { |
| EXPECT_NE(nullptr, exif_data.data) << "No thumbnail found in JPEG image"; |
| ResolutionInfo expected_thumbnail_resolution( |
| exif_test_data.thumbnail_resolution); |
| if (exif_test_data.orientation % 180 == 90 && |
| exif_orientation == ORIENTATION_UNDEFINED) { |
| // Device physically rotated image+thumbnail data |
| // Expect thumbnail size to be also rotated |
| SwapWidthAndHeight(&expected_thumbnail_resolution); |
| } |
| EXPECT_EQ(expected_thumbnail_resolution, GetMetadataThumbnailSize(metadata)) |
| << "JPEG thumbnail size result and request should match"; |
| if (exif_data.data) { |
| ResolutionInfo actual_thumbnail_resolution(0, 0); |
| if (GetJpegInfo(exif_data.data, exif_data.size, |
| &actual_thumbnail_resolution, nullptr) != 0) { |
| ADD_FAILURE() << "No valid thumbnail image found in the buffer"; |
| } else { |
| EXPECT_EQ(expected_thumbnail_resolution, actual_thumbnail_resolution) |
| << "EXIF thumbnail image size should match requested size"; |
| } |
| } |
| } |
| EXPECT_EQ(exif_test_data.orientation, |
| GetMetadataInteger(metadata, ANDROID_JPEG_ORIENTATION)) |
| << "JPEG orientation result and request should match"; |
| EXPECT_EQ(exif_test_data.jpeg_quality, |
| GetMetadataInteger(metadata, ANDROID_JPEG_QUALITY)) |
| << "JPEG quality result and request should match"; |
| EXPECT_EQ(exif_test_data.thumbnail_quality, |
| GetMetadataInteger(metadata, ANDROID_JPEG_THUMBNAIL_QUALITY)) |
| << "JPEG thumbnail quality result and request should match"; |
| // TAG_IMAGE_WIDTH and TAG_IMAGE_LENGTH and TAG_ORIENTATION. |
| // Orientation and exif width/height need to be tested carefully, two cases: |
| // 1. Device rotates the image buffer physically, then exif width/height may |
| // not match the requested still capture size, we need swap them to check. |
| // 2. Device uses the exif tag to record the image orientation, it doesn't |
| // rotate the jpeg image buffer itself. In this case, the exif width/height |
| // should always match the requested still capture size, and the exif |
| // orientation should always match the requested orientation. |
| ResolutionInfo expected_jpeg_size(jpeg_resolution); |
| if (exif_test_data.orientation % 180 == 90 && |
| exif_orientation == ORIENTATION_UNDEFINED) { |
| // Device captured image doesn't respect the requested orientation, which |
| // means it rotates the image buffer physically. Then we should swap the |
| // exif width/height accordingly to compare. |
| SwapWidthAndHeight(&expected_jpeg_size); |
| } |
| EXPECT_EQ( |
| expected_jpeg_size, |
| ResolutionInfo(GetExifTagInteger(exif_data, EXIF_IFD_0, |
| EXIF_TAG_IMAGE_WIDTH, byte_order), |
| GetExifTagInteger(exif_data, EXIF_IFD_0, |
| EXIF_TAG_IMAGE_LENGTH, byte_order))) |
| << "EXIF JPEG size should match requested size"; |
| EXPECT_EQ( |
| expected_jpeg_size, |
| ResolutionInfo(GetExifTagInteger(exif_data, EXIF_IFD_EXIF, |
| EXIF_TAG_PIXEL_X_DIMENSION, byte_order), |
| GetExifTagInteger(exif_data, EXIF_IFD_EXIF, |
| EXIF_TAG_PIXEL_Y_DIMENSION, byte_order))) |
| << "EXIF JPEG pixel dimension should match requested size"; |
| EXPECT_EQ(expected_jpeg_size, jpeg_exif_info.jpeg_resolution) |
| << "JPEG size result and request should match"; |
| |
| // Validate date time between EXIF data and current time |
| const char* exif_datetime_string = |
| GetExifTagString(exif_data, EXIF_IFD_0, EXIF_TAG_DATE_TIME); |
| if (exif_datetime_string) { |
| EXPECT_EQ(kExifDateTimeStringLength, strlen(exif_datetime_string)) |
| << "EXIF dateTime is in wrong format"; |
| struct tm exif_tm = {}; |
| strptime(exif_datetime_string, "%Y:%m:%d %H:%M:%S", &exif_tm); |
| time_t exif_time = mktime(&exif_tm); |
| EXPECT_GT(kExifDateTimeErrorMarginSeconds, difftime(date_time, exif_time)) |
| << "Capture time deviates too much from the current time"; |
| const char* exif_datetime_digitized = GetExifTagString( |
| exif_data, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_DIGITIZED); |
| if (exif_datetime_digitized) { |
| EXPECT_EQ(kExifDateTimeStringLength, strlen(exif_datetime_digitized)) |
| << "EXIF digitizedTime is in wrong format"; |
| EXPECT_EQ(0, strncmp(exif_datetime_string, exif_datetime_digitized, |
| kExifDateTimeStringLength)) |
| << "EXIF dataTime should match digitizedTime"; |
| } |
| } |
| |
| // Validate focal length between EXIF data and metadata |
| std::vector<float> focal_lengths; |
| if (cam_info_.GetAvailableFocalLengths(&focal_lengths) != 0 || |
| focal_lengths.empty()) { |
| ADD_FAILURE() << "Failed to get available focal lengths"; |
| } else { |
| float exif_focal_length = GetExifTagFloat( |
| exif_data, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH, byte_order); |
| EXPECT_GT( |
| kExifFocalLengthErrorMargin, |
| std::abs(GetClosestValueInArray(focal_lengths, exif_focal_length) - |
| exif_focal_length)) |
| << "EXIF focal length should be one of the available focal lengths"; |
| float result_focal_length = |
| GetMetadataKeyValueFloat(metadata, ANDROID_LENS_FOCAL_LENGTH); |
| EXPECT_LT(0.0f, result_focal_length) |
| << "Result Focal length " << result_focal_length |
| << " should be positive"; |
| EXPECT_NE(focal_lengths.end(), |
| std::find(focal_lengths.begin(), focal_lengths.end(), |
| result_focal_length)) |
| << "Result Focal length should be one of the available focal lengths"; |
| EXPECT_GT(kExifFocalLengthErrorMargin, |
| std::abs(result_focal_length - exif_focal_length)) |
| << "EXIF focal length should match capture result"; |
| } |
| |
| // Validate exposure time between EXIF data and metadata |
| float exif_exposure_time = GetExifTagFloat( |
| exif_data, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_TIME, byte_order); |
| if (exif_exposure_time > 0 && |
| cam_info_.IsKeyAvailable(ANDROID_SENSOR_EXPOSURE_TIME)) { |
| float result_exposure_time = static_cast<float>(GetMetadataInteger( |
| metadata, ANDROID_SENSOR_EXPOSURE_TIME)) * |
| kOneNanoSecond; |
| float tolerance = |
| std::max(result_exposure_time * kExifExposureTimeErrorMarginRation, |
| kExifExposureTimeMinErrorMarginSeconds); |
| EXPECT_GT(tolerance, std::abs(result_exposure_time - exif_exposure_time)) |
| << "Exif exposure time doesn't match"; |
| } |
| |
| // Validate aperture between EXIF data and metadata |
| float exif_aperture = |
| GetExifTagFloat(exif_data, EXIF_IFD_EXIF, EXIF_TAG_FNUMBER, byte_order); |
| if (exif_aperture > 0 && |
| cam_info_.IsKeyAvailable(ANDROID_LENS_INFO_AVAILABLE_APERTURES)) { |
| std::vector<float> apertures; |
| if (cam_info_.GetAvailableApertures(&apertures) != 0 || apertures.empty()) { |
| ADD_FAILURE() << "Failed to get available apertures"; |
| } else { |
| float result_aperture = |
| GetMetadataKeyValueFloat(metadata, ANDROID_LENS_APERTURE); |
| EXPECT_GT(kExifApertureErrorMargin, |
| std::abs(GetClosestValueInArray(apertures, exif_aperture) - |
| exif_aperture)) |
| << "Aperture value should be one of the available apertures"; |
| EXPECT_GT(kExifApertureErrorMargin, |
| std::abs(result_aperture - exif_aperture)) |
| << "Exif aperture length should match capture result"; |
| } |
| } |
| |
| // Verify EXIF TAG_FLASH is available |
| GetExifTagInteger(exif_data, EXIF_IFD_EXIF, EXIF_TAG_FLASH, byte_order); |
| // Verify EXIF TAG_WHITE_BALANCE is available |
| GetExifTagInteger(exif_data, EXIF_IFD_EXIF, EXIF_TAG_WHITE_BALANCE, |
| byte_order); |
| // TODO(hywu): For full devices, validate flash and AWB between EXIF and |
| // metadata |
| |
| // Validate ISO between EXIF and metadata |
| if (cam_info_.IsKeyAvailable(ANDROID_SENSOR_SENSITIVITY)) { |
| int32_t iso = GetExifTagInteger(exif_data, EXIF_IFD_EXIF, |
| EXIF_TAG_ISO_SPEED_RATINGS, byte_order); |
| EXPECT_EQ(GetMetadataInteger(metadata, ANDROID_SENSOR_SENSITIVITY), iso) |
| << "EXIF TAG_ISO is incorrect"; |
| } |
| |
| auto is_number = [&](const ExifIfd& ifd, const ExifTag& tag) { |
| const char* c = GetExifTagString(exif_data, ifd, tag); |
| const std::string s(c ? c : ""); |
| return !s.empty() && std::find_if(s.begin(), s.end(), [](char c) { |
| return !std::isdigit(c); |
| }) == s.end(); |
| }; |
| EXPECT_TRUE(is_number(EXIF_IFD_EXIF, EXIF_TAG_SUB_SEC_TIME)); |
| EXPECT_TRUE(is_number(EXIF_IFD_EXIF, EXIF_TAG_SUB_SEC_TIME_ORIGINAL)); |
| EXPECT_TRUE(is_number(EXIF_IFD_EXIF, EXIF_TAG_SUB_SEC_TIME_DIGITIZED)); |
| } |
| |
| int Camera3ExifValidator::getExifOrientation(const ScopedBufferHandle& buffer, |
| size_t buffer_size) { |
| JpegExifInfo jpeg_exif_info(buffer, buffer_size); |
| jpeg_exif_info.Initialize(); |
| ExifByteOrder byte_order = exif_data_get_byte_order(jpeg_exif_info.exif_data); |
| const ExifData& exif_data = *jpeg_exif_info.exif_data; |
| int32_t exif_orientation = GetExifTagInteger( |
| exif_data, EXIF_IFD_0, EXIF_TAG_ORIENTATION, byte_order); |
| return exif_orientation; |
| } |
| |
| } // namespace camera3_test |
