picklpf.c 12.9 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5
6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9
10
11
 */


John Koleszar's avatar
John Koleszar committed
12
#include "vp8/common/onyxc_int.h"
John Koleszar's avatar
John Koleszar committed
13
14
15
16
17
#include "onyx_int.h"
#include "quantize.h"
#include "vpx_mem/vpx_mem.h"
#include "vpx_scale/yv12extend.h"
#include "vpx_scale/vpxscale.h"
John Koleszar's avatar
John Koleszar committed
18
#include "vp8/common/alloccommon.h"
Johann's avatar
Johann committed
19
#include "vp8/common/loopfilter.h"
20
21
22
#if ARCH_ARM
#include "vpx_ports/arm.h"
#endif
John Koleszar's avatar
John Koleszar committed
23
24
25
26
27
28
29
30
31

extern int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd);

#if CONFIG_RUNTIME_CPU_DETECT
#define IF_RTCD(x) (x)
#else
#define IF_RTCD(x) NULL
#endif

32
33
34
35
36
extern void (*vp8_yv12_copy_partial_frame_ptr)(YV12_BUFFER_CONFIG *src_ybc,
                                               YV12_BUFFER_CONFIG *dst_ybc);

void vp8_yv12_copy_partial_frame(YV12_BUFFER_CONFIG *src_ybc,
                                 YV12_BUFFER_CONFIG *dst_ybc)
John Koleszar's avatar
John Koleszar committed
37
38
39
40
41
42
43
44
45
46
47
48
{
    unsigned char *src_y, *dst_y;
    int yheight;
    int ystride;
    int border;
    int yoffset;
    int linestocopy;

    border   = src_ybc->border;
    yheight  = src_ybc->y_height;
    ystride  = src_ybc->y_stride;

49
50
51
52
53
54
55
56
57
58
59
    /* number of MB rows to use in partial filtering */
    linestocopy = (yheight >> 4) / PARTIAL_FRAME_FRACTION;
    linestocopy = linestocopy ? linestocopy << 4 : 16;     /* 16 lines per MB */

    /* Copy extra 4 so that full filter context is available if filtering done
     * on the copied partial frame and not original. Partial filter does mb
     * filtering for top row also, which can modify3 pixels above.
     */
    linestocopy += 4;
    /* partial image starts at ~middle of frame (macroblock border)*/
    yoffset  = ystride * (((yheight >> 5) * 16) - 4);
John Koleszar's avatar
John Koleszar committed
60
61
62
    src_y = src_ybc->y_buffer + yoffset;
    dst_y = dst_ybc->y_buffer + yoffset;

63
    vpx_memcpy(dst_y, src_y, ystride * linestocopy);
John Koleszar's avatar
John Koleszar committed
64
65
}

66
67
68
static int calc_partial_ssl_err(YV12_BUFFER_CONFIG *source,
                                YV12_BUFFER_CONFIG *dest,
                                const vp8_variance_rtcd_vtable_t *rtcd)
John Koleszar's avatar
John Koleszar committed
69
70
71
72
73
74
75
{
    int i, j;
    int Total = 0;
    int srcoffset, dstoffset;
    unsigned char *src = source->y_buffer;
    unsigned char *dst = dest->y_buffer;

76
    int linestocopy;
John Koleszar's avatar
John Koleszar committed
77

78
79
80
    /* number of MB rows to use in partial filtering */
    linestocopy = (source->y_height >> 4) / PARTIAL_FRAME_FRACTION;
    linestocopy = linestocopy ? linestocopy << 4 : 16;     /* 16 lines per MB */
John Koleszar's avatar
John Koleszar committed
81
82


83
84
85
    /* partial image starts at ~middle of frame (macroblock border)*/
    srcoffset = source->y_stride * ((dest->y_height >> 5) * 16);
    dstoffset = dest->y_stride   * ((dest->y_height >> 5) * 16);
John Koleszar's avatar
John Koleszar committed
86
87
88
89
90
91
92
93
94
95

    src += srcoffset;
    dst += dstoffset;

    // Loop through the Y plane raw and reconstruction data summing (square differences)
    for (i = 0; i < linestocopy; i += 16)
    {
        for (j = 0; j < source->y_width; j += 16)
        {
            unsigned int sse;
96
97
98
            Total += VARIANCE_INVOKE(rtcd, mse16x16)(src + j, source->y_stride,
                                                     dst + j, dest->y_stride,
                                                     &sse);
John Koleszar's avatar
John Koleszar committed
99
100
101
102
103
104
105
106
107
108
109
110
111
112
        }

        src += 16 * source->y_stride;
        dst += 16 * dest->y_stride;
    }

    return Total;
}

// Enforce a minimum filter level based upon baseline Q
static int get_min_filter_level(VP8_COMP *cpi, int base_qindex)
{
    int min_filter_level;

113
114
    if (cpi->source_alt_ref_active && cpi->common.refresh_golden_frame &&
        !cpi->common.refresh_alt_ref_frame)
John Koleszar's avatar
John Koleszar committed
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
        min_filter_level = 0;
    else
    {
        if (base_qindex <= 6)
            min_filter_level = 0;
        else if (base_qindex <= 16)
            min_filter_level = 1;
        else
            min_filter_level = (base_qindex / 8);
    }

    return min_filter_level;
}

// Enforce a maximum filter level based upon baseline Q
static int get_max_filter_level(VP8_COMP *cpi, int base_qindex)
{
    // PGW August 2006: Highest filter values almost always a bad idea

    // jbb chg: 20100118 - not so any more with this overquant stuff allow high values
    // with lots of intra coming in.
    int max_filter_level = MAX_LOOP_FILTER ;//* 3 / 4;
Johann's avatar
Johann committed
137
    (void)base_qindex;
John Koleszar's avatar
John Koleszar committed
138

139
    if (cpi->twopass.section_intra_rating > 8)
John Koleszar's avatar
John Koleszar committed
140
141
142
143
144
145
146
147
148
149
150
        max_filter_level = MAX_LOOP_FILTER * 3 / 4;

    return max_filter_level;
}

void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)
{
    VP8_COMMON *cm = &cpi->common;

    int best_err = 0;
    int filt_err = 0;
Johann's avatar
Johann committed
151
152
    int min_filter_level = get_min_filter_level(cpi, cm->base_qindex);
    int max_filter_level = get_max_filter_level(cpi, cm->base_qindex);
John Koleszar's avatar
John Koleszar committed
153
154
    int filt_val;
    int best_filt_val = cm->filter_level;
155
    YV12_BUFFER_CONFIG * saved_frame = cm->frame_to_show;
John Koleszar's avatar
John Koleszar committed
156

157
158
    /* Replace unfiltered frame buffer with a new one */
    cm->frame_to_show = &cpi->pick_lf_lvl_frame;
John Koleszar's avatar
John Koleszar committed
159
160
161
162
163
164

    if (cm->frame_type == KEY_FRAME)
        cm->sharpness_level = 0;
    else
        cm->sharpness_level = cpi->oxcf.Sharpness;

Johann's avatar
Johann committed
165
166
167
    if (cm->sharpness_level != cm->last_sharpness_level)
    {
        vp8_loop_filter_update_sharpness(&cm->lf_info, cm->sharpness_level);
168
        cm->last_sharpness_level = cm->sharpness_level;
Johann's avatar
Johann committed
169
170
    }

John Koleszar's avatar
John Koleszar committed
171
172
173
174
175
176
177
178
179
180
181
    // Start the search at the previous frame filter level unless it is now out of range.
    if (cm->filter_level < min_filter_level)
        cm->filter_level = min_filter_level;
    else if (cm->filter_level > max_filter_level)
        cm->filter_level = max_filter_level;

    filt_val = cm->filter_level;
    best_filt_val = filt_val;

    // Get the err using the previous frame's filter value.

182
183
184
    /* Copy the unfiltered / processed recon buffer to the new buffer */
    vp8_yv12_copy_partial_frame_ptr(saved_frame, cm->frame_to_show);
    vp8_loop_filter_partial_frame(cm, &cpi->mb.e_mbd, filt_val);
John Koleszar's avatar
John Koleszar committed
185

186
187
    best_err = calc_partial_ssl_err(sd, cm->frame_to_show,
                                    IF_RTCD(&cpi->rtcd.variance));
John Koleszar's avatar
John Koleszar committed
188
189
190
191
192
193
194

    filt_val -= (1 + ((filt_val > 10) ? 1 : 0));

    // Search lower filter levels
    while (filt_val >= min_filter_level)
    {
        // Apply the loop filter
195
        vp8_yv12_copy_partial_frame_ptr(saved_frame, cm->frame_to_show);
Johann's avatar
Johann committed
196
        vp8_loop_filter_partial_frame(cm, &cpi->mb.e_mbd, filt_val);
John Koleszar's avatar
John Koleszar committed
197
198

        // Get the err for filtered frame
199
200
        filt_err = calc_partial_ssl_err(sd, cm->frame_to_show,
                                        IF_RTCD(&cpi->rtcd.variance));
John Koleszar's avatar
John Koleszar committed
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225

        // Update the best case record or exit loop.
        if (filt_err < best_err)
        {
            best_err = filt_err;
            best_filt_val = filt_val;
        }
        else
            break;

        // Adjust filter level
        filt_val -= (1 + ((filt_val > 10) ? 1 : 0));
    }

    // Search up (note that we have already done filt_val = cm->filter_level)
    filt_val = cm->filter_level + (1 + ((filt_val > 10) ? 1 : 0));

    if (best_filt_val == cm->filter_level)
    {
        // Resist raising filter level for very small gains
        best_err -= (best_err >> 10);

        while (filt_val < max_filter_level)
        {
            // Apply the loop filter
226
227
            vp8_yv12_copy_partial_frame_ptr(saved_frame, cm->frame_to_show);

Johann's avatar
Johann committed
228
            vp8_loop_filter_partial_frame(cm, &cpi->mb.e_mbd, filt_val);
John Koleszar's avatar
John Koleszar committed
229
230

            // Get the err for filtered frame
231
232
            filt_err = calc_partial_ssl_err(sd, cm->frame_to_show,
                                            IF_RTCD(&cpi->rtcd.variance));
John Koleszar's avatar
John Koleszar committed
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256

            // Update the best case record or exit loop.
            if (filt_err < best_err)
            {
                // Do not raise filter level if improvement is < 1 part in 4096
                best_err = filt_err - (filt_err >> 10);

                best_filt_val = filt_val;
            }
            else
                break;

            // Adjust filter level
            filt_val += (1 + ((filt_val > 10) ? 1 : 0));
        }
    }

    cm->filter_level = best_filt_val;

    if (cm->filter_level < min_filter_level)
        cm->filter_level = min_filter_level;

    if (cm->filter_level > max_filter_level)
        cm->filter_level = max_filter_level;
257
258
259

    /* restore unfiltered frame pointer */
    cm->frame_to_show = saved_frame;
John Koleszar's avatar
John Koleszar committed
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
}

// Stub function for now Alt LF not used
void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val)
{
    MACROBLOCKD *mbd = &cpi->mb.e_mbd;
    (void) filt_val;

    mbd->segment_feature_data[MB_LVL_ALT_LF][0] = cpi->segment_feature_data[MB_LVL_ALT_LF][0];
    mbd->segment_feature_data[MB_LVL_ALT_LF][1] = cpi->segment_feature_data[MB_LVL_ALT_LF][1];
    mbd->segment_feature_data[MB_LVL_ALT_LF][2] = cpi->segment_feature_data[MB_LVL_ALT_LF][2];
    mbd->segment_feature_data[MB_LVL_ALT_LF][3] = cpi->segment_feature_data[MB_LVL_ALT_LF][3];
}

void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)
{
    VP8_COMMON *cm = &cpi->common;

    int best_err = 0;
    int filt_err = 0;
Johann's avatar
Johann committed
280
281
    int min_filter_level = get_min_filter_level(cpi, cm->base_qindex);
    int max_filter_level = get_max_filter_level(cpi, cm->base_qindex);
John Koleszar's avatar
John Koleszar committed
282
283
284
285
286
287
288
289

    int filter_step;
    int filt_high = 0;
    int filt_mid = cm->filter_level;      // Start search at previous frame filter level
    int filt_low = 0;
    int filt_best;
    int filt_direction = 0;

290
291
292
    int Bias = 0;                       // Bias against raising loop filter and in favor of lowering it

    YV12_BUFFER_CONFIG * saved_frame = cm->frame_to_show;
John Koleszar's avatar
John Koleszar committed
293

294
295
    /* Replace unfiltered frame buffer with a new one */
    cm->frame_to_show = &cpi->pick_lf_lvl_frame;
John Koleszar's avatar
John Koleszar committed
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313

    if (cm->frame_type == KEY_FRAME)
        cm->sharpness_level = 0;
    else
        cm->sharpness_level = cpi->oxcf.Sharpness;

    // Start the search at the previous frame filter level unless it is now out of range.
    filt_mid = cm->filter_level;

    if (filt_mid < min_filter_level)
        filt_mid = min_filter_level;
    else if (filt_mid > max_filter_level)
        filt_mid = max_filter_level;

    // Define the initial step size
    filter_step = (filt_mid < 16) ? 4 : filt_mid / 4;

    // Get baseline error score
314
315
316
317

    /* Copy the unfiltered / processed recon buffer to the new buffer */
    vp8_yv12_copy_y_ptr(saved_frame, cm->frame_to_show);

John Koleszar's avatar
John Koleszar committed
318
    vp8cx_set_alt_lf_level(cpi, filt_mid);
Johann's avatar
Johann committed
319
    vp8_loop_filter_frame_yonly(cm, &cpi->mb.e_mbd, filt_mid);
John Koleszar's avatar
John Koleszar committed
320

321
322
    best_err = vp8_calc_ss_err(sd, cm->frame_to_show,
                               IF_RTCD(&cpi->rtcd.variance));
John Koleszar's avatar
John Koleszar committed
323
324
325
326
327
328
329
    filt_best = filt_mid;

    while (filter_step > 0)
    {
        Bias = (best_err >> (15 - (filt_mid / 8))) * filter_step; //PGW change 12/12/06 for small images

        // jbb chg: 20100118 - in sections with lots of new material coming in don't bias as much to a low filter value
330
331
        if (cpi->twopass.section_intra_rating < 20)
            Bias = Bias * cpi->twopass.section_intra_rating / 20;
John Koleszar's avatar
John Koleszar committed
332
333
334
335
336
337
338

        filt_high = ((filt_mid + filter_step) > max_filter_level) ? max_filter_level : (filt_mid + filter_step);
        filt_low = ((filt_mid - filter_step) < min_filter_level) ? min_filter_level : (filt_mid - filter_step);

        if ((filt_direction <= 0) && (filt_low != filt_mid))
        {
            // Get Low filter error score
339
            vp8_yv12_copy_y_ptr(saved_frame, cm->frame_to_show);
John Koleszar's avatar
John Koleszar committed
340
            vp8cx_set_alt_lf_level(cpi, filt_low);
Johann's avatar
Johann committed
341
            vp8_loop_filter_frame_yonly(cm, &cpi->mb.e_mbd, filt_low);
John Koleszar's avatar
John Koleszar committed
342

343
344
            filt_err = vp8_calc_ss_err(sd, cm->frame_to_show,
                                       IF_RTCD(&cpi->rtcd.variance));
John Koleszar's avatar
John Koleszar committed
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359

            // If value is close to the best so far then bias towards a lower loop filter value.
            if ((filt_err - Bias) < best_err)
            {
                // Was it actually better than the previous best?
                if (filt_err < best_err)
                    best_err = filt_err;

                filt_best = filt_low;
            }
        }

        // Now look at filt_high
        if ((filt_direction >= 0) && (filt_high != filt_mid))
        {
360
            vp8_yv12_copy_y_ptr(saved_frame, cm->frame_to_show);
John Koleszar's avatar
John Koleszar committed
361
            vp8cx_set_alt_lf_level(cpi, filt_high);
Johann's avatar
Johann committed
362
            vp8_loop_filter_frame_yonly(cm, &cpi->mb.e_mbd, filt_high);
John Koleszar's avatar
John Koleszar committed
363

364
365
            filt_err = vp8_calc_ss_err(sd, cm->frame_to_show,
                                       IF_RTCD(&cpi->rtcd.variance));
John Koleszar's avatar
John Koleszar committed
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388

            // Was it better than the previous best?
            if (filt_err < (best_err - Bias))
            {
                best_err = filt_err;
                filt_best = filt_high;
            }
        }

        // Half the step distance if the best filter value was the same as last time
        if (filt_best == filt_mid)
        {
            filter_step = filter_step / 2;
            filt_direction = 0;
        }
        else
        {
            filt_direction = (filt_best < filt_mid) ? -1 : 1;
            filt_mid = filt_best;
        }
    }

    cm->filter_level = filt_best;
389
390
391

    /* restore unfiltered frame pointer */
    cm->frame_to_show = saved_frame;
John Koleszar's avatar
John Koleszar committed
392
}