| // Copyright 2020 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include <array> |
| #include <cstring> |
| |
| #include "helper.h" // NOLINT(build/include) |
| #include "tiffio.h" // NOLINT(build/include) |
| |
| using ::sapi::IsOk; |
| using ::testing::Eq; |
| using ::testing::IsFalse; |
| using ::testing::IsTrue; |
| using ::testing::NotNull; |
| |
| namespace { |
| |
| struct ChannelLimits { |
| uint8_t min_red; |
| uint8_t max_red; |
| uint8_t min_green; |
| uint8_t max_green; |
| uint8_t min_blue; |
| uint8_t max_blue; |
| uint8_t min_alpha; |
| uint8_t max_alpha; |
| }; |
| |
| constexpr uint32_t kRawTileNumber = 9; |
| constexpr uint32_t kClusterSize = 6; |
| constexpr uint32_t kChannelsInPixel = 3; |
| constexpr uint32_t kTestCount = 3; |
| constexpr uint32_t kImageSize = 128 * 128; |
| constexpr uint32_t kClusterImageSize = 64 * 64; |
| using ClusterData = std::array<uint8_t, kClusterSize>; |
| |
| constexpr std::array<std::pair<uint32_t, ClusterData>, kTestCount> kClusters = { |
| {{0, {0, 0, 2, 0, 138, 139}}, |
| {64, {0, 0, 9, 6, 134, 119}}, |
| {128, {44, 40, 63, 59, 230, 95}}}}; |
| |
| constexpr std::array<std::pair<uint32_t, ChannelLimits>, kTestCount> kLimits = { |
| {{0, {15, 18, 0, 0, 18, 41, 255, 255}}, |
| {64, {0, 0, 0, 0, 0, 2, 255, 255}}, |
| {512, {5, 6, 34, 36, 182, 196, 255, 255}}}}; |
| |
| bool CheckCluster(uint32_t cluster, const sapi::v::Array<uint8_t>& buffer, |
| const ClusterData& expected_cluster) { |
| bool is_overrun = (buffer.GetSize() <= cluster * kClusterSize); |
| EXPECT_THAT(is_overrun, IsFalse()) << "Overrun"; |
| |
| if (is_overrun) { |
| return true; |
| } |
| |
| auto* target = buffer.GetData() + cluster * kClusterSize; |
| bool comp = |
| !(std::memcmp(target, expected_cluster.data(), kClusterSize) == 0); |
| |
| // the image is split on 6-bit clusters because it has YCbCr color format |
| EXPECT_THAT(comp, IsFalse()) |
| << "Cluster " << cluster << " did not match expected results.\n" |
| << "Expect: " << expected_cluster[0] << "\t" << expected_cluster[1] |
| << "\t" << expected_cluster[2] << "\t" << expected_cluster[3] << "\t" |
| << expected_cluster[4] << "\t" << expected_cluster[5] << "\n" |
| << "Got: " << target[0] << "\t" << target[1] << "\t" << target[2] << "\t" |
| << target[3] << "\t" << target[4] << "\t" << target[5]; |
| |
| return comp; |
| } |
| |
| bool CheckRgbPixel(uint32_t pixel, const ChannelLimits& limits, |
| const sapi::v::Array<uint8_t>& buffer) { |
| bool is_overrun = (buffer.GetSize() <= pixel * kChannelsInPixel); |
| EXPECT_THAT(is_overrun, IsFalse()) << "Overrun"; |
| |
| if (is_overrun) { |
| return true; |
| } |
| |
| auto* rgb = buffer.GetData() + pixel * kChannelsInPixel; |
| bool comp = !(rgb[0] >= limits.min_red && rgb[0] <= limits.max_red && |
| rgb[1] >= limits.min_green && rgb[1] <= limits.max_green && |
| rgb[2] >= limits.min_blue && rgb[2] <= limits.max_blue); |
| |
| EXPECT_THAT(comp, IsFalse()) |
| << "Pixel " << pixel << " did not match expected results.\n" |
| << "Got R=" << rgb[0] << " (expected " << limits.min_red |
| << "..=" << limits.max_red << "), G=" << rgb[1] << " (expected " |
| << limits.min_green << "..=" << limits.max_green << "), B=" << rgb[2] |
| << " (expected " << limits.min_blue << "..=" << limits.max_blue << ")"; |
| return comp; |
| } |
| |
| bool CheckRgbaPixel(uint32_t pixel, const ChannelLimits& limits, |
| const sapi::v::Array<uint32_t>& buffer) { |
| // RGBA images are upside down - adjust for normal ordering |
| uint32_t adjusted_pixel = pixel % 128 + (127 - (pixel / 128)) * 128; |
| |
| bool is_overrun = (buffer.GetSize() <= adjusted_pixel); |
| EXPECT_THAT(is_overrun, IsFalse()) << "Overrun"; |
| |
| if (is_overrun) { |
| return true; |
| } |
| |
| auto* rgba = buffer[adjusted_pixel]; |
| bool comp = !(TIFFGetR(rgba) >= static_cast<unsigned>(limits.min_red) && |
| TIFFGetR(rgba) <= static_cast<unsigned>(limits.max_red) && |
| TIFFGetG(rgba) >= static_cast<unsigned>(limits.min_green) && |
| TIFFGetG(rgba) <= static_cast<unsigned>(limits.max_green) && |
| TIFFGetB(rgba) >= static_cast<unsigned>(limits.min_blue) && |
| TIFFGetB(rgba) <= static_cast<unsigned>(limits.max_blue) && |
| TIFFGetA(rgba) >= static_cast<unsigned>(limits.min_alpha) && |
| TIFFGetA(rgba) <= static_cast<unsigned>(limits.max_alpha)); |
| |
| EXPECT_THAT(comp, IsFalse()) |
| << "Pixel " << pixel << " did not match expected results.\n" |
| << "Got R=" << TIFFGetR(rgba) << " (expected " << limits.min_red |
| << "..=" << limits.max_red << "), G=" << TIFFGetG(rgba) << " (expected " |
| << limits.min_green << "..=" << limits.max_green |
| << "), B=" << TIFFGetB(rgba) << " (expected " << limits.min_blue |
| << "..=" << limits.max_blue << "), A=" << TIFFGetA(rgba) << " (expected " |
| << limits.min_alpha << "..=" << limits.max_alpha << ")"; |
| return comp; |
| } |
| |
| TEST(SandboxTest, RawDecode) { |
| tsize_t sz; |
| bool pixel_status = false; |
| bool cluster_status = false; |
| std::string srcfile = GetFilePath("quad-tile.jpg.tiff"); |
| |
| TiffSapiSandbox sandbox(srcfile); |
| ASSERT_THAT(sandbox.Init(), IsOk()) << "Couldn't initialize Sandboxed API"; |
| |
| sapi::v::UShort h; |
| sapi::v::UShort v; |
| absl::StatusOr<TIFF*> status_or_tif; |
| absl::StatusOr<int> status_or_int; |
| absl::StatusOr<tmsize_t> status_or_long; |
| |
| TiffApi api(&sandbox); |
| sapi::v::ConstCStr srcfile_var(srcfile.c_str()); |
| sapi::v::ConstCStr r_var("r"); |
| |
| status_or_tif = api.TIFFOpen(srcfile_var.PtrBefore(), r_var.PtrBefore()); |
| ASSERT_THAT(status_or_tif, IsOk()) << "Could not open " << srcfile; |
| |
| sapi::v::RemotePtr tif(status_or_tif.value()); |
| ASSERT_THAT(tif.GetValue(), NotNull()) |
| << "Could not open " << srcfile << ", TIFFOpen return NULL"; |
| |
| status_or_int = api.TIFFGetField2(&tif, TIFFTAG_YCBCRSUBSAMPLING, h.PtrBoth(), |
| v.PtrBoth()); |
| ASSERT_THAT(status_or_int, IsOk()) << "TIFFGetField2 fatal error"; |
| EXPECT_THAT( |
| status_or_int.value() == 0 || h.GetValue() != 2 || v.GetValue() != 2, |
| IsFalse()) |
| << "Could not retrieve subsampling tag"; |
| |
| status_or_long = api.TIFFTileSize(&tif); |
| ASSERT_THAT(status_or_int, IsOk()) << "TIFFTileSize fatal error"; |
| EXPECT_THAT(status_or_long.value(), Eq(kClusterImageSize * kClusterSize)) |
| << "Unexpected TileSize " << status_or_long.value() << ". Expected " |
| << kClusterImageSize * kClusterSize << " bytes\n"; |
| sz = status_or_long.value(); |
| |
| sapi::v::Array<uint8_t> buffer_(sz); |
| // Read a tile in decompressed form, but still YCbCr subsampled |
| status_or_long = |
| api.TIFFReadEncodedTile(&tif, kRawTileNumber, buffer_.PtrBoth(), sz); |
| ASSERT_THAT(status_or_long, IsOk()) << "TIFFReadEncodedTile fatal error"; |
| EXPECT_THAT(status_or_long.value(), Eq(sz)) |
| << "Did not get expected result code from TIFFReadEncodedTile()(" |
| << (int)status_or_long.value() << " instead of " << (int)sz << ")"; |
| |
| for (const auto& [id, data] : kClusters) { |
| cluster_status |= CheckCluster(id, buffer_, data); |
| } |
| ASSERT_FALSE(cluster_status) << "Clusters did not match expected results"; |
| |
| status_or_int = |
| api.TIFFSetFieldU1(&tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB); |
| ASSERT_THAT(status_or_int, IsOk()) << "TIFFSetFieldU1 fatal error"; |
| EXPECT_THAT(status_or_int.value(), IsTrue()) |
| << "The JPEGCOLORMODE tag cannot be changed"; |
| |
| status_or_long = api.TIFFTileSize(&tif); |
| ASSERT_THAT(status_or_long, IsOk()) << "TIFFTileSize fatal error"; |
| EXPECT_THAT(status_or_long.value(), Eq(kImageSize * kChannelsInPixel)) |
| << "Unexpected TileSize " << status_or_long.value() << ". Expected " |
| << kImageSize * kChannelsInPixel << " bytes\n"; |
| sz = status_or_long.value(); |
| |
| sapi::v::Array<uint8_t> buffer2_(sz); |
| status_or_long = |
| api.TIFFReadEncodedTile(&tif, kRawTileNumber, buffer2_.PtrBoth(), sz); |
| ASSERT_THAT(status_or_long, IsOk()) << "TIFFReadEncodedTile fatal error"; |
| EXPECT_THAT(status_or_long.value(), Eq(sz)) |
| << "Did not get expected result code from TIFFReadEncodedTile()(" |
| << status_or_long.value() << " instead of " << sz; |
| |
| for (const auto& [id, data] : kLimits) { |
| pixel_status |= CheckRgbPixel(id, data, buffer2_); |
| } |
| |
| ASSERT_THAT(api.TIFFClose(&tif), IsOk()) << "TIFFClose fatal error"; |
| |
| status_or_tif = api.TIFFOpen(srcfile_var.PtrBefore(), r_var.PtrBefore()); |
| ASSERT_THAT(status_or_tif, IsOk()) << "TIFFOpen fatal error"; |
| |
| sapi::v::RemotePtr tif2(status_or_tif.value()); |
| ASSERT_THAT(tif2.GetValue(), NotNull()) |
| << "Could not open " << srcfile << ", TIFFOpen return NULL"; |
| |
| sapi::v::Array<uint32_t> rgba_buffer_(kImageSize); |
| |
| status_or_int = |
| api.TIFFReadRGBATile(&tif2, 1 * 128, 2 * 128, rgba_buffer_.PtrBoth()); |
| ASSERT_THAT(status_or_int, IsOk()) << "TIFFReadRGBATile fatal error"; |
| EXPECT_THAT(status_or_int.value(), IsTrue()) |
| << "TIFFReadRGBATile() returned failure code"; |
| |
| for (const auto& [id, data] : kLimits) { |
| pixel_status |= CheckRgbaPixel(id, data, rgba_buffer_); |
| } |
| |
| EXPECT_THAT(api.TIFFClose(&tif2), IsOk()) << "TIFFClose fatal error"; |
| EXPECT_THAT(pixel_status, IsFalse()) << "wrong encoding"; |
| } |
| |
| } // namespace |