History

avfilter/vf_atadenoise: add sigma options

Paul B Mahol committed 5 years ago

Commit 95183d21 parent ee1d1c44 files · +162 −23Browse files

Unified · Split

4 files
  1. doc/filters.texi +9 −0
  2. libavfilter/atadenoise.h +5 −5
  3. libavfilter/vf_atadenoise.c +138 −10
  4. libavfilter/x86/vf_atadenoise_init.c +10 −8
doc/filters.texi+9−0
@@ -7096,6 +7096,15 @@ Alternatively can be set to @code{s} serial. · 7095 unmodified lines
70967096 Parallel can be faster then serial, while other way around is never true.
70977097 Parallel will abort early on first change being greater then thresholds, while serial
70987098 will continue processing other side of frames if they are equal or below thresholds.
7099+
7100+@item 0s
7101+@item 1s
7102+@item 2s
7103+Set sigma for 1st plane, 2nd plane or 3rd plane. Default is 32767.
7104+Valid range is from 0 to 32767.
7105+This options controls weight for each pixel in radius defined by size.
7106+Default value means every pixel have same weight.
7107+Setting this option to 0 effectively disables filtering.
70997108 @end table
71007109
71017110 @subsection Commands
libavfilter/atadenoise.h+5−5
@@ -31,12 +31,12 @@ enum ATAAlgorithm { · 30 unmodified lines
3131 };
3232
3333 typedef struct ATADenoiseDSPContext {
34− void (*filter_row)(const uint8_t *src, uint8_t *dst,
35− const uint8_t **srcf,
36− int w, int mid, int size,
37− int thra, int thrb);
34+ void (*filter_row[4])(const uint8_t *src, uint8_t *dst,
35+ const uint8_t **srcf,
36+ int w, int mid, int size,
37+ int thra, int thrb, const float *weight);
3838 } ATADenoiseDSPContext;
3939
40−void ff_atadenoise_init_x86(ATADenoiseDSPContext *dsp, int depth, int algorithm);
40+void ff_atadenoise_init_x86(ATADenoiseDSPContext *dsp, int depth, int algorithm, const float *sigma);
4141
4242 #endif /* AVFILTER_ATADENOISE_H */
libavfilter/vf_atadenoise.c+138−10
@@ -44,6 +44,7 @@ typedef struct ATADenoiseContext { · 43 unmodified lines
4444 const AVClass *class;
4545
4646 float fthra[4], fthrb[4];
47+ float sigma[4];
4748 int thra[4], thrb[4];
4849 int algorithm;
4950
@@ -55,7 +56,8 @@ typedef struct ATADenoiseContext { · 5 unmodified lines
5556 struct FFBufQueue q;
5657 void *data[4][SIZE];
5758 int linesize[4][SIZE];
58− int size, mid;
59+ float weights[4][SIZE];
60+ int size, mid, radius;
5961 int available;
6062
6163 int (*filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
@@ -79,6 +81,9 @@ static const AVOption atadenoise_options[] = { · 17 unmodified lines
7981 { "a", "set variant of algorithm", OFFSET(algorithm),AV_OPT_TYPE_INT, {.i64=PARALLEL}, 0, NB_ATAA-1, FLAGS, "a" },
8082 { "p", "parallel", 0, AV_OPT_TYPE_CONST, {.i64=PARALLEL}, 0, 0, FLAGS, "a" },
8183 { "s", "serial", 0, AV_OPT_TYPE_CONST, {.i64=SERIAL}, 0, 0, FLAGS, "a" },
84+ { "0s", "set sigma for 1st plane", OFFSET(sigma[0]), AV_OPT_TYPE_FLOAT, {.dbl=INT16_MAX}, 0, INT16_MAX, FLAGS },
85+ { "1s", "set sigma for 2nd plane", OFFSET(sigma[1]), AV_OPT_TYPE_FLOAT, {.dbl=INT16_MAX}, 0, INT16_MAX, FLAGS },
86+ { "2s", "set sigma for 3rd plane", OFFSET(sigma[2]), AV_OPT_TYPE_FLOAT, {.dbl=INT16_MAX}, 0, INT16_MAX, FLAGS },
8287 { NULL }
8388 };
8489
@@ -129,7 +134,8 @@ static av_cold int init(AVFilterContext *ctx) · 44 unmodified lines
129134 av_log(ctx, AV_LOG_WARNING, "size %d is invalid. Must be an odd value, setting it to %d.\n", s->size, s->size|1);
130135 s->size |= 1;
131136 }
132− s->mid = s->size / 2 + 1;
137+ s->radius = s->size / 2;
138+ s->mid = s->radius + 1;
133139
134140 return 0;
135141 }
@@ -138,11 +144,114 @@ typedef struct ThreadData { · 2 unmodified lines
138144 AVFrame *in, *out;
139145 } ThreadData;
140146
147+#define WFILTER_ROW(type, name) \
148+static void fweight_row##name(const uint8_t *ssrc, uint8_t *ddst, \
149+ const uint8_t *ssrcf[SIZE], \
150+ int w, int mid, int size, \
151+ int thra, int thrb, const float *weights) \
152+{ \
153+ const type *src = (const type *)ssrc; \
154+ const type **srcf = (const type **)ssrcf; \
155+ type *dst = (type *)ddst; \
156+ \
157+ for (int x = 0; x < w; x++) { \
158+ const int srcx = src[x]; \
159+ unsigned lsumdiff = 0, rsumdiff = 0; \
160+ unsigned ldiff, rdiff; \
161+ float sum = srcx; \
162+ float wsum = 1.f; \
163+ int l = 0, r = 0; \
164+ int srcjx, srcix; \
165+ \
166+ for (int j = mid - 1, i = mid + 1; j >= 0 && i < size; j--, i++) { \
167+ srcjx = srcf[j][x]; \
168+ \
169+ ldiff = FFABS(srcx - srcjx); \
170+ lsumdiff += ldiff; \
171+ if (ldiff > thra || \
172+ lsumdiff > thrb) \
173+ break; \
174+ l++; \
175+ sum += srcjx * weights[j]; \
176+ wsum += weights[j]; \
177+ \
178+ srcix = srcf[i][x]; \
179+ \
180+ rdiff = FFABS(srcx - srcix); \
181+ rsumdiff += rdiff; \
182+ if (rdiff > thra || \
183+ rsumdiff > thrb) \
184+ break; \
185+ r++; \
186+ sum += srcix * weights[i]; \
187+ wsum += weights[i]; \
188+ } \
189+ \
190+ dst[x] = lrintf(sum / wsum); \
191+ } \
192+}
193+
194+WFILTER_ROW(uint8_t, 8)
195+WFILTER_ROW(uint16_t, 16)
196+
197+#define WFILTER_ROW_SERIAL(type, name) \
198+static void fweight_row##name##_serial(const uint8_t *ssrc, uint8_t *ddst, \
199+ const uint8_t *ssrcf[SIZE], \
200+ int w, int mid, int size, \
201+ int thra, int thrb, \
202+ const float *weights) \
203+{ \
204+ const type *src = (const type *)ssrc; \
205+ const type **srcf = (const type **)ssrcf; \
206+ type *dst = (type *)ddst; \
207+ \
208+ for (int x = 0; x < w; x++) { \
209+ const int srcx = src[x]; \
210+ unsigned lsumdiff = 0, rsumdiff = 0; \
211+ unsigned ldiff, rdiff; \
212+ float sum = srcx; \
213+ float wsum = 1.f; \
214+ int l = 0, r = 0; \
215+ int srcjx, srcix; \
216+ \
217+ for (int j = mid - 1; j >= 0; j--) { \
218+ srcjx = srcf[j][x]; \
219+ \
220+ ldiff = FFABS(srcx - srcjx); \
221+ lsumdiff += ldiff; \
222+ if (ldiff > thra || \
223+ lsumdiff > thrb) \
224+ break; \
225+ l++; \
226+ sum += srcjx * weights[j]; \
227+ wsum += weights[j]; \
228+ } \
229+ \
230+ for (int i = mid + 1; i < size; i++) { \
231+ srcix = srcf[i][x]; \
232+ \
233+ rdiff = FFABS(srcx - srcix); \
234+ rsumdiff += rdiff; \
235+ if (rdiff > thra || \
236+ rsumdiff > thrb) \
237+ break; \
238+ r++; \
239+ sum += srcix * weights[i]; \
240+ wsum += weights[i]; \
241+ } \
242+ \
243+ dst[x] = lrintf(sum / wsum); \
244+ } \
245+}
246+
247+WFILTER_ROW_SERIAL(uint8_t, 8)
248+WFILTER_ROW_SERIAL(uint16_t, 16)
249+
141250 #define FILTER_ROW(type, name) \
142251 static void filter_row##name(const uint8_t *ssrc, uint8_t *ddst, \
143252 const uint8_t *ssrcf[SIZE], \
144253 int w, int mid, int size, \
145− int thra, int thrb) \
254+ int thra, int thrb, const float *weights) \
146255 { \
147256 const type *src = (const type *)ssrc; \
148257 const type **srcf = (const type **)ssrcf; \
@@ -189,7 +298,8 @@ FILTER_ROW(uint16_t, 16) · 40 unmodified lines
189298 static void filter_row##name##_serial(const uint8_t *ssrc, uint8_t *ddst, \
190299 const uint8_t *ssrcf[SIZE], \
191300 int w, int mid, int size, \
192− int thra, int thrb) \
301+ int thra, int thrb, \
302+ const float *weights) \
193303 { \
194304 const type *src = (const type *)ssrc; \
195305 const type **srcf = (const type **)ssrcf; \
@@ -245,6 +355,7 @@ static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) · 49 unmodified lines
245355 int p, y, i;
246356
247357 for (p = 0; p < s->nb_planes; p++) {
358+ const float *weights = s->weights[p];
248359 const int h = s->planeheight[p];
249360 const int w = s->planewidth[p];
250361 const int slice_start = (h * jobnr) / nb_jobs;
@@ -267,7 +378,7 @@ static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) · 16 unmodified lines
267378 srcf[i] = data[i] + slice_start * linesize[i];
268379
269380 for (y = slice_start; y < slice_end; y++) {
270− s->dsp.filter_row(src, dst, srcf, w, mid, size, thra, thrb);
381+ s->dsp.filter_row[p](src, dst, srcf, w, mid, size, thra, thrb, weights);
271382
272383 dst += out->linesize[p];
273384 src += in->linesize[p];
@@ -296,10 +407,17 @@ static int config_input(AVFilterLink *inlink) · 22 unmodified lines
296407
297408 depth = desc->comp[0].depth;
298409 s->filter_slice = filter_slice;
299− if (depth == 8)
300− s->dsp.filter_row = s->algorithm == PARALLEL ? filter_row8 : filter_row8_serial;
301− else
302− s->dsp.filter_row = s->algorithm == PARALLEL ? filter_row16 : filter_row16_serial;
410+
411+ for (int p = 0; p < s->nb_planes; p++) {
412+ if (depth == 8 && s->sigma[p] == INT16_MAX)
413+ s->dsp.filter_row[p] = s->algorithm == PARALLEL ? filter_row8 : filter_row8_serial;
414+ else if (s->sigma[p] == INT16_MAX)
415+ s->dsp.filter_row[p] = s->algorithm == PARALLEL ? filter_row16 : filter_row16_serial;
416+ else if (depth == 8 && s->sigma[p] < INT16_MAX)
417+ s->dsp.filter_row[p] = s->algorithm == PARALLEL ? fweight_row8 : fweight_row8_serial;
418+ else if (s->sigma[p] < INT16_MAX)
419+ s->dsp.filter_row[p] = s->algorithm == PARALLEL ? fweight_row16 : fweight_row16_serial;
420+ }
303421
304422 s->thra[0] = s->fthra[0] * (1 << depth) - 1;
305423 s->thra[1] = s->fthra[1] * (1 << depth) - 1;
@@ -308,8 +426,18 @@ static int config_input(AVFilterLink *inlink) · 2 unmodified lines
308426 s->thrb[1] = s->fthrb[1] * (1 << depth) - 1;
309427 s->thrb[2] = s->fthrb[2] * (1 << depth) - 1;
310428
429+ for (int p = 0; p < s->nb_planes; p++) {
430+ float sigma = s->radius * s->sigma[p];
431+
432+ s->weights[p][s->mid] = 1.f;
433+ for (int n = 1; n <= s->radius; n++) {
434+ s->weights[p][s->radius + n] =
435+ s->weights[p][s->radius - n] = expf(-0.5 * (n + 1) * (n + 1) / (sigma * sigma));
436+ }
437+ }
438+
311439 if (ARCH_X86)
312− ff_atadenoise_init_x86(&s->dsp, depth, s->algorithm);
440+ ff_atadenoise_init_x86(&s->dsp, depth, s->algorithm, s->sigma);
313441
314442 return 0;
315443 }
libavfilter/x86/vf_atadenoise_init.c+10−8
@@ -28,22 +28,24 @@ · 27 unmodified lines
2828 void ff_atadenoise_filter_row8_sse4(const uint8_t *src, uint8_t *dst,
2929 const uint8_t **srcf,
3030 int w, int mid, int size,
31− int thra, int thrb);
31+ int thra, int thrb, const float *weights);
3232
3333 void ff_atadenoise_filter_row8_serial_sse4(const uint8_t *src, uint8_t *dst,
3434 const uint8_t **srcf,
3535 int w, int mid, int size,
36− int thra, int thrb);
36+ int thra, int thrb, const float *weights);
3737
38−av_cold void ff_atadenoise_init_x86(ATADenoiseDSPContext *dsp, int depth, int algorithm)
38+av_cold void ff_atadenoise_init_x86(ATADenoiseDSPContext *dsp, int depth, int algorithm, const float *sigma)
3939 {
4040 int cpu_flags = av_get_cpu_flags();
4141
42− if (ARCH_X86_64 && EXTERNAL_SSE4(cpu_flags) && depth <= 8 && algorithm == PARALLEL) {
43− dsp->filter_row = ff_atadenoise_filter_row8_sse4;
44− }
42+ for (int p = 0; p < 4; p++) {
43+ if (ARCH_X86_64 && EXTERNAL_SSE4(cpu_flags) && depth <= 8 && algorithm == PARALLEL && sigma[p] == INT16_MAX) {
44+ dsp->filter_row[p] = ff_atadenoise_filter_row8_sse4;
45+ }
4546
46− if (ARCH_X86_64 && EXTERNAL_SSE4(cpu_flags) && depth <= 8 && algorithm == SERIAL) {
47− dsp->filter_row = ff_atadenoise_filter_row8_serial_sse4;
47+ if (ARCH_X86_64 && EXTERNAL_SSE4(cpu_flags) && depth <= 8 && algorithm == SERIAL && sigma[p] == INT16_MAX) {
48+ dsp->filter_row[p] = ff_atadenoise_filter_row8_serial_sse4;
49+ }
4850 }
4951 }

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t