History

avfilter/vf_atadenoise: add sigma options

Paul B Mahol committed 5 years ago

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

Showing the changes to libavfilter (3 of 4 files). Show all

Unified · Split

3 files
  1. libavfilter/atadenoise.h +5 −5
  2. libavfilter/vf_atadenoise.c +138 −10
  3. libavfilter/x86/vf_atadenoise_init.c +10 −8
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