Public_Skunkworks/singe
Public_Skunkworks/singe
1
0
Fork 0
Code Issues 12 Pull requests Projects Releases Packages Wiki Activity Actions
singe/thirdparty/SDL2_image/external/libjxl/tools/cjxl.cc
Scott Duensing 94f83e7608 Major reorganization to start work on Singe 2.10.
2023-10-23 19:38:18 -05:00

851 lines
32 KiB
C++
Raw Blame History

// 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 "tools/cjxl.h"
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <algorithm>
#include <string>
#include <utility>
#include <vector>
#include "lib/extras/codec.h"
#if JPEGXL_ENABLE_JPEG
#include "lib/extras/codec_jpg.h"
#endif
#include "lib/extras/time.h"
#include "lib/jxl/aux_out.h"
#include "lib/jxl/base/cache_aligned.h"
#include "lib/jxl/base/compiler_specific.h"
#include "lib/jxl/base/data_parallel.h"
#include "lib/jxl/base/padded_bytes.h"
#include "lib/jxl/base/profiler.h"
#include "lib/jxl/base/status.h"
#include "lib/jxl/base/thread_pool_internal.h"
#include "lib/jxl/codec_in_out.h"
#include "lib/jxl/common.h"
#include "lib/jxl/enc_cache.h"
#include "lib/jxl/enc_file.h"
#include "lib/jxl/enc_params.h"
#include "lib/jxl/frame_header.h"
#include "lib/jxl/image.h"
#include "lib/jxl/image_bundle.h"
#include "lib/jxl/modular/encoding/encoding.h"
#include "tools/args.h"
#include "tools/box/box.h"
#include "tools/cpu/cpu.h"
#include "tools/speed_stats.h"
namespace jpegxl {
namespace tools {
namespace {
static inline bool ParseSpeedTier(const char* arg, jxl::SpeedTier* out) {
return jxl::ParseSpeedTier(arg, out);
}
static inline bool ParseColorTransform(const char* arg,
jxl::ColorTransform* out) {
size_t value = 0;
bool ret = ParseUnsigned(arg, &value);
if (ret && value > 2) ret = false;
if (ret) *out = jxl::ColorTransform(value);
return ret;
}
static inline bool ParseIntensityTarget(const char* arg, float* out) {
return ParseFloat(arg, out) && *out > 0;
}
static inline bool ParsePhotonNoiseParameter(const char* arg, float* out) {
return strncmp(arg, "ISO", 3) == 0 && ParseFloat(arg + 3, out) && *out > 0;
}
// Proposes a distance to try for a given bpp target. This could depend
// on the entropy in the image, too, but let's start with something.
static double ApproximateDistanceForBPP(double bpp) {
return 1.704 * pow(bpp, -0.804);
}
jxl::Status LoadSaliencyMap(const std::string& filename_heatmap,
jxl::ThreadPool* pool, jxl::ImageF* out_map) {
jxl::CodecInOut io_heatmap;
if (!SetFromFile(filename_heatmap, jxl::ColorHints(), &io_heatmap, pool)) {
return JXL_FAILURE("Could not load heatmap.");
}
*out_map = std::move(io_heatmap.Main().color()->Plane(0));
return true;
}
// Search algorithm for modular mode instead of Butteraugli distance.
void SetModularQualityForBitrate(jxl::ThreadPoolInternal* pool,
const size_t pixels, const double target_size,
CompressArgs* args) {
JXL_ASSERT(args->params.modular_mode);
CompressArgs s = *args; // Args for search.
float quality = -100 + target_size * 8.0 / pixels * 50;
if (quality > 100.f) quality = 100.f;
s.params.target_size = 0;
s.params.target_bitrate = 0;
double best_loss = 1e99;
float best_quality = quality;
float best_below = -10000.f;
float best_below_size = 0;
float best_above = 200.f;
float best_above_size = pixels * 15.f;
jxl::CodecInOut io;
double decode_mps = 0;
if (!LoadAll(*args, pool, &io, &decode_mps)) {
s.params.quality_pair = std::make_pair(quality, quality);
printf("couldn't load image\n");
return;
}
for (int i = 0; i < 10; ++i) {
s.params.quality_pair = std::make_pair(quality, quality);
jxl::PaddedBytes candidate;
bool ok =
CompressJxl(io, decode_mps, pool, s, &candidate, /*print_stats=*/false);
if (!ok) {
printf(
"Compression error occurred during the search for best size."
" Trying with quality %.1f\n",
quality);
break;
}
printf("Quality %.2f yields %6zu bytes, %.3f bpp.\n", quality,
candidate.size(), candidate.size() * 8.0 / pixels);
const double ratio = static_cast<double>(candidate.size()) / target_size;
const double loss = std::abs(1.0 - ratio);
if (best_loss > loss) {
best_quality = quality;
best_loss = loss;
if (loss < 0.01f) break;
}
if (quality == 100.f && ratio < 1.f) break; // can't spend more bits
if (ratio > 1.f && quality < best_above) {
best_above = quality;
best_above_size = candidate.size();
}
if (ratio < 1.f && quality > best_below) {
best_below = quality;
best_below_size = candidate.size();
}
float t =
(target_size - best_below_size) / (best_above_size - best_below_size);
if (best_above > 100.f && ratio < 1.f) {
quality = (quality + 105) / 2;
} else if (best_above - best_below > 1000 && ratio > 1.f) {
quality -= 1000;
} else {
quality = best_above * t + best_below * (1.f - t);
}
if (quality >= 100.f) quality = 100.f;
}
args->params.quality_pair = std::make_pair(best_quality, best_quality);
args->params.target_bitrate = 0;
args->params.target_size = 0;
}
void SetParametersForSizeOrBitrate(jxl::ThreadPoolInternal* pool,
const size_t pixels, CompressArgs* args) {
CompressArgs s = *args; // Args for search.
// If fixed size, convert to bitrate.
if (s.params.target_size > 0) {
s.params.target_bitrate = s.params.target_size * 8.0 / pixels;
s.params.target_size = 0;
}
const double target_size = s.params.target_bitrate * (1 / 8.) * pixels;
if (args->params.modular_mode) {
SetModularQualityForBitrate(pool, pixels, target_size, args);
return;
}
double dist = ApproximateDistanceForBPP(s.params.target_bitrate);
s.params.target_bitrate = 0;
double best_dist = 1.0;
double best_loss = 1e99;
jxl::CodecInOut io;
double decode_mps = 0;
if (!LoadAll(*args, pool, &io, &decode_mps)) {
s.params.butteraugli_distance = static_cast<float>(dist);
printf("couldn't load image\n");
return;
}
for (int i = 0; i < 7; ++i) {
s.params.butteraugli_distance = static_cast<float>(dist);
jxl::PaddedBytes candidate;
bool ok =
CompressJxl(io, decode_mps, pool, s, &candidate, /*print_stats=*/false);
if (!ok) {
printf(
"Compression error occurred during the search for best size. "
"Trying with butteraugli distance %.15g\n",
best_dist);
break;
}
printf("Butteraugli distance %.3f yields %6zu bytes, %.3f bpp.\n", dist,
candidate.size(), candidate.size() * 8.0 / pixels);
const double ratio = static_cast<double>(candidate.size()) / target_size;
const double loss = std::max(ratio, 1.0 / std::max(ratio, 1e-30));
if (best_loss > loss) {
best_dist = dist;
best_loss = loss;
}
dist *= ratio;
if (dist < 0.01) {
dist = 0.01;
}
if (dist >= 16.0) {
dist = 16.0;
}
}
args->params.butteraugli_distance = static_cast<float>(best_dist);
args->params.target_bitrate = 0;
args->params.target_size = 0;
}
const char* ModeFromArgs(const CompressArgs& args) {
if (args.jpeg_transcode) return "JPEG";
if (args.params.modular_mode) return "Modular";
return "VarDCT";
}
std::string QualityFromArgs(const CompressArgs& args) {
char buf[100];
if (args.jpeg_transcode) {
snprintf(buf, sizeof(buf), "lossless transcode");
} else if (args.params.modular_mode) {
if (args.params.quality_pair.first == 100 &&
args.params.quality_pair.second == 100) {
snprintf(buf, sizeof(buf), "lossless");
} else if (args.params.quality_pair.first !=
args.params.quality_pair.second) {
snprintf(buf, sizeof(buf), "Q%.2f,%.2f", args.params.quality_pair.first,
args.params.quality_pair.second);
} else {
snprintf(buf, sizeof(buf), "Q%.2f", args.params.quality_pair.first);
}
} else {
snprintf(buf, sizeof(buf), "d%.3f", args.params.butteraugli_distance);
}
return buf;
}
void PrintMode(jxl::ThreadPoolInternal* pool, const jxl::CodecInOut& io,
const double decode_mps, const CompressArgs& args) {
const char* mode = ModeFromArgs(args);
const char* speed = SpeedTierName(args.params.speed_tier);
const std::string quality = QualityFromArgs(args);
fprintf(stderr,
"Read %zux%zu image, %.1f MP/s\n"
"Encoding [%s%s, %s, %s",
io.xsize(), io.ysize(), decode_mps,
(args.use_container ? "Container | " : ""), mode, quality.c_str(),
speed);
if (args.use_container) {
if (args.jpeg_transcode) fprintf(stderr, " | JPEG reconstruction data");
if (!io.blobs.exif.empty())
fprintf(stderr, " | %zu-byte Exif", io.blobs.exif.size());
if (!io.blobs.xmp.empty())
fprintf(stderr, " | %zu-byte XMP", io.blobs.xmp.size());
if (!io.blobs.jumbf.empty())
fprintf(stderr, " | %zu-byte JUMBF", io.blobs.jumbf.size());
}
fprintf(stderr, "], %zu threads.\n", pool->NumWorkerThreads());
}
} // namespace
void CompressArgs::AddCommandLineOptions(CommandLineParser* cmdline) {
// Positional arguments.
cmdline->AddPositionalOption("INPUT", /* required = */ true,
"the input can be PNG"
#if JPEGXL_ENABLE_APNG
", APNG"
#endif
#if JPEGXL_ENABLE_GIF
", GIF"
#endif
#if JPEGXL_ENABLE_JPEG
", JPEG"
#endif
#if JPEGXL_ENABLE_EXR
", EXR"
#endif
", PPM, PFM, or PGX",
&file_in);
cmdline->AddPositionalOption(
"OUTPUT", /* required = */ true,
"the compressed JXL output file (can be omitted for benchmarking)",
&file_out);
// Flags.
// TODO(lode): also add options to add exif/xmp/other metadata in the
// container.
// TODO(lode): decide on good name for this flag: box, container, bmff, ...
cmdline->AddOptionFlag(
'\0', "container",
"Always encode using container format (default: only if needed)",
&use_container, &SetBooleanTrue, 1);
cmdline->AddOptionFlag('\0', "strip",
"Do not encode using container format (strips "
"Exif/XMP/JPEG bitstream reconstruction data)",
&no_container, &SetBooleanTrue, 2);
// Target distance/size/bpp
opt_distance_id = cmdline->AddOptionValue(
'd', "distance", "maxError",
("Max. butteraugli distance, lower = higher quality. Range: 0 .. 25.\n"
" 0.0 = mathematically lossless. Default for already-lossy input "
"(JPEG/GIF).\n"
" 1.0 = visually lossless. Default for other input.\n"
" Recommended range: 0.5 .. 3.0."),
&params.butteraugli_distance, &ParseFloat);
opt_target_size_id = cmdline->AddOptionValue(
'\0', "target_size", "N",
("Aim at file size of N bytes.\n"
" Compresses to 1 % of the target size in ideal conditions.\n"
" Runs the same algorithm as --target_bpp"),
&params.target_size, &ParseUnsigned, 1);
opt_target_bpp_id = cmdline->AddOptionValue(
'\0', "target_bpp", "BPP",
("Aim at file size that has N bits per pixel.\n"
" Compresses to 1 % of the target BPP in ideal conditions."),
&params.target_bitrate, &ParseFloat, 1);
// High-level options
opt_quality_id = cmdline->AddOptionValue(
'q', "quality", "QUALITY",
"Quality setting (is remapped to --distance). Range: -inf .. 100.\n"
" 100 = mathematically lossless. Default for already-lossy input "
"(JPEG/GIF).\n Positive quality values roughly match libjpeg quality.",
&quality, &ParseFloat);
cmdline->AddOptionValue(
'e', "effort", "EFFORT",
"Encoder effort setting. Range: 1 .. 9.\n"
" Default: 7. Higher number is more effort (slower).",
&params.speed_tier, &ParseSpeedTier);
cmdline->AddOptionValue(
's', "speed", "ANIMAL",
"Deprecated synonym for --effort. Valid values are:\n"
" lightning (1), thunder, falcon, cheetah, hare, wombat, squirrel, "
"kitten, tortoise (9)\n"
" Default: squirrel. Values are in order from faster to slower.\n",
&params.speed_tier, &ParseSpeedTier, 2);
cmdline->AddOptionValue('\0', "faster_decoding", "AMOUNT",
"Favour higher decoding speed. 0 = default, higher "
"values give higher speed at the expense of quality",
&params.decoding_speed_tier, &ParseUnsigned, 2);
cmdline->AddOptionFlag('p', "progressive",
"Enable progressive/responsive decoding.",
&progressive, &SetBooleanTrue);
cmdline->AddOptionFlag('\0', "premultiply",
"Force premultiplied (associated) alpha.",
&force_premultiplied, &SetBooleanTrue, 1);
cmdline->AddOptionValue('\0', "keep_invisible", "0|1",
"force disable/enable preserving color of invisible "
"pixels (default: 1 if lossless, 0 if lossy).",
&params.keep_invisible, &ParseOverride, 1);
cmdline->AddOptionFlag('\0', "centerfirst",
"Put center groups first in the compressed file.",
&params.centerfirst, &SetBooleanTrue, 1);
cmdline->AddOptionValue('\0', "center_x", "0..XSIZE",
"Put center groups first in the compressed file.",
&params.center_x, &ParseUnsigned, 1);
cmdline->AddOptionValue('\0', "center_y", "0..YSIZE",
"Put center groups first in the compressed file.",
&params.center_y, &ParseUnsigned, 1);
// Flags.
cmdline->AddOptionFlag('\0', "progressive_ac",
"Use the progressive mode for AC.",
&params.progressive_mode, &SetBooleanTrue, 1);
cmdline->AddOptionFlag('\0', "qprogressive_ac",
"Use the progressive mode for AC.",
&params.qprogressive_mode, &SetBooleanTrue, 1);
cmdline->AddOptionValue('\0', "progressive_dc", "num_dc_frames",
"Use progressive mode for DC.",
&params.progressive_dc, &ParseSigned, 1);
cmdline->AddOptionFlag('m', "modular",
"Use the modular mode (lossy / lossless).",
&params.modular_mode, &SetBooleanTrue, 1);
cmdline->AddOptionFlag('\0', "use_new_heuristics",
"use new and not yet ready encoder heuristics",
&params.use_new_heuristics, &SetBooleanTrue, 2);
// JPEG modes: parallel Brunsli, pixels to JPEG, or JPEG to Brunsli
cmdline->AddOptionFlag('j', "jpeg_transcode",
"Do lossy transcode of input JPEG file (decode to "
"pixels instead of doing lossless transcode).",
&jpeg_transcode, &SetBooleanFalse, 1);
opt_num_threads_id = cmdline->AddOptionValue(
'\0', "num_threads", "N", "number of worker threads (zero = none).",
&num_threads, &ParseUnsigned, 1);
cmdline->AddOptionValue('\0', "num_reps", "N", "how many times to compress.",
&num_reps, &ParseUnsigned, 1);
cmdline->AddOptionValue('\0', "noise", "0|1",
"force disable/enable noise generation.",
&params.noise, &ParseOverride, 1);
cmdline->AddOptionValue(
'\0', "photon_noise", "ISO3200",
"Set the noise to approximately what it would be at a given nominal "
"exposure on a 35mm camera. For formats other than 35mm, or when the "
"whole sensor was not used, you can multiply the ISO value by the "
"equivalence ratio squared, for example by 2.25 for an APS-C camera.",
&params.photon_noise_iso, &ParsePhotonNoiseParameter, 1);
cmdline->AddOptionValue('\0', "dots", "0|1",
"force disable/enable dots generation.", &params.dots,
&ParseOverride, 1);
cmdline->AddOptionValue('\0', "patches", "0|1",
"force disable/enable patches generation.",
&params.patches, &ParseOverride, 1);
cmdline->AddOptionValue(
'\0', "resampling", "0|1|2|4|8",
"Subsample all color channels by this factor, or use 0 to choose the "
"resampling factor based on distance.",
&params.resampling, &ParseUnsigned, 0);
cmdline->AddOptionValue(
'\0', "ec_resampling", "1|2|4|8",
"Subsample all extra channels by this factor. If this value is smaller "
"than the resampling of color channels, it will be increased to match.",
&params.ec_resampling, &ParseUnsigned, 2);
cmdline->AddOptionFlag('\0', "already_downsampled",
"Do not downsample the given input before encoding, "
"but still signal that the decoder should upsample.",
&params.already_downsampled, &SetBooleanTrue, 2);
cmdline->AddOptionValue(
'\0', "epf", "-1..3",
"Edge preserving filter level (-1 = choose based on quality, default)",
&params.epf, &ParseSigned, 1);
cmdline->AddOptionValue('\0', "gaborish", "0|1",
"force disable/enable gaborish.", &params.gaborish,
&ParseOverride, 1);
opt_intensity_target_id = cmdline->AddOptionValue(
'\0', "intensity_target", "N",
("Intensity target of monitor in nits, higher\n"
" results in higher quality image. Must be strictly positive.\n"
" Default is 255 for standard images, 4000 for input images known to\n"
" to have PQ or HLG transfer function."),
&intensity_target, &ParseIntensityTarget, 1);
cmdline->AddOptionValue('\0', "saliency_num_progressive_steps", "N", nullptr,
&params.saliency_num_progressive_steps,
&ParseUnsigned, 2);
cmdline->AddOptionValue('\0', "saliency_map_filename", "STRING", nullptr,
&saliency_map_filename, &ParseString, 2);
cmdline->AddOptionValue('\0', "saliency_threshold", "0..1", nullptr,
&params.saliency_threshold, &ParseFloat, 2);
cmdline->AddOptionValue(
'x', "dec-hints", "key=value",
"color_space indicates the ColorEncoding, see Description();\n"
"icc_pathname refers to a binary file containing an ICC profile.",
&color_hints, &ParseAndAppendKeyValue, 1);
cmdline->AddOptionValue(
'\0', "override_bitdepth", "0=use from image, 1-32=override",
"If nonzero, store the given bit depth in the JPEG XL file metadata"
" (1-32), instead of using the bit depth from the original input"
" image.",
&override_bitdepth, &ParseUnsigned, 2);
opt_color_id = cmdline->AddOptionValue(
'c', "colortransform", "0..2", "0=XYB, 1=None, 2=YCbCr",
&params.color_transform, &ParseColorTransform, 2);
// modular mode options
cmdline->AddOptionValue(
'Q', "mquality", "luma_q[,chroma_q]",
"[modular encoding] lossy 'quality' (100=lossless, lower is more lossy)",
&params.quality_pair, &ParseFloatPair, 1);
cmdline->AddOptionValue(
'I', "iterations", "F",
"[modular encoding] fraction of pixels used to learn MA trees "
"(default=0.5, try 0 for no MA and fast decode)",
&params.options.nb_repeats, &ParseFloat, 2);
cmdline->AddOptionValue(
'C', "colorspace", "K",
("[modular encoding] color transform: 0=RGB, 1=YCoCg, "
"2-37=RCT (default: try several, depending on speed)"),
&params.colorspace, &ParseSigned, 1);
opt_m_group_size_id = cmdline->AddOptionValue(
'g', "group-size", "K",
("[modular encoding] set group size to 128 << K "
"(default: 1 or 2)"),
&params.modular_group_size_shift, &ParseUnsigned, 1);
cmdline->AddOptionValue(
'P', "predictor", "K",
"[modular encoding] predictor(s) to use: 0=zero, "
"1=left, 2=top, 3=avg0, 4=select, 5=gradient, 6=weighted, "
"7=topright, 8=topleft, 9=leftleft, 10=avg1, 11=avg2, 12=avg3, "
"13=toptop predictive average "
"14=mix 5 and 6, 15=mix everything. Default 14, at slowest speed "
"default 15",
&params.options.predictor, &ParsePredictor, 1);
cmdline->AddOptionValue(
'E', "extra-properties", "K",
"[modular encoding] number of extra MA tree properties to use",
&params.options.max_properties, &ParseSigned, 2);
cmdline->AddOptionValue('\0', "palette", "K",
"[modular encoding] use a palette if image has at "
"most K colors (default: 1024)",
&params.palette_colors, &ParseSigned, 1);
cmdline->AddOptionFlag(
'\0', "lossy-palette",
"[modular encoding] quantize to a palette that has fewer entries than "
"would be necessary for perfect preservation; for the time being, it is "
"recommended to set --palette=0 with this option to use the default "
"palette only",
&params.lossy_palette, &SetBooleanTrue, 1);
cmdline->AddOptionValue(
'X', "pre-compact", "PERCENT",
("[modular encoding] compact channels (globally) if ratio "
"used/range is below this (default: 80%)"),
&params.channel_colors_pre_transform_percent, &ParseFloat, 2);
cmdline->AddOptionValue(
'Y', "post-compact", "PERCENT",
("[modular encoding] compact channels (per-group) if ratio "
"used/range is below this (default: 80%)"),
&params.channel_colors_percent, &ParseFloat, 2);
cmdline->AddOptionValue('R', "responsive", "K",
"[modular encoding] do Squeeze transform, 0=false, "
"1=true (default: true if lossy, false if lossless)",
&params.responsive, &ParseSigned, 1);
cmdline->AddOptionFlag('V', "version", "Print version number and exit",
&version, &SetBooleanTrue, 1);
cmdline->AddOptionFlag('\0', "quiet", "Be more silent", &quiet,
&SetBooleanTrue, 1);
cmdline->AddOptionValue('\0', "print_profile", "0|1",
"Print timing information before exiting",
&print_profile, &ParseOverride, 1);
cmdline->AddOptionFlag(
'v', "verbose",
"Verbose output; can be repeated, also applies to help (!).",
&params.verbose, &SetBooleanTrue);
}
jxl::Status CompressArgs::ValidateArgs(const CommandLineParser& cmdline) {
params.file_in = file_in;
params.file_out = file_out;
if (file_in == nullptr) {
fprintf(stderr, "Missing INPUT filename.\n");
return false;
}
bool got_distance = cmdline.GetOption(opt_distance_id)->matched();
bool got_target_size = cmdline.GetOption(opt_target_size_id)->matched();
bool got_target_bpp = cmdline.GetOption(opt_target_bpp_id)->matched();
bool got_quality = cmdline.GetOption(opt_quality_id)->matched();
bool got_intensity_target =
cmdline.GetOption(opt_intensity_target_id)->matched();
if (got_quality) {
default_settings = false;
if (quality < 100) jpeg_transcode = false;
// Quality settings roughly match libjpeg qualities.
if (quality < 7 || quality == 100 || params.modular_mode) {
if (jpeg_transcode == false) params.modular_mode = true;
// Internal modular quality to roughly match VarDCT size.
if (quality < 7) {
params.quality_pair.first = params.quality_pair.second =
std::min(35 + (quality - 7) * 3.0f, 100.0f);
} else {
params.quality_pair.first = params.quality_pair.second =
std::min(35 + (quality - 7) * 65.f / 93.f, 100.0f);
}
} else {
if (quality >= 30) {
params.butteraugli_distance = 0.1 + (100 - quality) * 0.09;
} else {
params.butteraugli_distance =
6.4 + pow(2.5, (30 - quality) / 5.0f) / 6.25f;
}
}
}
if (params.resampling > 1 && !params.already_downsampled)
jpeg_transcode = false;
if (progressive) {
params.qprogressive_mode = true;
params.responsive = 1;
default_settings = false;
}
if (got_target_size || got_target_bpp || got_intensity_target) {
default_settings = false;
}
if (params.progressive_dc < -1 || params.progressive_dc > 2) {
fprintf(stderr, "Invalid/out of range progressive_dc (%d), try -1 to 2.\n",
params.progressive_dc);
return false;
}
if (got_distance) {
constexpr float butteraugli_min_dist = 0.1f;
constexpr float butteraugli_max_dist = 25.0f;
if (!(0 <= params.butteraugli_distance &&
params.butteraugli_distance <= butteraugli_max_dist)) {
fprintf(stderr, "Invalid/out of range distance, try 0 to %g.\n",
butteraugli_max_dist);
return false;
}
if (params.butteraugli_distance > 0) jpeg_transcode = false;
if (params.butteraugli_distance == 0) {
// Use modular for lossless.
if (jpeg_transcode == false) params.modular_mode = true;
} else if (params.butteraugli_distance < butteraugli_min_dist) {
params.butteraugli_distance = butteraugli_min_dist;
}
default_settings = false;
}
if (got_target_bpp || got_target_size) {
jpeg_transcode = false;
}
if (got_target_bpp + got_target_size + got_distance + got_quality > 1) {
fprintf(stderr,
"You can specify only one of '--distance', '-q', "
"'--target_bpp' and '--target_size'. They are all different ways"
" to specify the image quality. When in doubt, use --distance."
" It gives the most visually consistent results.\n");
return false;
}
if (!saliency_map_filename.empty()) {
if (!params.progressive_mode) {
saliency_map_filename.clear();
fprintf(stderr,
"Warning: Specifying --saliency_map_filename only makes sense "
"for --progressive_ac mode.\n");
}
}
if (!params.file_in) {
fprintf(stderr, "Missing input filename.\n");
return false;
}
if (!cmdline.GetOption(opt_color_id)->matched()) {
// default to RGB for lossless modular
if (params.modular_mode) {
if (params.quality_pair.first != 100 ||
params.quality_pair.second != 100) {
params.color_transform = jxl::ColorTransform::kXYB;
} else {
params.color_transform = jxl::ColorTransform::kNone;
}
}
}
if (override_bitdepth > 32) {
fprintf(stderr, "override_bitdepth must be <= 32\n");
return false;
}
if (params.epf > 3) {
fprintf(stderr, "--epf must be in the 0..3 range\n");
return false;
}
// User didn't override num_threads, so we have to compute a default, which
// might fail, so only do so when necessary. Don't just check num_threads != 0
// because the user may have set it to that.
if (!cmdline.GetOption(opt_num_threads_id)->matched()) {
cpu::ProcessorTopology topology;
if (!cpu::DetectProcessorTopology(&topology)) {
// We have seen sporadic failures caused by setaffinity_np.
fprintf(stderr,
"Failed to choose default num_threads; you can avoid this "
"error by specifying a --num_threads N argument.\n");
return false;
}
num_threads = topology.packages * topology.cores_per_package;
}
return true;
}
jxl::Status CompressArgs::ValidateArgsAfterLoad(
const CommandLineParser& cmdline, const jxl::CodecInOut& io) {
if (!ValidateArgs(cmdline)) return false;
bool got_m_group_size = cmdline.GetOption(opt_m_group_size_id)->matched();
if (params.modular_mode && !got_m_group_size) {
// Default modular group size: set to 512 if 256 would be silly
const size_t kThinImageThr = 256 + 64;
const size_t kSmallImageThr = 256 + 128;
if (io.xsize() < kThinImageThr || io.ysize() < kThinImageThr ||
(io.xsize() < kSmallImageThr && io.ysize() < kSmallImageThr)) {
params.modular_group_size_shift = 2;
}
}
if (!io.blobs.exif.empty() || !io.blobs.xmp.empty() ||
!io.blobs.jumbf.empty() || !io.blobs.iptc.empty() || jpeg_transcode) {
use_container = true;
}
if (no_container) use_container = false;
if (jpeg_transcode && params.modular_mode) {
fprintf(stderr,
"Error: cannot do lossless JPEG transcode in modular mode.\n");
return false;
}
if (jpeg_transcode) {
if (params.progressive_mode || params.qprogressive_mode ||
params.progressive_dc > 0) {
fprintf(stderr,
"Error: progressive lossless JPEG transcode is not yet "
"implemented.\n");
return false;
}
}
return true;
}
jxl::Status LoadAll(CompressArgs& args, jxl::ThreadPoolInternal* pool,
jxl::CodecInOut* io, double* decode_mps) {
const double t0 = jxl::Now();
io->target_nits = args.intensity_target;
io->dec_target = (args.jpeg_transcode ? jxl::DecodeTarget::kQuantizedCoeffs
: jxl::DecodeTarget::kPixels);
jxl::Codec input_codec;
if (!SetFromFile(args.params.file_in, args.color_hints, io, nullptr,
&input_codec)) {
fprintf(stderr, "Failed to read image %s.\n", args.params.file_in);
return false;
}
if (input_codec != jxl::Codec::kJPG) args.jpeg_transcode = false;
if (args.jpeg_transcode) args.params.butteraugli_distance = 0;
if (input_codec == jxl::Codec::kGIF && args.default_settings) {
args.params.modular_mode = true;
args.params.quality_pair.first = args.params.quality_pair.second = 100;
}
if (args.override_bitdepth != 0) {
if (args.override_bitdepth == 32) {
io->metadata.m.SetFloat32Samples();
} else {
io->metadata.m.SetUintSamples(args.override_bitdepth);
}
}
if (args.force_premultiplied) {
io->PremultiplyAlpha();
}
jxl::ImageF saliency_map;
if (!args.saliency_map_filename.empty()) {
if (!LoadSaliencyMap(args.saliency_map_filename, pool, &saliency_map)) {
fprintf(stderr, "Failed to read saliency map %s.\n",
args.saliency_map_filename.c_str());
return false;
}
args.params.saliency_map = &saliency_map;
}
const double t1 = jxl::Now();
const size_t pixels = io->xsize() * io->ysize();
*decode_mps = pixels * io->frames.size() * 1E-6 / (t1 - t0);
return true;
}
jxl::Status CompressJxl(jxl::CodecInOut& io, double decode_mps,
jxl::ThreadPoolInternal* pool, CompressArgs& args,
jxl::PaddedBytes* compressed, bool print_stats) {
JXL_CHECK(pool);
const size_t pixels = io.xsize() * io.ysize();
if (args.params.target_size > 0 || args.params.target_bitrate > 0) {
// Slow iterative search for parameters that reach target bpp / size.
SetParametersForSizeOrBitrate(pool, pixels, &args);
}
if (print_stats) PrintMode(pool, io, decode_mps, args);
// Final/actual compression run (possibly repeated for benchmarking).
jxl::AuxOut aux_out;
if (args.inspector_image3f) {
aux_out.SetInspectorImage3F(args.inspector_image3f);
}
SpeedStats stats;
jxl::PassesEncoderState passes_encoder_state;
if (args.params.use_new_heuristics) {
passes_encoder_state.heuristics =
jxl::make_unique<jxl::FastEncoderHeuristics>();
}
for (size_t i = 0; i < args.num_reps; ++i) {
const double t0 = jxl::Now();
jxl::Status ok = false;
if (io.Main().IsJPEG()) {
// TODO(lode): automate this in the encoder. The encoder must in the
// beginning choose to either do all in xyb, or all in non-xyb, write
// that in the xyb_encoded header flag, and persistently keep that state
// to check if every frame uses an allowed color transform.
args.params.color_transform = io.Main().color_transform;
}
ok = EncodeFile(args.params, &io, &passes_encoder_state, compressed,
&aux_out, pool);
if (!ok) {
fprintf(stderr, "Failed to compress to %s.\n", ModeFromArgs(args));
return false;
}
const double t1 = jxl::Now();
stats.NotifyElapsed(t1 - t0);
stats.SetImageSize(io.xsize(), io.ysize());
}
if (print_stats) {
const double bpp =
static_cast<double>(compressed->size() * jxl::kBitsPerByte) / pixels;
fprintf(stderr, "Compressed to %zu bytes (%.3f bpp%s).\n",
compressed->size(), bpp / io.frames.size(),
io.frames.size() == 1 ? "" : "/frame");
JXL_CHECK(stats.Print(args.num_threads));
if (args.params.verbose) {
aux_out.Print(1);
}
}
return true;
}
} // namespace tools
} // namespace jpegxl
Reference in a new issue View git blame Copy permalink