denoising.c 10.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
 *  Copyright (c) 2012 The WebM 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 in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "denoising.h"

#include "vp8/common/reconinter.h"
#include "vpx/vpx_integer.h"
#include "vpx_mem/vpx_mem.h"
#include "vpx_rtcd.h"

18
static const unsigned int NOISE_MOTION_THRESHOLD = 25 * 25;
John Koleszar's avatar
John Koleszar committed
19
20
21
/* SSE_DIFF_THRESHOLD is selected as ~95% confidence assuming
 * var(noise) ~= 100.
 */
22
23
24
static const unsigned int SSE_DIFF_THRESHOLD = 16 * 16 * 20;
static const unsigned int SSE_THRESHOLD = 16 * 16 * 40;

John Koleszar's avatar
John Koleszar committed
25
/*
26
27
28
29
30
31
32
33
34
35
36
 * The filter function was modified to reduce the computational complexity.
 * Step 1:
 * Instead of applying tap coefficients for each pixel, we calculated the
 * pixel adjustments vs. pixel diff value ahead of time.
 *     adjustment = filtered_value - current_raw
 *                = (filter_coefficient * diff + 128) >> 8
 * where
 *     filter_coefficient = (255 << 8) / (256 + ((absdiff * 330) >> 3));
 *     filter_coefficient += filter_coefficient /
 *                           (3 + motion_magnitude_adjustment);
 *     filter_coefficient is clamped to 0 ~ 255.
John Koleszar's avatar
John Koleszar committed
37
 *
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 * Step 2:
 * The adjustment vs. diff curve becomes flat very quick when diff increases.
 * This allowed us to use only several levels to approximate the curve without
 * changing the filtering algorithm too much.
 * The adjustments were further corrected by checking the motion magnitude.
 * The levels used are:
 * diff       adjustment w/o motion correction   adjustment w/ motion correction
 * [-255, -16]           -6                                   -7
 * [-15, -8]             -4                                   -5
 * [-7, -4]              -3                                   -4
 * [-3, 3]               diff                                 diff
 * [4, 7]                 3                                    4
 * [8, 15]                4                                    5
 * [16, 255]              6                                    7
John Koleszar's avatar
John Koleszar committed
52
 */
53

54
int vp8_denoiser_filter_c(YV12_BUFFER_CONFIG *mc_running_avg,
55
56
                          YV12_BUFFER_CONFIG *running_avg, MACROBLOCK *signal,
                          unsigned int motion_magnitude, int y_offset,
57
                          int uv_offset)
58
{
59
60
61
62
63
64
    unsigned char *sig = signal->thismb;
    int sig_stride = 16;
    unsigned char *mc_running_avg_y = mc_running_avg->y_buffer + y_offset;
    int mc_avg_y_stride = mc_running_avg->y_stride;
    unsigned char *running_avg_y = running_avg->y_buffer + y_offset;
    int avg_y_stride = running_avg->y_stride;
65
    int r, c, i;
66
    int sum_diff = 0;
67
    int adj_val[3] = {3, 4, 6};
68

69
70
71
    /* If motion_magnitude is small, making the denoiser more aggressive by
     * increasing the adjustment for each level. */
    if (motion_magnitude <= MOTION_MAGNITUDE_THRESHOLD)
72
    {
73
74
75
        for (i = 0; i < 3; i++)
            adj_val[i] += 1;
    }
76

77
78
    for (r = 0; r < 16; ++r)
    {
79
80
        for (c = 0; c < 16; ++c)
        {
81
82
83
            int diff = 0;
            int adjustment = 0;
            int absdiff = 0;
84

85
86
            diff = mc_running_avg_y[c] - sig[c];
            absdiff = abs(diff);
87

88
89
            /* When |diff| < 4, use pixel value from last denoised raw. */
            if (absdiff <= 3)
90
            {
91
92
                running_avg_y[c] = mc_running_avg_y[c];
                sum_diff += diff;
93
94
95
            }
            else
            {
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
                if (absdiff >= 4 && absdiff <= 7)
                    adjustment = adj_val[0];
                else if (absdiff >= 8 && absdiff <= 15)
                    adjustment = adj_val[1];
                else
                    adjustment = adj_val[2];

                if (diff > 0)
                {
                    if ((sig[c] + adjustment) > 255)
                        running_avg_y[c] = 255;
                    else
                        running_avg_y[c] = sig[c] + adjustment;

                    sum_diff += adjustment;
                }
                else
                {
                    if ((sig[c] - adjustment) < 0)
                        running_avg_y[c] = 0;
                    else
                        running_avg_y[c] = sig[c] - adjustment;

                    sum_diff -= adjustment;
                }
121
122
123
            }
        }

John Koleszar's avatar
John Koleszar committed
124
        /* Update pointers for next iteration. */
125
126
127
        sig += sig_stride;
        mc_running_avg_y += mc_avg_y_stride;
        running_avg_y += avg_y_stride;
128
    }
129

130
131
    if (abs(sum_diff) > SUM_DIFF_THRESHOLD)
        return COPY_BLOCK;
132
133
134

    vp8_copy_mem16x16(running_avg->y_buffer + y_offset, avg_y_stride,
                      signal->thismb, sig_stride);
135
    return FILTER_BLOCK;
136
137
138
139
}

int vp8_denoiser_allocate(VP8_DENOISER *denoiser, int width, int height)
{
140
    int i;
141
142
    assert(denoiser);

143
    for (i = 0; i < MAX_REF_FRAMES; i++)
144
    {
145
        denoiser->yv12_running_avg[i].flags = 0;
146

147
148
149
150
151
152
153
154
155
156
157
        if (vp8_yv12_alloc_frame_buffer(&(denoiser->yv12_running_avg[i]), width,
                                        height, VP8BORDERINPIXELS)
            < 0)
        {
            vp8_denoiser_free(denoiser);
            return 1;
        }
        vpx_memset(denoiser->yv12_running_avg[i].buffer_alloc, 0,
                   denoiser->yv12_running_avg[i].frame_size);

    }
158
159
160
    denoiser->yv12_mc_running_avg.flags = 0;

    if (vp8_yv12_alloc_frame_buffer(&(denoiser->yv12_mc_running_avg), width,
161
                                   height, VP8BORDERINPIXELS) < 0)
162
163
164
165
166
167
168
169
    {
        vp8_denoiser_free(denoiser);
        return 1;
    }

    vpx_memset(denoiser->yv12_mc_running_avg.buffer_alloc, 0,
               denoiser->yv12_mc_running_avg.frame_size);
    return 0;
170
171
172
173
}

void vp8_denoiser_free(VP8_DENOISER *denoiser)
{
174
    int i;
175
    assert(denoiser);
176

177
    for (i = 0; i < MAX_REF_FRAMES ; i++)
178
179
180
    {
        vp8_yv12_de_alloc_frame_buffer(&denoiser->yv12_running_avg[i]);
    }
181
    vp8_yv12_de_alloc_frame_buffer(&denoiser->yv12_mc_running_avg);
182
183
}

184

185
186
187
188
189
void vp8_denoiser_denoise_mb(VP8_DENOISER *denoiser,
                             MACROBLOCK *x,
                             unsigned int best_sse,
                             unsigned int zero_mv_sse,
                             int recon_yoffset,
190
191
192
193
194
                             int recon_uvoffset)
{
    int mv_row;
    int mv_col;
    unsigned int motion_magnitude2;
195
196
197
198

    MV_REFERENCE_FRAME frame = x->best_reference_frame;
    MV_REFERENCE_FRAME zero_frame = x->best_zeromv_reference_frame;

199
200
201
    enum vp8_denoiser_decision decision = FILTER_BLOCK;

    if (zero_frame)
202
203
204
205
206
207
208
209
210
211
212
213
214
    {
        YV12_BUFFER_CONFIG *src = &denoiser->yv12_running_avg[frame];
        YV12_BUFFER_CONFIG *dst = &denoiser->yv12_mc_running_avg;
        YV12_BUFFER_CONFIG saved_pre,saved_dst;
        MB_MODE_INFO saved_mbmi;
        MACROBLOCKD *filter_xd = &x->e_mbd;
        MB_MODE_INFO *mbmi = &filter_xd->mode_info_context->mbmi;
        int mv_col;
        int mv_row;
        int sse_diff = zero_mv_sse - best_sse;

        saved_mbmi = *mbmi;

John Koleszar's avatar
John Koleszar committed
215
        /* Use the best MV for the compensation. */
216
217
218
219
220
221
222
        mbmi->ref_frame = x->best_reference_frame;
        mbmi->mode = x->best_sse_inter_mode;
        mbmi->mv = x->best_sse_mv;
        mbmi->need_to_clamp_mvs = x->need_to_clamp_best_mvs;
        mv_col = x->best_sse_mv.as_mv.col;
        mv_row = x->best_sse_mv.as_mv.row;

223
        if (frame == INTRA_FRAME ||
224
225
226
            ((unsigned int)(mv_row *mv_row + mv_col *mv_col)
              <= NOISE_MOTION_THRESHOLD &&
             sse_diff < (int)SSE_DIFF_THRESHOLD))
227
        {
John Koleszar's avatar
John Koleszar committed
228
229
230
231
232
233
234
235
            /*
             * Handle intra blocks as referring to last frame with zero motion
             * and let the absolute pixel difference affect the filter factor.
             * Also consider small amount of motion as being random walk due
             * to noise, if it doesn't mean that we get a much bigger error.
             * Note that any changes to the mode info only affects the
             * denoising.
             */
236
237
238
239
240
241
242
243
244
245
246
247
248
249
            mbmi->ref_frame =
                    x->best_zeromv_reference_frame;

            src = &denoiser->yv12_running_avg[zero_frame];

            mbmi->mode = ZEROMV;
            mbmi->mv.as_int = 0;
            x->best_sse_inter_mode = ZEROMV;
            x->best_sse_mv.as_int = 0;
            best_sse = zero_mv_sse;
        }

        saved_pre = filter_xd->pre;
        saved_dst = filter_xd->dst;
250

John Koleszar's avatar
John Koleszar committed
251
        /* Compensate the running average. */
252
253
254
        filter_xd->pre.y_buffer = src->y_buffer + recon_yoffset;
        filter_xd->pre.u_buffer = src->u_buffer + recon_uvoffset;
        filter_xd->pre.v_buffer = src->v_buffer + recon_uvoffset;
John Koleszar's avatar
John Koleszar committed
255
        /* Write the compensated running average to the destination buffer. */
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
        filter_xd->dst.y_buffer = dst->y_buffer + recon_yoffset;
        filter_xd->dst.u_buffer = dst->u_buffer + recon_uvoffset;
        filter_xd->dst.v_buffer = dst->v_buffer + recon_uvoffset;

        if (!x->skip)
        {
            vp8_build_inter_predictors_mb(filter_xd);
        }
        else
        {
            vp8_build_inter16x16_predictors_mb(filter_xd,
                                               filter_xd->dst.y_buffer,
                                               filter_xd->dst.u_buffer,
                                               filter_xd->dst.v_buffer,
                                               filter_xd->dst.y_stride,
                                               filter_xd->dst.uv_stride);
        }
        filter_xd->pre = saved_pre;
        filter_xd->dst = saved_dst;
        *mbmi = saved_mbmi;

    }

    mv_row = x->best_sse_mv.as_mv.row;
    mv_col = x->best_sse_mv.as_mv.col;
    motion_magnitude2 = mv_row * mv_row + mv_col * mv_col;
    if (best_sse > SSE_THRESHOLD || motion_magnitude2
           > 8 * NOISE_MOTION_THRESHOLD)
284
285
286
287
288
289
    {
        decision = COPY_BLOCK;
    }

    if (decision == FILTER_BLOCK)
    {
John Koleszar's avatar
John Koleszar committed
290
        /* Filter. */
291
        decision = vp8_denoiser_filter(&denoiser->yv12_mc_running_avg,
292
                                       &denoiser->yv12_running_avg[INTRA_FRAME],
293
294
295
296
297
                                       x,
                                       motion_magnitude2,
                                       recon_yoffset, recon_uvoffset);
    }
    if (decision == COPY_BLOCK)
298
    {
John Koleszar's avatar
John Koleszar committed
299
300
301
        /* No filtering of this block; it differs too much from the predictor,
         * or the motion vector magnitude is considered too big.
         */
302
303
        vp8_copy_mem16x16(
                x->thismb, 16,
304
305
                denoiser->yv12_running_avg[INTRA_FRAME].y_buffer + recon_yoffset,
                denoiser->yv12_running_avg[INTRA_FRAME].y_stride);
306
    }
307
}