1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// 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.
// Edge-preserving smoothing: weighted average based on L1 patch similarity.
#include "lib/jxl/epf.h"
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <atomic>
#include <numeric> // std::accumulate
#include <vector>
#include "lib/jxl/ac_strategy.h"
#include "lib/jxl/base/compiler_specific.h"
#include "lib/jxl/base/data_parallel.h"
#include "lib/jxl/base/status.h"
#include "lib/jxl/common.h"
#include "lib/jxl/convolve.h"
#include "lib/jxl/dec_cache.h"
#include "lib/jxl/image.h"
#include "lib/jxl/image_bundle.h"
#include "lib/jxl/image_ops.h"
#include "lib/jxl/loop_filter.h"
#include "lib/jxl/quant_weights.h"
#include "lib/jxl/quantizer.h"
namespace jxl {
// Mirror n floats starting at *p and store them before p.
JXL_INLINE void LeftMirror(float* p, size_t n) {
for (size_t i = 0; i < n; i++) {
*(p - 1 - i) = p[i];
}
}
// Mirror n floats starting at *(p - n) and store them at *p.
JXL_INLINE void RightMirror(float* p, size_t n) {
for (size_t i = 0; i < n; i++) {
p[i] = *(p - 1 - i);
}
}
void ComputeSigma(const Rect& block_rect, PassesDecoderState* state) {
const LoopFilter& lf = state->shared->frame_header.loop_filter;
JXL_CHECK(lf.epf_iters > 0);
const AcStrategyImage& ac_strategy = state->shared->ac_strategy;
const float quant_scale = state->shared->quantizer.Scale();
const size_t sigma_stride = state->sigma.PixelsPerRow();
const size_t sharpness_stride = state->shared->epf_sharpness.PixelsPerRow();
for (size_t by = 0; by < block_rect.ysize(); ++by) {
float* JXL_RESTRICT sigma_row = block_rect.Row(&state->sigma, by);
const uint8_t* JXL_RESTRICT sharpness_row =
block_rect.ConstRow(state->shared->epf_sharpness, by);
AcStrategyRow acs_row = ac_strategy.ConstRow(block_rect, by);
const int* const JXL_RESTRICT row_quant =
block_rect.ConstRow(state->shared->raw_quant_field, by);
for (size_t bx = 0; bx < block_rect.xsize(); bx++) {
AcStrategy acs = acs_row[bx];
size_t llf_x = acs.covered_blocks_x();
if (!acs.IsFirstBlock()) continue;
// quant_scale is smaller for low quality.
// quant_scale is roughly 0.08 / butteraugli score.
//
// row_quant is smaller for low quality.
// row_quant is a quantization multiplier of form 1.0 /
// row_quant[bx]
//
// lf.epf_quant_mul is a parameter in the format
// kInvSigmaNum is a constant
float sigma_quant =
lf.epf_quant_mul / (quant_scale * row_quant[bx] * kInvSigmaNum);
for (size_t iy = 0; iy < acs.covered_blocks_y(); iy++) {
for (size_t ix = 0; ix < acs.covered_blocks_x(); ix++) {
float sigma =
sigma_quant *
lf.epf_sharp_lut[sharpness_row[bx + ix + iy * sharpness_stride]];
// Avoid infinities.
sigma = std::min(-1e-4f, sigma); // TODO(veluca): remove this.
sigma_row[bx + ix + kSigmaPadding +
(iy + kSigmaPadding) * sigma_stride] = 1.0f / sigma;
}
}
// TODO(veluca): remove this padding.
// Left padding with mirroring.
if (bx + block_rect.x0() == 0) {
for (size_t iy = 0; iy < acs.covered_blocks_y(); iy++) {
LeftMirror(
sigma_row + kSigmaPadding + (iy + kSigmaPadding) * sigma_stride,
kSigmaBorder);
}
}
// Right padding with mirroring.
if (bx + block_rect.x0() + llf_x ==
state->shared->frame_dim.xsize_blocks) {
for (size_t iy = 0; iy < acs.covered_blocks_y(); iy++) {
RightMirror(sigma_row + kSigmaPadding + bx + llf_x +
(iy + kSigmaPadding) * sigma_stride,
kSigmaBorder);
}
}
// Offsets for row copying, in blocks.
size_t offset_before = bx + block_rect.x0() == 0 ? 1 : bx + kSigmaPadding;
size_t offset_after =
bx + block_rect.x0() + llf_x == state->shared->frame_dim.xsize_blocks
? kSigmaPadding + llf_x + bx + kSigmaBorder
: kSigmaPadding + llf_x + bx;
size_t num = offset_after - offset_before;
// Above
if (by + block_rect.y0() == 0) {
for (size_t iy = 0; iy < kSigmaBorder; iy++) {
memcpy(
sigma_row + offset_before +
(kSigmaPadding - 1 - iy) * sigma_stride,
sigma_row + offset_before + (kSigmaPadding + iy) * sigma_stride,
num * sizeof(*sigma_row));
}
}
// Below
if (by + block_rect.y0() + acs.covered_blocks_y() ==
state->shared->frame_dim.ysize_blocks) {
for (size_t iy = 0; iy < kSigmaBorder; iy++) {
memcpy(
sigma_row + offset_before +
sigma_stride * (acs.covered_blocks_y() + kSigmaPadding + iy),
sigma_row + offset_before +
sigma_stride *
(acs.covered_blocks_y() + kSigmaPadding - 1 - iy),
num * sizeof(*sigma_row));
}
}
}
}
}
} // namespace jxl
|
