OmaPhoto 1.0.0: the Linux port of Compositor
Release / deb (push) Canceled after 0s
Release / rpm (push) Canceled after 0s
Release / arch (push) Canceled after 0s
Release / publish (push) Canceled after 0s

A layered image editor for Linux and Omarchy, ported from Compositor
(github.com/robbietilton/Compositor), whose Swift source is its
specification. It reads and writes Compositor's .comp projects.

Packages for Ubuntu, Fedora and Arch come from the release workflow;
scripts/install/ holds one install script per distribution family,
and flake.nix serves NixOS.

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
雷电芽衣andClaude committed 2026-09-26 00:44:52 -04:00
commit c864304695
564 files changed
+100804

No files matched your search

+268
View File
@@ -0,0 +1,268 @@
#include "Rendering/DownsampleCache.h"
#include "Rendering/PoolMap.h"
#include "Document/BrushStroke.h"
#include <QThreadPool>
#include <QtConcurrent>
#include <algorithm>
#include <array>
#include <cmath>
#include <cstring>
#include <numbers>
extern "C" {
#include "AdjustPixels.h"
}
namespace {
constexpr int taps = 12;
// Lanczos-3 at half scale, sampled between source pixels.
const std::array<float, taps> &kernel()
{
static const std::array<float, taps> weights = [] {
std::array<double, taps> lobes{};
double sum = 0;
for (int tap = 0; tap < taps; ++tap) {
const double x = std::numbers::pi * (tap - 5.5) / 2;
lobes[tap] = std::sin(x) / x * std::sin(x / 3) / (x / 3);
sum += lobes[tap];
}
std::array<float, taps> result{};
for (int tap = 0; tap < taps; ++tap)
result[tap] = float(lobes[tap] / sum);
return result;
}();
return weights;
}
// A mask's row, one channel: scalar, clamped at the edges.
void filterMaskRow(const uchar *row, int width, float *line, int outWidth)
{
const float *const weights = kernel().data();
for (int x = 0; x < outWidth; ++x) {
float sum = 0;
for (int tap = 0; tap < taps; ++tap)
sum += weights[tap] * float(row[std::clamp(2 * x - 5 + tap, 0, width - 1)]);
line[x] = sum;
}
}
// Four channels in one vector: each lane sums as before.
using Float4 = float __attribute__((vector_size(16)));
void filterColorRow(const uchar *row, int width, float *line, int outWidth, float *floats)
{
for (int index = 0; index < width * 4; ++index)
floats[index] = float(row[index]);
const float *const weights = kernel().data();
for (int x = 0; x < outWidth; ++x) {
Float4 sum = {0, 0, 0, 0};
for (int tap = 0; tap < taps; ++tap) {
Float4 pixel;
std::memcpy(&pixel, floats + std::clamp(2 * x - 5 + tap, 0, width - 1) * 4, sizeof pixel);
sum += weights[tap] * pixel;
}
std::memcpy(line + x * 4, &sum, sizeof sum);
}
}
// One band's scratch: twelve rows, sums, a source row.
struct Band {
int first;
int last;
float *lines;
float *sums;
float *floats;
};
struct Target {
uchar *bits;
qsizetype stride;
int width;
};
template <int channels> void filterBand(const QImage &source, const Target &target, const Band &band)
{
const float *const weights = kernel().data();
const int samples = target.width * channels;
std::array<int, taps> held;
held.fill(-1);
for (int y = band.first; y < band.last; ++y) {
std::array<const float *, taps> rows;
for (int tap = 0; tap < taps; ++tap) {
const int sourceRow = std::clamp(2 * y - 5 + tap, 0, source.height() - 1);
const int slot = sourceRow % taps;
float *line = band.lines + size_t(slot) * samples;
if (held[slot] != sourceRow) {
if (channels == 4)
filterColorRow(source.constScanLine(sourceRow), source.width(), line, target.width, band.floats);
else
filterMaskRow(source.constScanLine(sourceRow), source.width(), line, target.width);
held[slot] = sourceRow;
}
rows[tap] = line;
}
// Tap by tap over whole rows: the same order, contiguous.
float *const sum = band.sums;
std::fill(sum, sum + samples, 0.0f);
for (int tap = 0; tap < taps; ++tap) {
const float weight = weights[tap];
const float *const row = rows.data()[tap];
for (int sample = 0; sample < samples; ++sample)
sum[sample] += weight * row[sample];
}
uchar *out = target.bits + y * target.stride;
for (int sample = 0; sample < samples; ++sample)
out[sample] = uchar(std::clamp(int(sum[sample] + 0.5f), 0, 255));
}
}
void filterBand(const QImage &source, const Target &target, int channels, const Band &band)
{
if (channels == 4)
filterBand<4>(source, target, band);
else
filterBand<1>(source, target, band);
}
// False when the scratch rows cannot be allocated.
bool lanczosHalve(const QImage &source, QImage &destination, int channels, bool threaded)
{
const int height = destination.height();
const int count = threaded ? std::clamp(height / 32, 1, QThreadPool::globalInstance()->maxThreadCount()) : 1;
const size_t samples = size_t(destination.width()) * channels;
// Workers allocate nothing: a failure throws here, caught below.
const size_t bandFloats = size_t(taps) * samples + samples + size_t(source.width()) * channels;
// Writable bits are fetched once: scanLine() is not thread-safe.
const Target target{destination.bits(), destination.bytesPerLine(), destination.width()};
try {
std::vector<float> scratch(bandFloats * count);
std::vector<Band> bands;
for (int index = 0; index < count; ++index) {
float *const lines = scratch.data() + bandFloats * index;
bands.push_back({height * index / count, height * (index + 1) / count, lines, lines + taps * samples, lines + taps * samples + samples});
}
if (threaded)
PoolMap::blocking(bands, [&](const Band &band) { filterBand(source, target, channels, band); });
else
filterBand(source, target, channels, bands.front());
} catch (const std::bad_alloc &) {
return false;
}
return true;
}
}
DownsampleCache::DownsampleCache(qint64 pixelBudget) : m_pixelBudget(pixelBudget) {}
DownsampleCache &DownsampleCache::shared()
{
static DownsampleCache cache;
return cache;
}
qint64 DownsampleCache::Entry::pixels() const
{
qint64 total = 0;
for (const QImage &level : levels)
total += qint64(level.width()) * level.height();
return total;
}
int DownsampleCache::level(double factor)
{
if (!std::isfinite(factor) || factor <= 0 || factor >= 0.5)
return 0;
return std::min(maxLevel, int(std::floor(std::log2(1 / factor))));
}
QImage DownsampleCache::imageDrawnAt(const QImage &image, double factor)
{
return imageAtLevel(image, level(factor)).image;
}
DownsampleCache::Reduced DownsampleCache::imageAtLevel(const QImage &image, int wanted)
{
if (wanted < 1 || (image.width() <= 1 && image.height() <= 1))
return {image, 0};
const qint64 key = image.cacheKey();
std::vector<QImage> levels;
{
const std::lock_guard<std::mutex> guard(m_lock);
m_clock += 1;
if (const auto found = m_entries.find(key); found != m_entries.end())
levels = found->second.levels;
}
while (int(levels.size()) < wanted) {
const QImage &previous = levels.empty() ? image : levels.back();
if (previous.width() <= 1 && previous.height() <= 1)
break;
const std::optional<QImage> next = halve(previous);
if (!next)
break;
levels.push_back(*next);
}
if (levels.empty())
return {image, 0};
{
const std::lock_guard<std::mutex> guard(m_lock);
const auto found = m_entries.find(key);
if (found != m_entries.end() && found->second.levels.size() >= levels.size())
found->second.lastUse = m_clock;
else
m_entries.insert_or_assign(key, Entry{image, levels, m_clock});
evict(key);
}
const int applied = std::min(wanted, int(levels.size()));
return {levels[applied - 1], applied};
}
void DownsampleCache::evict(qint64 keeping)
{
qint64 total = 0;
for (const auto &[key, entry] : m_entries)
total += entry.pixels();
while (total > m_pixelBudget) {
auto oldest = m_entries.end();
for (auto entry = m_entries.begin(); entry != m_entries.end(); ++entry) {
if (entry->first != keeping && (oldest == m_entries.end() || entry->second.lastUse < oldest->second.lastUse))
oldest = entry;
}
if (oldest == m_entries.end())
return;
total -= oldest->second.pixels();
m_entries.erase(oldest);
}
}
std::optional<QImage> DownsampleCache::halve(const QImage &image, bool threaded)
{
const bool mask = image.format() == QImage::Format_Grayscale8;
const int width = (image.width() + 1) / 2, height = (image.height() + 1) / 2;
// Color fades into transparent padding wherever an image is cut.
const int pad = mask ? 0 : 8;
const int paddedWidth = width * 2 + pad * 2, paddedHeight = height * 2 + pad * 2;
const QImage::Format format = mask ? QImage::Format_Grayscale8 : QImage::Format_RGBA8888_Premultiplied;
QImage source(paddedWidth, paddedHeight, format), destination(paddedWidth / 2, paddedHeight / 2, format);
if (source.isNull() || destination.isNull())
return std::nullopt;
source.fill(0);
{
QPainter painter(&source);
BrushRaster::draw(image, QRectF(pad, pad, image.width(), image.height()), painter);
}
if (mask) {
// An odd last column and row repeat.
for (int y = 0; y < image.height() && paddedWidth > image.width(); ++y)
source.scanLine(y)[image.width()] = source.constScanLine(y)[image.width() - 1];
if (paddedHeight > image.height())
std::copy_n(source.constScanLine(image.height() - 1), paddedWidth, source.scanLine(image.height()));
}
if (!lanczosHalve(source, destination, mask ? 1 : 4, threaded))
return std::nullopt;
if (mask)
return destination;
rgba_clamp_premultiplied(destination.bits(), size_t(destination.width()) * destination.height());
const QImage cropped = destination.copy(pad / 2, pad / 2, width, height);
return cropped.isNull() ? std::nullopt : std::optional(cropped);
}