Source code
Revision control
Copy as Markdown
Other Tools
// Copyright (c) the JPEG XL Project 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 <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>
#include "lib/jpegli/encode.h"
#include "lib/jpegli/libjpeg_test_util.h"
#include "lib/jpegli/test_params.h"
#include "lib/jpegli/test_utils.h"
#include "lib/jpegli/testing.h"
#include "lib/jpegli/types.h"
namespace jpegli {
namespace {
struct TestConfig {
TestImage input;
CompressParams jparams;
JpegIOMode input_mode = PIXELS;
double max_bpp;
double max_dist;
};
class EncodeAPITestParam : public ::testing::TestWithParam<TestConfig> {};
void GenerateInput(JpegIOMode input_mode, const CompressParams& jparams,
TestImage* input) {
GeneratePixels(input);
if (input_mode == RAW_DATA) {
GenerateRawData(jparams, input);
} else if (input_mode == COEFFICIENTS) {
GenerateCoeffs(jparams, input);
}
}
TEST_P(EncodeAPITestParam, TestAPI) {
TestConfig config = GetParam();
GenerateInput(config.input_mode, config.jparams, &config.input);
std::vector<uint8_t> compressed;
ASSERT_TRUE(EncodeWithJpegli(config.input, config.jparams, &compressed));
if (config.jparams.icc.empty()) {
double bpp =
compressed.size() * 8.0 / (config.input.xsize * config.input.ysize);
printf("bpp: %f\n", bpp);
EXPECT_LT(bpp, config.max_bpp);
}
DecompressParams dparams;
dparams.output_mode =
config.input_mode == COEFFICIENTS ? COEFFICIENTS : PIXELS;
if (config.jparams.set_jpeg_colorspace &&
config.jparams.jpeg_color_space == JCS_GRAYSCALE) {
ConvertToGrayscale(&config.input);
} else {
dparams.set_out_color_space = true;
dparams.out_color_space = config.input.color_space;
}
TestImage output;
DecodeWithLibjpeg(config.jparams, dparams, compressed, &output);
VerifyOutputImage(config.input, output, config.max_dist);
}
TEST(EncodeAPITest, ReuseCinfoSameImageTwice) {
TestImage input;
input.xsize = 129;
input.ysize = 73;
CompressParams jparams;
GenerateInput(PIXELS, jparams, &input);
uint8_t* buffer = nullptr;
unsigned long buffer_size = 0; // NOLINT
std::vector<uint8_t> compressed0;
std::vector<uint8_t> compressed1;
jpeg_compress_struct cinfo;
const auto try_catch_block = [&]() -> bool {
ERROR_HANDLER_SETUP(jpegli);
jpegli_create_compress(&cinfo);
jpegli_mem_dest(&cinfo, &buffer, &buffer_size);
EncodeWithJpegli(input, jparams, &cinfo);
compressed0.assign(buffer, buffer + buffer_size);
jpegli_mem_dest(&cinfo, &buffer, &buffer_size);
EncodeWithJpegli(input, jparams, &cinfo);
compressed1.assign(buffer, buffer + buffer_size);
return true;
};
EXPECT_TRUE(try_catch_block());
jpegli_destroy_compress(&cinfo);
if (buffer) free(buffer);
ASSERT_EQ(compressed0.size(), compressed1.size());
EXPECT_EQ(0,
memcmp(compressed0.data(), compressed1.data(), compressed0.size()));
}
std::vector<TestConfig> GenerateBasicConfigs() {
std::vector<TestConfig> all_configs;
for (int samp : {1, 2}) {
for (int progr : {0, 2}) {
for (int optimize : {0, 1}) {
if (progr && optimize) continue;
TestConfig config;
config.input.xsize = 257 + samp * 37;
config.input.ysize = 265 + optimize * 17;
config.jparams.h_sampling = {samp, 1, 1};
config.jparams.v_sampling = {samp, 1, 1};
config.jparams.progressive_mode = progr;
config.jparams.optimize_coding = optimize;
config.max_dist = 2.4f;
GeneratePixels(&config.input);
all_configs.push_back(config);
}
}
}
return all_configs;
}
TEST(EncodeAPITest, ReuseCinfoSameMemOutput) {
std::vector<TestConfig> all_configs = GenerateBasicConfigs();
uint8_t* buffer = nullptr;
unsigned long buffer_size = 0; // NOLINT
{
jpeg_compress_struct cinfo;
const auto try_catch_block = [&]() -> bool {
ERROR_HANDLER_SETUP(jpegli);
jpegli_create_compress(&cinfo);
jpegli_mem_dest(&cinfo, &buffer, &buffer_size);
for (const TestConfig& config : all_configs) {
EncodeWithJpegli(config.input, config.jparams, &cinfo);
}
return true;
};
EXPECT_TRUE(try_catch_block());
jpegli_destroy_compress(&cinfo);
}
size_t pos = 0;
for (auto& config : all_configs) {
TestImage output;
pos += DecodeWithLibjpeg(config.jparams, DecompressParams(), nullptr, 0,
buffer + pos, buffer_size - pos, &output);
VerifyOutputImage(config.input, output, config.max_dist);
}
if (buffer) free(buffer);
}
TEST(EncodeAPITest, ReuseCinfoSameStdOutput) {
std::vector<TestConfig> all_configs = GenerateBasicConfigs();
FILE* tmpf = tmpfile();
ASSERT_TRUE(tmpf);
{
jpeg_compress_struct cinfo;
const auto try_catch_block = [&]() -> bool {
ERROR_HANDLER_SETUP(jpegli);
jpegli_create_compress(&cinfo);
jpegli_stdio_dest(&cinfo, tmpf);
for (const TestConfig& config : all_configs) {
EncodeWithJpegli(config.input, config.jparams, &cinfo);
}
return true;
};
EXPECT_TRUE(try_catch_block());
jpegli_destroy_compress(&cinfo);
}
size_t total_size = ftell(tmpf);
fseek(tmpf, 0, SEEK_SET);
std::vector<uint8_t> compressed(total_size);
ASSERT_TRUE(total_size == fread(compressed.data(), 1, total_size, tmpf));
fclose(tmpf);
size_t pos = 0;
for (auto& config : all_configs) {
TestImage output;
pos +=
DecodeWithLibjpeg(config.jparams, DecompressParams(), nullptr, 0,
&compressed[pos], compressed.size() - pos, &output);
VerifyOutputImage(config.input, output, config.max_dist);
}
}
TEST(EncodeAPITest, ReuseCinfoChangeParams) {
TestImage input;
TestImage output;
CompressParams jparams;
DecompressParams dparams;
uint8_t* buffer = nullptr;
unsigned long buffer_size = 0; // NOLINT
std::vector<uint8_t> compressed;
jpeg_compress_struct cinfo;
const auto max_rms = [](int q, int hs, int vs) {
if (hs == 1 && vs == 1) return q == 90 ? 2.2 : 0.6;
if (hs == 2 && vs == 2) return q == 90 ? 2.8 : 1.2;
return q == 90 ? 2.4 : 1.0;
};
const auto try_catch_block = [&]() -> bool {
ERROR_HANDLER_SETUP(jpegli);
jpegli_create_compress(&cinfo);
input.xsize = 129;
input.ysize = 73;
dparams.set_out_color_space = true;
for (JpegIOMode input_mode : {PIXELS, RAW_DATA, PIXELS, COEFFICIENTS}) {
for (int h_samp : {2, 1}) {
for (int v_samp : {2, 1}) {
for (int progr : {0, 2}) {
for (int quality : {90, 100}) {
input.Clear();
input.color_space =
(input_mode == RAW_DATA ? JCS_YCbCr : JCS_RGB);
jparams.quality = quality;
jparams.h_sampling = {h_samp, 1, 1};
jparams.v_sampling = {v_samp, 1, 1};
jparams.progressive_mode = progr;
printf(
"Generating input with quality %d chroma subsampling %dx%d "
"input mode %d progressive_mode %d\n",
quality, h_samp, v_samp, input_mode, progr);
GenerateInput(input_mode, jparams, &input);
jpegli_mem_dest(&cinfo, &buffer, &buffer_size);
if (input_mode != COEFFICIENTS) {
cinfo.image_width = input.xsize;
cinfo.image_height = input.ysize;
cinfo.input_components = input.components;
jpegli_set_defaults(&cinfo);
jpegli_start_compress(&cinfo, TRUE);
jpegli_abort_compress(&cinfo);
jpegli_mem_dest(&cinfo, &buffer, &buffer_size);
}
EncodeWithJpegli(input, jparams, &cinfo);
compressed.resize(buffer_size);
std::copy_n(buffer, buffer_size, compressed.data());
dparams.output_mode =
input_mode == COEFFICIENTS ? COEFFICIENTS : PIXELS;
dparams.out_color_space = input.color_space;
output.Clear();
DecodeWithLibjpeg(jparams, dparams, compressed, &output);
VerifyOutputImage(input, output,
max_rms(quality, h_samp, v_samp));
}
}
}
}
}
return true;
};
EXPECT_TRUE(try_catch_block());
jpegli_destroy_compress(&cinfo);
if (buffer) free(buffer);
}
TEST(EncodeAPITest, AbbreviatedStreams) {
uint8_t* table_stream = nullptr;
unsigned long table_stream_size = 0; // NOLINT
uint8_t* data_stream = nullptr;
unsigned long data_stream_size = 0; // NOLINT
{
jpeg_compress_struct cinfo;
const auto try_catch_block = [&]() -> bool {
ERROR_HANDLER_SETUP(jpegli);
jpegli_create_compress(&cinfo);
jpegli_mem_dest(&cinfo, &table_stream, &table_stream_size);
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
jpegli_set_defaults(&cinfo);
jpegli_write_tables(&cinfo);
jpegli_mem_dest(&cinfo, &data_stream, &data_stream_size);
cinfo.image_width = 1;
cinfo.image_height = 1;
cinfo.optimize_coding = FALSE;
jpegli_set_progressive_level(&cinfo, 0);
jpegli_start_compress(&cinfo, FALSE);
JSAMPLE image[3] = {0};
JSAMPROW row[] = {image};
jpegli_write_scanlines(&cinfo, row, 1);
jpegli_finish_compress(&cinfo);
return true;
};
EXPECT_TRUE(try_catch_block());
EXPECT_LT(data_stream_size, 50);
jpegli_destroy_compress(&cinfo);
}
TestImage output;
DecodeWithLibjpeg(CompressParams(), DecompressParams(), table_stream,
table_stream_size, data_stream, data_stream_size, &output);
EXPECT_EQ(1, output.xsize);
EXPECT_EQ(1, output.ysize);
EXPECT_EQ(3, output.components);
EXPECT_EQ(0, output.pixels[0]);
EXPECT_EQ(0, output.pixels[1]);
EXPECT_EQ(0, output.pixels[2]);
if (table_stream) free(table_stream);
if (data_stream) free(data_stream);
}
void CopyQuantTables(j_compress_ptr cinfo, uint16_t* quant_tables) {
for (int c = 0; c < cinfo->num_components; ++c) {
int quant_idx = cinfo->comp_info[c].quant_tbl_no;
JQUANT_TBL* quant_table = cinfo->quant_tbl_ptrs[quant_idx];
for (int k = 0; k < DCTSIZE2; ++k) {
quant_tables[c * DCTSIZE2 + k] = quant_table->quantval[k];
}
}
}
TEST(EncodeAPITest, QualitySettings) {
// Test that jpegli_set_quality, jpegli_set_linear_quality and
// jpegli_quality_scaling are consistent with each other.
uint16_t quant_tables0[3 * DCTSIZE2];
uint16_t quant_tables1[3 * DCTSIZE2];
jpeg_compress_struct cinfo;
const auto try_catch_block = [&]() -> bool {
ERROR_HANDLER_SETUP(jpegli);
jpegli_create_compress(&cinfo);
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
jpegli_set_defaults(&cinfo);
for (boolean baseline : {FALSE, TRUE}) {
for (int q = 1; q <= 100; ++q) {
jpegli_set_quality(&cinfo, q, baseline);
CopyQuantTables(&cinfo, quant_tables0);
jpegli_set_linear_quality(&cinfo, jpegli_quality_scaling(q), baseline);
CopyQuantTables(&cinfo, quant_tables1);
EXPECT_EQ(0,
memcmp(quant_tables0, quant_tables1, sizeof(quant_tables0)));
#if JPEG_LIB_VERSION >= 70
for (int i = 0; i < NUM_QUANT_TBLS; ++i) {
cinfo.q_scale_factor[i] = jpegli_quality_scaling(q);
}
jpegli_default_qtables(&cinfo, baseline);
CopyQuantTables(&cinfo, quant_tables1);
EXPECT_EQ(0,
memcmp(quant_tables0, quant_tables1, sizeof(quant_tables0)));
#endif
}
}
return true;
};
EXPECT_TRUE(try_catch_block());
jpegli_destroy_compress(&cinfo);
// Test jpegli_quality_scaling for some specific values .
EXPECT_EQ(5000, jpegli_quality_scaling(-1));
EXPECT_EQ(5000, jpegli_quality_scaling(0));
EXPECT_EQ(5000, jpegli_quality_scaling(1));
EXPECT_EQ(100, jpegli_quality_scaling(50));
EXPECT_EQ(50, jpegli_quality_scaling(75));
EXPECT_EQ(20, jpegli_quality_scaling(90));
EXPECT_EQ(0, jpegli_quality_scaling(100));
EXPECT_EQ(0, jpegli_quality_scaling(101));
}
std::vector<TestConfig> GenerateTests() {
std::vector<TestConfig> all_tests;
for (int h_samp : {1, 2}) {
for (int v_samp : {1, 2}) {
for (int progr : {0, 2}) {
for (int optimize : {0, 1}) {
if (progr && optimize) continue;
TestConfig config;
config.jparams.h_sampling = {h_samp, 1, 1};
config.jparams.v_sampling = {v_samp, 1, 1};
config.jparams.progressive_mode = progr;
if (!progr) {
config.jparams.optimize_coding = optimize;
}
const float kMaxBpp[4] = {1.55, 1.4, 1.4, 1.32};
const float kMaxDist[4] = {1.95, 2.2, 2.2, 2.0};
const int idx = v_samp * 2 + h_samp - 3;
config.max_bpp =
kMaxBpp[idx] * (optimize ? 0.97 : 1.0) * (progr ? 0.97 : 1.0);
config.max_dist = kMaxDist[idx];
all_tests.push_back(config);
}
}
}
}
{
TestConfig config;
config.jparams.quality = 100;
config.jparams.h_sampling = {1, 1, 1};
config.jparams.v_sampling = {1, 1, 1};
config.max_bpp = 6.6;
config.max_dist = 0.6;
all_tests.push_back(config);
}
{
TestConfig config;
config.jparams.quality = 80;
config.max_bpp = 1.05;
config.max_dist = 2.7;
all_tests.push_back(config);
}
for (int samp : {1, 2}) {
for (int progr : {0, 2}) {
for (int optimize : {0, 1}) {
if (progr && optimize) continue;
TestConfig config;
config.input.xsize = 257;
config.input.ysize = 265;
config.jparams.h_sampling = {samp, 1, 1};
config.jparams.v_sampling = {samp, 1, 1};
config.jparams.progressive_mode = progr;
if (!progr) {
config.jparams.optimize_coding = optimize;
}
config.jparams.use_adaptive_quantization = false;
config.max_bpp = 2.05f;
config.max_dist = 2.3f;
all_tests.push_back(config);
}
}
}
for (int h0_samp : {1, 2, 4}) {
for (int v0_samp : {1, 2, 4}) {
for (int h2_samp : {1, 2, 4}) {
for (int v2_samp : {1, 2, 4}) {
TestConfig config;
config.input.xsize = 137;
config.input.ysize = 75;
config.jparams.progressive_mode = 2;
config.jparams.h_sampling = {h0_samp, 1, h2_samp};
config.jparams.v_sampling = {v0_samp, 1, v2_samp};
config.max_bpp = 2.5;
config.max_dist = 12.0;
all_tests.push_back(config);
}
}
}
}
for (int h0_samp : {1, 3}) {
for (int v0_samp : {1, 3}) {
for (int h2_samp : {1, 3}) {
for (int v2_samp : {1, 3}) {
TestConfig config;
config.input.xsize = 205;
config.input.ysize = 99;
config.jparams.progressive_mode = 2;
config.jparams.h_sampling = {h0_samp, 1, h2_samp};
config.jparams.v_sampling = {v0_samp, 1, v2_samp};
config.max_bpp = 2.5;
config.max_dist = 10.0;
all_tests.push_back(config);
}
}
}
}
for (int h0_samp : {1, 2, 3, 4}) {
for (int v0_samp : {1, 2, 3, 4}) {
TestConfig config;
config.input.xsize = 217;
config.input.ysize = 129;
config.jparams.progressive_mode = 2;
config.jparams.h_sampling = {h0_samp, 1, 1};
config.jparams.v_sampling = {v0_samp, 1, 1};
config.max_bpp = 2.0;
config.max_dist = 5.5;
all_tests.push_back(config);
}
}
for (int p = 0; p < 3 + NumTestScanScripts(); ++p) {
for (int samp : {1, 2}) {
for (int quality : {100, 90, 1}) {
for (int r : {0, 1024, 1}) {
for (int optimize : {0, 1}) {
bool progressive = p == 1 || p == 2 || p > 4;
if (progressive && !optimize) continue;
TestConfig config;
config.input.xsize = 273;
config.input.ysize = 265;
config.jparams.progressive_mode = p;
if (!progressive) {
config.jparams.optimize_coding = optimize;
}
config.jparams.h_sampling = {samp, 1, 1};
config.jparams.v_sampling = {samp, 1, 1};
config.jparams.quality = quality;
config.jparams.restart_interval = r;
config.max_bpp = quality == 100 ? 8.0 : 1.9;
if (r == 1) {
config.max_bpp += 10.0;
}
config.max_dist = quality == 1 ? 20.0 : 2.1;
all_tests.push_back(config);
}
}
}
}
}
{
TestConfig config;
config.jparams.simple_progression = true;
config.max_bpp = 1.48;
config.max_dist = 2.0;
all_tests.push_back(config);
}
{
TestConfig config;
config.input_mode = COEFFICIENTS;
config.jparams.h_sampling = {2, 1, 1};
config.jparams.v_sampling = {2, 1, 1};
config.jparams.progressive_mode = 0;
config.jparams.optimize_coding = 0;
config.max_bpp = 16;
config.max_dist = 0.0;
all_tests.push_back(config);
}
{
TestConfig config;
config.jparams.xyb_mode = true;
config.jparams.progressive_mode = 2;
config.max_bpp = 1.5;
config.max_dist = 3.5;
all_tests.push_back(config);
}
{
TestConfig config;
config.jparams.libjpeg_mode = true;
config.max_bpp = 2.1;
config.max_dist = 1.7;
config.jparams.h_sampling = {1, 1, 1};
config.jparams.v_sampling = {1, 1, 1};
all_tests.push_back(config);
}
for (J_COLOR_SPACE in_color_space :
{JCS_RGB, JCS_YCbCr, JCS_GRAYSCALE, JCS_EXT_RGB, JCS_EXT_BGR,
JCS_EXT_RGBA, JCS_EXT_BGRA, JCS_EXT_ARGB, JCS_EXT_ABGR}) {
for (J_COLOR_SPACE jpeg_color_space : {JCS_RGB, JCS_YCbCr, JCS_GRAYSCALE}) {
if (jpeg_color_space == JCS_RGB && in_color_space >= JCS_YCbCr) continue;
TestConfig config;
config.input.xsize = config.input.ysize = 256;
config.input.color_space = in_color_space;
config.jparams.set_jpeg_colorspace = true;
config.jparams.jpeg_color_space = jpeg_color_space;
config.jparams.h_sampling = {1, 1, 1};
config.jparams.v_sampling = {1, 1, 1};
config.max_bpp = jpeg_color_space == JCS_RGB ? 4.5 : 1.85;
config.max_dist = jpeg_color_space == JCS_RGB ? 1.4 : 2.05;
all_tests.push_back(config);
}
}
for (J_COLOR_SPACE in_color_space : {JCS_CMYK, JCS_YCCK}) {
for (J_COLOR_SPACE jpeg_color_space : {JCS_CMYK, JCS_YCCK}) {
if (jpeg_color_space == JCS_CMYK && in_color_space == JCS_YCCK) continue;
TestConfig config;
config.input.xsize = config.input.ysize = 256;
config.input.color_space = in_color_space;
if (in_color_space != jpeg_color_space) {
config.jparams.set_jpeg_colorspace = true;
config.jparams.jpeg_color_space = jpeg_color_space;
}
config.jparams.h_sampling = {1, 1, 1, 1};
config.jparams.v_sampling = {1, 1, 1, 1};
config.max_bpp = jpeg_color_space == JCS_CMYK ? 4.0 : 3.6;
config.max_dist = jpeg_color_space == JCS_CMYK ? 1.2 : 1.5;
all_tests.push_back(config);
}
}
{
TestConfig config;
config.input.color_space = JCS_YCbCr;
config.max_bpp = 1.6;
config.max_dist = 1.35;
config.jparams.h_sampling = {1, 1, 1};
config.jparams.v_sampling = {1, 1, 1};
all_tests.push_back(config);
}
for (bool xyb : {false, true}) {
TestConfig config;
config.input.color_space = JCS_GRAYSCALE;
config.jparams.xyb_mode = xyb;
config.max_bpp = 1.35;
config.max_dist = 1.4;
all_tests.push_back(config);
}
for (int channels = 1; channels <= 4; ++channels) {
TestConfig config;
config.input.color_space = JCS_UNKNOWN;
config.input.components = channels;
config.max_bpp = 1.35 * channels;
config.max_dist = 1.4;
all_tests.push_back(config);
}
for (size_t r : {1, 3, 17, 1024}) {
for (int progr : {0, 2}) {
TestConfig config;
config.jparams.restart_interval = r;
config.jparams.progressive_mode = progr;
config.max_bpp = 1.58 + 5.5 / r;
config.max_dist = 2.2;
all_tests.push_back(config);
}
}
for (size_t rr : {1, 3, 8, 100}) {
TestConfig config;
config.jparams.restart_in_rows = rr;
config.max_bpp = 1.6;
config.max_dist = 2.2;
all_tests.push_back(config);
}
for (int type : {0, 1, 10, 100, 10000}) {
for (int scale : {1, 50, 100, 200, 500}) {
for (bool add_raw : {false, true}) {
for (bool baseline : {true, false}) {
if (!baseline && (add_raw || type * scale < 25500)) continue;
TestConfig config;
config.input.xsize = 64;
config.input.ysize = 64;
CustomQuantTable table;
table.table_type = type;
table.scale_factor = scale;
table.force_baseline = baseline;
table.add_raw = add_raw;
table.Generate();
config.jparams.optimize_coding = 1;
config.jparams.h_sampling = {1, 1, 1};
config.jparams.v_sampling = {1, 1, 1};
config.jparams.quant_tables.push_back(table);
config.jparams.quant_indexes = {0, 0, 0};
float q = (type == 0 ? 16 : type) * scale * 0.01f;
if (baseline && !add_raw) q = std::max(1.0f, std::min(255.0f, q));
config.max_bpp = 1.5f + 25.0f / q;
config.max_dist = 0.6f + 0.25f * q;
all_tests.push_back(config);
}
}
}
}
for (int qidx = 0; qidx < 8; ++qidx) {
if (qidx == 3) continue;
TestConfig config;
config.input.xsize = 256;
config.input.ysize = 256;
config.jparams.quant_indexes = {(qidx >> 2) & 1, (qidx >> 1) & 1,
(qidx >> 0) & 1};
config.jparams.h_sampling = {1, 1, 1};
config.jparams.v_sampling = {1, 1, 1};
config.max_bpp = 2.25;
config.max_dist = 2.8;
all_tests.push_back(config);
}
for (int qidx = 0; qidx < 8; ++qidx) {
for (int slot_idx = 0; slot_idx < 2; ++slot_idx) {
if (qidx == 0 && slot_idx == 0) continue;
TestConfig config;
config.input.xsize = 256;
config.input.ysize = 256;
config.jparams.quant_indexes = {(qidx >> 2) & 1, (qidx >> 1) & 1,
(qidx >> 0) & 1};
config.jparams.h_sampling = {1, 1, 1};
config.jparams.v_sampling = {1, 1, 1};
CustomQuantTable table;
table.slot_idx = slot_idx;
table.Generate();
config.jparams.quant_tables.push_back(table);
config.max_bpp = 2.3;
config.max_dist = 2.9;
all_tests.push_back(config);
}
}
for (int qidx = 0; qidx < 8; ++qidx) {
for (bool xyb : {false, true}) {
TestConfig config;
config.input.xsize = 256;
config.input.ysize = 256;
config.jparams.xyb_mode = xyb;
config.jparams.quant_indexes = {(qidx >> 2) & 1, (qidx >> 1) & 1,
(qidx >> 0) & 1};
if (!xyb) {
config.jparams.h_sampling = {1, 1, 1};
config.jparams.v_sampling = {1, 1, 1};
}
{
CustomQuantTable table;
table.slot_idx = 0;
table.Generate();
config.jparams.quant_tables.push_back(table);
}
{
CustomQuantTable table;
table.slot_idx = 1;
table.table_type = 20;
table.Generate();
config.jparams.quant_tables.push_back(table);
}
config.max_bpp = 2.0;
config.max_dist = 3.85;
all_tests.push_back(config);
}
}
for (bool xyb : {false, true}) {
TestConfig config;
config.input.xsize = 256;
config.input.ysize = 256;
config.jparams.xyb_mode = xyb;
config.jparams.quant_indexes = {0, 1, 2};
if (!xyb) {
config.jparams.h_sampling = {1, 1, 1};
config.jparams.v_sampling = {1, 1, 1};
}
{
CustomQuantTable table;
table.slot_idx = 0;
table.Generate();
config.jparams.quant_tables.push_back(table);
}
{
CustomQuantTable table;
table.slot_idx = 1;
table.table_type = 20;
table.Generate();
config.jparams.quant_tables.push_back(table);
}
{
CustomQuantTable table;
table.slot_idx = 2;
table.table_type = 30;
table.Generate();
config.jparams.quant_tables.push_back(table);
}
config.max_bpp = 1.5;
config.max_dist = 3.75;
all_tests.push_back(config);
}
{
TestConfig config;
config.jparams.comp_ids = {7, 17, 177};
config.input.xsize = config.input.ysize = 128;
config.max_bpp = 2.25;
config.max_dist = 2.4;
all_tests.push_back(config);
}
for (int override_JFIF : {-1, 0, 1}) {
for (int override_Adobe : {-1, 0, 1}) {
if (override_JFIF == -1 && override_Adobe == -1) continue;
TestConfig config;
config.input.xsize = config.input.ysize = 128;
config.jparams.override_JFIF = override_JFIF;
config.jparams.override_Adobe = override_Adobe;
config.max_bpp = 2.25;
config.max_dist = 2.4;
all_tests.push_back(config);
}
}
{
TestConfig config;
config.input.xsize = config.input.ysize = 256;
config.max_bpp = 1.85;
config.max_dist = 2.05;
config.jparams.add_marker = true;
all_tests.push_back(config);
}
for (size_t icc_size : {728, 70000, 1000000}) {
TestConfig config;
config.input.xsize = config.input.ysize = 256;
config.max_dist = 2.05;
config.jparams.icc.resize(icc_size);
for (size_t i = 0; i < icc_size; ++i) {
config.jparams.icc[i] = (i * 17) & 0xff;
}
all_tests.push_back(config);
}
for (JpegIOMode input_mode : {PIXELS, RAW_DATA, COEFFICIENTS}) {
TestConfig config;
config.input.xsize = config.input.ysize = 256;
config.input_mode = input_mode;
if (input_mode == RAW_DATA) {
config.input.color_space = JCS_YCbCr;
}
config.jparams.progressive_mode = 0;
config.jparams.optimize_coding = 0;
config.jparams.h_sampling = {1, 1, 1};
config.jparams.v_sampling = {1, 1, 1};
config.max_bpp = 1.85;
config.max_dist = 2.05;
if (input_mode == COEFFICIENTS) {
config.max_bpp = 3.5;
config.max_dist = 0.0;
}
all_tests.push_back(config);
config.jparams.use_flat_dc_luma_code = true;
all_tests.push_back(config);
}
for (int xsize : {640, 641, 648, 649}) {
for (int ysize : {640, 641, 648, 649}) {
for (int h_sampling : {1, 2}) {
for (int v_sampling : {1, 2}) {
if (h_sampling == 1 && v_sampling == 1) continue;
for (int progr : {0, 2}) {
TestConfig config;
config.input.xsize = xsize;
config.input.ysize = ysize;
config.input.color_space = JCS_YCbCr;
config.jparams.h_sampling = {h_sampling, 1, 1};
config.jparams.v_sampling = {v_sampling, 1, 1};
config.jparams.progressive_mode = progr;
config.input_mode = RAW_DATA;
config.max_bpp = 1.75;
config.max_dist = 2.0;
all_tests.push_back(config);
config.input_mode = COEFFICIENTS;
if (xsize & 1) {
config.jparams.add_marker = true;
}
config.max_bpp = 24.0;
all_tests.push_back(config);
}
}
}
}
}
for (JpegliDataType data_type : {JPEGLI_TYPE_UINT16, JPEGLI_TYPE_FLOAT}) {
for (JpegliEndianness endianness :
{JPEGLI_LITTLE_ENDIAN, JPEGLI_BIG_ENDIAN, JPEGLI_NATIVE_ENDIAN}) {
J_COLOR_SPACE colorspace[4] = {JCS_GRAYSCALE, JCS_UNKNOWN, JCS_RGB,
JCS_CMYK};
float max_bpp[4] = {1.32, 2.7, 1.6, 4.0};
for (int channels = 1; channels <= 4; ++channels) {
TestConfig config;
config.input.data_type = data_type;
config.input.endianness = endianness;
config.input.components = channels;
config.input.color_space = colorspace[channels - 1];
config.max_bpp = max_bpp[channels - 1];
config.max_dist = 2.2;
all_tests.push_back(config);
}
}
}
for (int smoothing : {1, 5, 50, 100}) {
for (int h_sampling : {1, 2}) {
for (int v_sampling : {1, 2}) {
TestConfig config;
config.input.xsize = 257;
config.input.ysize = 265;
config.jparams.smoothing_factor = smoothing;
config.jparams.h_sampling = {h_sampling, 1, 1};
config.jparams.v_sampling = {v_sampling, 1, 1};
config.max_bpp = 1.85;
config.max_dist = 3.05f;
all_tests.push_back(config);
}
}
}
return all_tests;
};
std::ostream& operator<<(std::ostream& os, const TestConfig& c) {
os << c.input;
os << c.jparams;
if (c.input_mode == RAW_DATA) {
os << "RawDataIn";
} else if (c.input_mode == COEFFICIENTS) {
os << "WriteCoeffs";
}
return os;
}
std::string TestDescription(
const testing::TestParamInfo<EncodeAPITestParam::ParamType>& info) {
std::stringstream name;
name << info.param;
return name.str();
}
JPEGLI_INSTANTIATE_TEST_SUITE_P(EncodeAPITest, EncodeAPITestParam,
testing::ValuesIn(GenerateTests()),
TestDescription);
} // namespace
} // namespace jpegli