pickrst.c 30.5 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
/*
 *  Copyright (c) 2010 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 <assert.h>
12
#include <float.h>
13
14
15
#include <limits.h>
#include <math.h>

Yaowu Xu's avatar
Yaowu Xu committed
16
#include "./aom_scale_rtcd.h"
17

18
#include "aom_dsp/psnr.h"
Yaowu Xu's avatar
Yaowu Xu committed
19
20
#include "aom_dsp/aom_dsp_common.h"
#include "aom_mem/aom_mem.h"
21
#include "aom_ports/mem.h"
22

23
24
#include "av1/common/onyxc_int.h"
#include "av1/common/quant_common.h"
25

26
27
28
29
#include "av1/encoder/encoder.h"
#include "av1/encoder/picklpf.h"
#include "av1/encoder/pickrst.h"
#include "av1/encoder/quantize.h"
30

31
32
33
34
35
typedef double (*search_restore_type)(const YV12_BUFFER_CONFIG *src,
                                      AV1_COMP *cpi, int filter_level,
                                      int partial_frame, RestorationInfo *info,
                                      double *best_tile_cost);

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
const int frame_level_restore_bits[RESTORE_TYPES] = { 2, 2, 2, 2 };

static int64_t sse_restoration_tile(const YV12_BUFFER_CONFIG *src,
                                    AV1_COMMON *const cm, int h_start,
                                    int width, int v_start, int height) {
  int64_t filt_err;
#if CONFIG_AOM_HIGHBITDEPTH
  if (cm->use_highbitdepth) {
    filt_err = aom_highbd_get_y_sse_part(src, cm->frame_to_show, h_start, width,
                                         v_start, height);
  } else {
    filt_err = aom_get_y_sse_part(src, cm->frame_to_show, h_start, width,
                                  v_start, height);
  }
#else
  filt_err = aom_get_y_sse_part(src, cm->frame_to_show, h_start, width, v_start,
                                height);
#endif  // CONFIG_AOM_HIGHBITDEPTH
  return filt_err;
}

static int64_t try_restoration_tile(const YV12_BUFFER_CONFIG *src,
                                    AV1_COMP *const cpi, RestorationInfo *rsi,
                                    int partial_frame, int tile_idx,
                                    int subtile_idx, int subtile_bits) {
  AV1_COMMON *const cm = &cpi->common;
  int64_t filt_err;
  int tile_width, tile_height, nhtiles, nvtiles;
  int h_start, h_end, v_start, v_end;
  const int ntiles = av1_get_rest_ntiles(cm->width, cm->height, &tile_width,
                                         &tile_height, &nhtiles, &nvtiles);
  (void)ntiles;

  av1_loop_restoration_frame(cm->frame_to_show, cm, rsi, 1, partial_frame);
  av1_get_rest_tile_limits(tile_idx, subtile_idx, subtile_bits, nhtiles,
                           nvtiles, tile_width, tile_height, cm->width,
                           cm->height, 0, 0, &h_start, &h_end, &v_start,
                           &v_end);
  filt_err = sse_restoration_tile(src, cm, h_start, h_end - h_start, v_start,
                                  v_end - v_start);

  // Re-instate the unfiltered frame
  aom_yv12_copy_y(&cpi->last_frame_db, cm->frame_to_show);
  return filt_err;
}

static int64_t try_restoration_frame(const YV12_BUFFER_CONFIG *src,
Yaowu Xu's avatar
Yaowu Xu committed
83
                                     AV1_COMP *const cpi, RestorationInfo *rsi,
84
                                     int partial_frame) {
Yaowu Xu's avatar
Yaowu Xu committed
85
  AV1_COMMON *const cm = &cpi->common;
86
  int64_t filt_err;
Yaowu Xu's avatar
Yaowu Xu committed
87
88
  av1_loop_restoration_frame(cm->frame_to_show, cm, rsi, 1, partial_frame);
#if CONFIG_AOM_HIGHBITDEPTH
89
  if (cm->use_highbitdepth) {
90
    filt_err = aom_highbd_get_y_sse(src, cm->frame_to_show);
91
  } else {
92
    filt_err = aom_get_y_sse(src, cm->frame_to_show);
93
94
  }
#else
95
  filt_err = aom_get_y_sse(src, cm->frame_to_show);
Yaowu Xu's avatar
Yaowu Xu committed
96
#endif  // CONFIG_AOM_HIGHBITDEPTH
97
98

  // Re-instate the unfiltered frame
Yaowu Xu's avatar
Yaowu Xu committed
99
  aom_yv12_copy_y(&cpi->last_frame_db, cm->frame_to_show);
100
101
102
  return filt_err;
}

103
104
105
106
static double search_bilateral(const YV12_BUFFER_CONFIG *src, AV1_COMP *cpi,
                               int filter_level, int partial_frame,
                               RestorationInfo *info, double *best_tile_cost) {
  BilateralInfo *bilateral_info = info->bilateral_info;
Yaowu Xu's avatar
Yaowu Xu committed
107
  AV1_COMMON *const cm = &cpi->common;
108
  int i, tile_idx, subtile_idx;
109
  int64_t err;
110
  int bits;
111
  double cost, best_cost, cost_bilateral, cost_norestore_subtile;
Yaowu Xu's avatar
Yaowu Xu committed
112
  const int bilateral_level_bits = av1_bilateral_level_bits(&cpi->common);
113
114
  const int bilateral_levels = 1 << bilateral_level_bits;
  MACROBLOCK *x = &cpi->td.mb;
115
  RestorationInfo rsi;
116
117
118
119
  int tile_width, tile_height, nhtiles, nvtiles;
  int h_start, h_end, v_start, v_end;
  const int ntiles = av1_get_rest_ntiles(cm->width, cm->height, &tile_width,
                                         &tile_height, &nhtiles, &nvtiles);
120
121

  //  Make a copy of the unfiltered / processed recon buffer
Yaowu Xu's avatar
Yaowu Xu committed
122
123
124
125
  aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);
  av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filter_level,
                        1, partial_frame);
  aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_db);
126

127
  rsi.frame_restoration_type = RESTORE_BILATERAL;
128
129
130
  rsi.bilateral_info =
      (BilateralInfo *)aom_malloc(sizeof(*rsi.bilateral_info) * ntiles);
  assert(rsi.bilateral_info != NULL);
131

132
133
134
135
  for (tile_idx = 0; tile_idx < ntiles; ++tile_idx)
    for (subtile_idx = 0; subtile_idx < BILATERAL_SUBTILES; ++subtile_idx)
      bilateral_info[tile_idx].level[subtile_idx] =
          rsi.bilateral_info[tile_idx].level[subtile_idx] = -1;
136
137
138

  // Find best filter for each tile
  for (tile_idx = 0; tile_idx < ntiles; ++tile_idx) {
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
    for (subtile_idx = 0; subtile_idx < BILATERAL_SUBTILES; ++subtile_idx) {
      av1_get_rest_tile_limits(tile_idx, subtile_idx, BILATERAL_SUBTILE_BITS,
                               nhtiles, nvtiles, tile_width, tile_height,
                               cm->width, cm->height, 0, 0, &h_start, &h_end,
                               &v_start, &v_end);
      err = sse_restoration_tile(src, cm, h_start, h_end - h_start, v_start,
                                 v_end - v_start);
#if BILATERAL_SUBTILES
      // #bits when a subtile is not restored
      bits = av1_cost_bit(RESTORE_NONE_BILATERAL_PROB, 0);
#else
      bits = 0;
#endif
      cost_norestore_subtile =
          RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
      best_cost = cost_norestore_subtile;

      for (i = 0; i < bilateral_levels; ++i) {
157
        rsi.bilateral_info[tile_idx].level[subtile_idx] = i;
158
159
160
161
162
163
        err = try_restoration_tile(src, cpi, &rsi, partial_frame, tile_idx,
                                   subtile_idx, BILATERAL_SUBTILE_BITS);
        bits = bilateral_level_bits << AV1_PROB_COST_SHIFT;
        bits += av1_cost_bit(RESTORE_NONE_BILATERAL_PROB, 1);
        cost = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
        if (cost < best_cost) {
164
          bilateral_info[tile_idx].level[subtile_idx] = i;
165
166
          best_cost = cost;
        }
167
        rsi.bilateral_info[tile_idx].level[subtile_idx] = -1;
168
169
      }
    }
170
171
172
173
174
175
    bits = 0;
    for (subtile_idx = 0; subtile_idx < BILATERAL_SUBTILES; ++subtile_idx) {
      rsi.bilateral_info[tile_idx].level[subtile_idx] =
          bilateral_info[tile_idx].level[subtile_idx];
      if (rsi.bilateral_info[tile_idx].level[subtile_idx] >= 0)
        bits += bilateral_level_bits << AV1_PROB_COST_SHIFT;
176
#if BILATERAL_SUBTILES
177
178
179
      bits +=
          av1_cost_bit(RESTORE_NONE_BILATERAL_PROB,
                       rsi.bilateral_info[tile_idx].level[subtile_idx] >= 0);
180
#endif
181
    }
182
183
184
185
    err = try_restoration_tile(src, cpi, &rsi, partial_frame, tile_idx, 0, 0);
    best_tile_cost[tile_idx] = RDCOST_DBL(
        x->rdmult, x->rddiv,
        (bits + cpi->switchable_restore_cost[RESTORE_BILATERAL]) >> 4, err);
186
  }
187
  // Find cost for combined configuration
188
189
  bits = frame_level_restore_bits[rsi.frame_restoration_type]
         << AV1_PROB_COST_SHIFT;
190
191
192
193
194
195
196
  for (tile_idx = 0; tile_idx < ntiles; ++tile_idx) {
    for (subtile_idx = 0; subtile_idx < BILATERAL_SUBTILES; ++subtile_idx) {
      rsi.bilateral_info[tile_idx].level[subtile_idx] =
          bilateral_info[tile_idx].level[subtile_idx];
      if (rsi.bilateral_info[tile_idx].level[subtile_idx] >= 0) {
        bits += bilateral_level_bits << AV1_PROB_COST_SHIFT;
      }
197
#if BILATERAL_SUBTILES
198
199
200
      bits +=
          av1_cost_bit(RESTORE_NONE_BILATERAL_PROB,
                       rsi.bilateral_info[tile_idx].level[subtile_idx] >= 0);
201
#endif
202
    }
203
  }
204
205
  err = try_restoration_frame(src, cpi, &rsi, partial_frame);
  cost_bilateral = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
206

207
  aom_free(rsi.bilateral_info);
208

Yaowu Xu's avatar
Yaowu Xu committed
209
  aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);
210
  return cost_bilateral;
211
212
}

213
214
static double find_average(uint8_t *src, int h_start, int h_end, int v_start,
                           int v_end, int stride) {
215
216
217
  uint64_t sum = 0;
  double avg = 0;
  int i, j;
218
219
220
  for (i = v_start; i < v_end; i++)
    for (j = h_start; j < h_end; j++) sum += src[i * stride + j];
  avg = (double)sum / ((v_end - v_start) * (h_end - h_start));
221
222
223
  return avg;
}

224
225
226
static void compute_stats(uint8_t *dgd, uint8_t *src, int h_start, int h_end,
                          int v_start, int v_end, int dgd_stride,
                          int src_stride, double *M, double *H) {
227
228
  int i, j, k, l;
  double Y[RESTORATION_WIN2];
229
230
  const double avg =
      find_average(dgd, h_start, h_end, v_start, v_end, dgd_stride);
231
232
233

  memset(M, 0, sizeof(*M) * RESTORATION_WIN2);
  memset(H, 0, sizeof(*H) * RESTORATION_WIN2 * RESTORATION_WIN2);
234
235
  for (i = v_start; i < v_end; i++) {
    for (j = h_start; j < h_end; j++) {
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
      const double X = (double)src[i * src_stride + j] - avg;
      int idx = 0;
      for (k = -RESTORATION_HALFWIN; k <= RESTORATION_HALFWIN; k++) {
        for (l = -RESTORATION_HALFWIN; l <= RESTORATION_HALFWIN; l++) {
          Y[idx] = (double)dgd[(i + l) * dgd_stride + (j + k)] - avg;
          idx++;
        }
      }
      for (k = 0; k < RESTORATION_WIN2; ++k) {
        M[k] += Y[k] * X;
        H[k * RESTORATION_WIN2 + k] += Y[k] * Y[k];
        for (l = k + 1; l < RESTORATION_WIN2; ++l) {
          double value = Y[k] * Y[l];
          H[k * RESTORATION_WIN2 + l] += value;
          H[l * RESTORATION_WIN2 + k] += value;
        }
      }
    }
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
257
#if CONFIG_AOM_HIGHBITDEPTH
258
259
static double find_average_highbd(uint16_t *src, int h_start, int h_end,
                                  int v_start, int v_end, int stride) {
260
261
262
  uint64_t sum = 0;
  double avg = 0;
  int i, j;
263
264
265
  for (i = v_start; i < v_end; i++)
    for (j = h_start; j < h_end; j++) sum += src[i * stride + j];
  avg = (double)sum / ((v_end - v_start) * (h_end - h_start));
266
267
268
  return avg;
}

269
270
271
272
static void compute_stats_highbd(uint8_t *dgd8, uint8_t *src8, int h_start,
                                 int h_end, int v_start, int v_end,
                                 int dgd_stride, int src_stride, double *M,
                                 double *H) {
273
274
275
276
  int i, j, k, l;
  double Y[RESTORATION_WIN2];
  uint16_t *src = CONVERT_TO_SHORTPTR(src8);
  uint16_t *dgd = CONVERT_TO_SHORTPTR(dgd8);
277
278
  const double avg =
      find_average_highbd(dgd, h_start, h_end, v_start, v_end, dgd_stride);
279
280
281

  memset(M, 0, sizeof(*M) * RESTORATION_WIN2);
  memset(H, 0, sizeof(*H) * RESTORATION_WIN2 * RESTORATION_WIN2);
282
283
  for (i = v_start; i < v_end; i++) {
    for (j = h_start; j < h_end; j++) {
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
      const double X = (double)src[i * src_stride + j] - avg;
      int idx = 0;
      for (k = -RESTORATION_HALFWIN; k <= RESTORATION_HALFWIN; k++) {
        for (l = -RESTORATION_HALFWIN; l <= RESTORATION_HALFWIN; l++) {
          Y[idx] = (double)dgd[(i + l) * dgd_stride + (j + k)] - avg;
          idx++;
        }
      }
      for (k = 0; k < RESTORATION_WIN2; ++k) {
        M[k] += Y[k] * X;
        H[k * RESTORATION_WIN2 + k] += Y[k] * Y[k];
        for (l = k + 1; l < RESTORATION_WIN2; ++l) {
          double value = Y[k] * Y[l];
          H[k * RESTORATION_WIN2 + l] += value;
          H[l * RESTORATION_WIN2 + k] += value;
        }
      }
    }
  }
}
Yaowu Xu's avatar
Yaowu Xu committed
304
#endif  // CONFIG_AOM_HIGHBITDEPTH
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326

// Solves Ax = b, where x and b are column vectors
static int linsolve(int n, double *A, int stride, double *b, double *x) {
  int i, j, k;
  double c;
  // Partial pivoting
  for (i = n - 1; i > 0; i--) {
    if (A[(i - 1) * stride] < A[i * stride]) {
      for (j = 0; j < n; j++) {
        c = A[i * stride + j];
        A[i * stride + j] = A[(i - 1) * stride + j];
        A[(i - 1) * stride + j] = c;
      }
      c = b[i];
      b[i] = b[i - 1];
      b[i - 1] = c;
    }
  }
  // Forward elimination
  for (k = 0; k < n - 1; k++) {
    for (i = k; i < n - 1; i++) {
      c = A[(i + 1) * stride + k] / A[k * stride + k];
327
      for (j = 0; j < n; j++) A[(i + 1) * stride + j] -= c * A[k * stride + j];
328
329
330
331
332
      b[i + 1] -= c * b[k];
    }
  }
  // Backward substitution
  for (i = n - 1; i >= 0; i--) {
333
    if (fabs(A[i * stride + i]) < 1e-10) return 0;
334
    c = 0;
335
    for (j = i + 1; j <= n - 1; j++) c += A[i * stride + j] * x[j];
336
337
338
339
340
341
342
343
344
345
346
347
348
349
    x[i] = (b[i] - c) / A[i * stride + i];
  }
  return 1;
}

static INLINE int wrap_index(int i) {
  return (i >= RESTORATION_HALFWIN1 ? RESTORATION_WIN - 1 - i : i);
}

// Fix vector b, update vector a
static void update_a_sep_sym(double **Mc, double **Hc, double *a, double *b) {
  int i, j;
  double S[RESTORATION_WIN];
  double A[RESTORATION_WIN], B[RESTORATION_WIN2];
Aamir Anis's avatar
Aamir Anis committed
350
  int w, w2;
351
352
  memset(A, 0, sizeof(A));
  memset(B, 0, sizeof(B));
353
  for (i = 0; i < RESTORATION_WIN; i++) {
354
355
356
357
358
    for (j = 0; j < RESTORATION_WIN; ++j) {
      const int jj = wrap_index(j);
      A[jj] += Mc[i][j] * b[i];
    }
  }
359
360
  for (i = 0; i < RESTORATION_WIN; i++) {
    for (j = 0; j < RESTORATION_WIN; j++) {
361
362
363
364
365
366
      int k, l;
      for (k = 0; k < RESTORATION_WIN; ++k)
        for (l = 0; l < RESTORATION_WIN; ++l) {
          const int kk = wrap_index(k);
          const int ll = wrap_index(l);
          B[ll * RESTORATION_HALFWIN1 + kk] +=
367
368
              Hc[j * RESTORATION_WIN + i][k * RESTORATION_WIN2 + l] * b[i] *
              b[j];
369
370
371
        }
    }
  }
Aamir Anis's avatar
Aamir Anis committed
372
373
374
375
  // Normalization enforcement in the system of equations itself
  w = RESTORATION_WIN;
  w2 = (w >> 1) + 1;
  for (i = 0; i < w2 - 1; ++i)
376
377
    A[i] -=
        A[w2 - 1] * 2 + B[i * w2 + w2 - 1] - 2 * B[(w2 - 1) * w2 + (w2 - 1)];
Aamir Anis's avatar
Aamir Anis committed
378
379
380
381
382
383
384
385
386
  for (i = 0; i < w2 - 1; ++i)
    for (j = 0; j < w2 - 1; ++j)
      B[i * w2 + j] -= 2 * (B[i * w2 + (w2 - 1)] + B[(w2 - 1) * w2 + j] -
                            2 * B[(w2 - 1) * w2 + (w2 - 1)]);
  if (linsolve(w2 - 1, B, w2, A, S)) {
    S[w2 - 1] = 1.0;
    for (i = w2; i < w; ++i) {
      S[i] = S[w - 1 - i];
      S[w2 - 1] -= 2 * S[i];
387
    }
Aamir Anis's avatar
Aamir Anis committed
388
    memcpy(a, S, w * sizeof(*a));
389
390
391
392
393
394
395
396
  }
}

// Fix vector a, update vector b
static void update_b_sep_sym(double **Mc, double **Hc, double *a, double *b) {
  int i, j;
  double S[RESTORATION_WIN];
  double A[RESTORATION_WIN], B[RESTORATION_WIN2];
Aamir Anis's avatar
Aamir Anis committed
397
  int w, w2;
398
399
  memset(A, 0, sizeof(A));
  memset(B, 0, sizeof(B));
400
  for (i = 0; i < RESTORATION_WIN; i++) {
401
    const int ii = wrap_index(i);
402
    for (j = 0; j < RESTORATION_WIN; j++) A[ii] += Mc[i][j] * a[j];
403
404
405
406
407
408
409
410
411
412
  }

  for (i = 0; i < RESTORATION_WIN; i++) {
    for (j = 0; j < RESTORATION_WIN; j++) {
      const int ii = wrap_index(i);
      const int jj = wrap_index(j);
      int k, l;
      for (k = 0; k < RESTORATION_WIN; ++k)
        for (l = 0; l < RESTORATION_WIN; ++l)
          B[jj * RESTORATION_HALFWIN1 + ii] +=
413
414
              Hc[i * RESTORATION_WIN + j][k * RESTORATION_WIN2 + l] * a[k] *
              a[l];
415
416
    }
  }
Aamir Anis's avatar
Aamir Anis committed
417
418
419
420
  // Normalization enforcement in the system of equations itself
  w = RESTORATION_WIN;
  w2 = RESTORATION_HALFWIN1;
  for (i = 0; i < w2 - 1; ++i)
421
422
    A[i] -=
        A[w2 - 1] * 2 + B[i * w2 + w2 - 1] - 2 * B[(w2 - 1) * w2 + (w2 - 1)];
Aamir Anis's avatar
Aamir Anis committed
423
424
425
426
427
428
429
430
431
  for (i = 0; i < w2 - 1; ++i)
    for (j = 0; j < w2 - 1; ++j)
      B[i * w2 + j] -= 2 * (B[i * w2 + (w2 - 1)] + B[(w2 - 1) * w2 + j] -
                            2 * B[(w2 - 1) * w2 + (w2 - 1)]);
  if (linsolve(w2 - 1, B, w2, A, S)) {
    S[w2 - 1] = 1.0;
    for (i = w2; i < w; ++i) {
      S[i] = S[w - 1 - i];
      S[w2 - 1] -= 2 * S[i];
432
    }
Aamir Anis's avatar
Aamir Anis committed
433
    memcpy(b, S, w * sizeof(*b));
434
435
436
  }
}

437
438
static int wiener_decompose_sep_sym(double *M, double *H, double *a,
                                    double *b) {
439
  static const double init_filt[RESTORATION_WIN] = {
440
    0.035623, -0.127154, 0.211436, 0.760190, 0.211436, -0.127154, 0.035623,
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
  };
  int i, j, iter;
  double *Hc[RESTORATION_WIN2];
  double *Mc[RESTORATION_WIN];
  for (i = 0; i < RESTORATION_WIN; i++) {
    Mc[i] = M + i * RESTORATION_WIN;
    for (j = 0; j < RESTORATION_WIN; j++) {
      Hc[i * RESTORATION_WIN + j] =
          H + i * RESTORATION_WIN * RESTORATION_WIN2 + j * RESTORATION_WIN;
    }
  }
  memcpy(a, init_filt, sizeof(*a) * RESTORATION_WIN);
  memcpy(b, init_filt, sizeof(*b) * RESTORATION_WIN);

  iter = 1;
  while (iter < 10) {
    update_a_sep_sym(Mc, Hc, a, b);
    update_b_sep_sym(Mc, Hc, a, b);
    iter++;
  }
461
  return 1;
462
463
}

Aamir Anis's avatar
Aamir Anis committed
464
465
466
// Computes the function x'*A*x - x'*b for the learned filters, and compares
// against identity filters; Final score is defined as the difference between
// the function values
467
static double compute_score(double *M, double *H, int *vfilt, int *hfilt) {
Aamir Anis's avatar
Aamir Anis committed
468
469
470
471
472
473
474
475
476
477
  double ab[RESTORATION_WIN * RESTORATION_WIN];
  int i, k, l;
  double P = 0, Q = 0;
  double iP = 0, iQ = 0;
  double Score, iScore;
  int w;
  double a[RESTORATION_WIN], b[RESTORATION_WIN];
  w = RESTORATION_WIN;
  a[RESTORATION_HALFWIN] = b[RESTORATION_HALFWIN] = 1.0;
  for (i = 0; i < RESTORATION_HALFWIN; ++i) {
478
479
480
481
    a[i] = a[RESTORATION_WIN - i - 1] =
        (double)vfilt[i] / RESTORATION_FILT_STEP;
    b[i] = b[RESTORATION_WIN - i - 1] =
        (double)hfilt[i] / RESTORATION_FILT_STEP;
Aamir Anis's avatar
Aamir Anis committed
482
483
484
485
    a[RESTORATION_HALFWIN] -= 2 * a[i];
    b[RESTORATION_HALFWIN] -= 2 * b[i];
  }
  for (k = 0; k < w; ++k) {
486
    for (l = 0; l < w; ++l) ab[k * w + l] = a[l] * b[k];
Aamir Anis's avatar
Aamir Anis committed
487
488
489
  }
  for (k = 0; k < w * w; ++k) {
    P += ab[k] * M[k];
490
    for (l = 0; l < w * w; ++l) Q += ab[k] * H[k * w * w + l] * ab[l];
Aamir Anis's avatar
Aamir Anis committed
491
492
493
494
495
496
497
498
499
500
  }
  Score = Q - 2 * P;

  iP = M[(w * w) >> 1];
  iQ = H[((w * w) >> 1) * w * w + ((w * w) >> 1)];
  iScore = iQ - 2 * iP;

  return Score - iScore;
}

501
#define CLIP(x, lo, hi) ((x) < (lo) ? (lo) : (x) > (hi) ? (hi) : (x))
502
#define RINT(x) ((x) < 0 ? (int)((x)-0.5) : (int)((x) + 0.5))
503
504
505
506
507
508
509
510
511
512
513
514

static void quantize_sym_filter(double *f, int *fi) {
  int i;
  for (i = 0; i < RESTORATION_HALFWIN; ++i) {
    fi[i] = RINT(f[i] * RESTORATION_FILT_STEP);
  }
  // Specialize for 7-tap filter
  fi[0] = CLIP(fi[0], WIENER_FILT_TAP0_MINV, WIENER_FILT_TAP0_MAXV);
  fi[1] = CLIP(fi[1], WIENER_FILT_TAP1_MINV, WIENER_FILT_TAP1_MAXV);
  fi[2] = CLIP(fi[2], WIENER_FILT_TAP2_MINV, WIENER_FILT_TAP2_MAXV);
}

515
516
517
518
static double search_wiener(const YV12_BUFFER_CONFIG *src, AV1_COMP *cpi,
                            int filter_level, int partial_frame,
                            RestorationInfo *info, double *best_tile_cost) {
  WienerInfo *wiener_info = info->wiener_info;
Yaowu Xu's avatar
Yaowu Xu committed
519
  AV1_COMMON *const cm = &cpi->common;
520
  RestorationInfo rsi;
521
522
  int64_t err;
  int bits;
523
  double cost_wiener, cost_norestore_tile;
524
525
526
527
528
529
530
531
532
  MACROBLOCK *x = &cpi->td.mb;
  double M[RESTORATION_WIN2];
  double H[RESTORATION_WIN2 * RESTORATION_WIN2];
  double vfilterd[RESTORATION_WIN], hfilterd[RESTORATION_WIN];
  const YV12_BUFFER_CONFIG *dgd = cm->frame_to_show;
  const int width = cm->width;
  const int height = cm->height;
  const int src_stride = src->y_stride;
  const int dgd_stride = dgd->y_stride;
Aamir Anis's avatar
Aamir Anis committed
533
  double score;
534
  int tile_idx, tile_width, tile_height, nhtiles, nvtiles;
535
536
537
  int h_start, h_end, v_start, v_end;
  int i, j;

538
539
  const int ntiles = av1_get_rest_ntiles(width, height, &tile_width,
                                         &tile_height, &nhtiles, &nvtiles);
540
541
542
543
544
545
  assert(width == dgd->y_crop_width);
  assert(height == dgd->y_crop_height);
  assert(width == src->y_crop_width);
  assert(height == src->y_crop_height);

  //  Make a copy of the unfiltered / processed recon buffer
Yaowu Xu's avatar
Yaowu Xu committed
546
547
548
549
  aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);
  av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filter_level,
                        1, partial_frame);
  aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_db);
550

551
  rsi.frame_restoration_type = RESTORE_WIENER;
552
553
554
555
  rsi.wiener_info = (WienerInfo *)aom_malloc(sizeof(*rsi.wiener_info) * ntiles);
  assert(rsi.wiener_info != NULL);

  for (j = 0; j < ntiles; ++j) rsi.wiener_info[j].level = 0;
556
557
558

  // Compute best Wiener filters for each tile
  for (tile_idx = 0; tile_idx < ntiles; ++tile_idx) {
559
560
561
562
563
564
565
566
    av1_get_rest_tile_limits(tile_idx, 0, 0, nhtiles, nvtiles, tile_width,
                             tile_height, width, height, 0, 0, &h_start, &h_end,
                             &v_start, &v_end);
    err = sse_restoration_tile(src, cm, h_start, h_end - h_start, v_start,
                               v_end - v_start);
    // #bits when a tile is not restored
    bits = av1_cost_bit(RESTORE_NONE_WIENER_PROB, 0);
    cost_norestore_tile = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
567
    best_tile_cost[tile_idx] = DBL_MAX;
568
569
570
571

    av1_get_rest_tile_limits(tile_idx, 0, 0, nhtiles, nvtiles, tile_width,
                             tile_height, width, height, 1, 1, &h_start, &h_end,
                             &v_start, &v_end);
Yaowu Xu's avatar
Yaowu Xu committed
572
#if CONFIG_AOM_HIGHBITDEPTH
573
574
575
576
    if (cm->use_highbitdepth)
      compute_stats_highbd(dgd->y_buffer, src->y_buffer, h_start, h_end,
                           v_start, v_end, dgd_stride, src_stride, M, H);
    else
Yaowu Xu's avatar
Yaowu Xu committed
577
#endif  // CONFIG_AOM_HIGHBITDEPTH
578
579
580
      compute_stats(dgd->y_buffer, src->y_buffer, h_start, h_end, v_start,
                    v_end, dgd_stride, src_stride, M, H);

581
    wiener_info[tile_idx].level = 1;
582
    if (!wiener_decompose_sep_sym(M, H, vfilterd, hfilterd)) {
583
      wiener_info[tile_idx].level = 0;
584
585
      continue;
    }
586
587
    quantize_sym_filter(vfilterd, rsi.wiener_info[tile_idx].vfilter);
    quantize_sym_filter(hfilterd, rsi.wiener_info[tile_idx].hfilter);
588
589
590
591

    // Filter score computes the value of the function x'*A*x - x'*b for the
    // learned filter and compares it against identity filer. If there is no
    // reduction in the function, the filter is reverted back to identity
592
593
    score = compute_score(M, H, rsi.wiener_info[tile_idx].vfilter,
                          rsi.wiener_info[tile_idx].hfilter);
594
    if (score > 0.0) {
595
      wiener_info[tile_idx].level = 0;
596
597
      continue;
    }
598

599
    rsi.wiener_info[tile_idx].level = 1;
600
601
602
603
    err = try_restoration_tile(src, cpi, &rsi, partial_frame, tile_idx, 0, 0);
    bits = WIENER_FILT_BITS << AV1_PROB_COST_SHIFT;
    bits += av1_cost_bit(RESTORE_NONE_WIENER_PROB, 1);
    cost_wiener = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
604
605
606
607
608
609
610
611
    if (cost_wiener >= cost_norestore_tile) {
      wiener_info[tile_idx].level = 0;
    } else {
      wiener_info[tile_idx].level = 1;
      for (i = 0; i < RESTORATION_HALFWIN; ++i) {
        wiener_info[tile_idx].vfilter[i] = rsi.wiener_info[tile_idx].vfilter[i];
        wiener_info[tile_idx].hfilter[i] = rsi.wiener_info[tile_idx].hfilter[i];
      }
612
613
614
615
616
      bits = WIENER_FILT_BITS << AV1_PROB_COST_SHIFT;
      best_tile_cost[tile_idx] = RDCOST_DBL(
          x->rdmult, x->rddiv,
          (bits + cpi->switchable_restore_cost[RESTORE_WIENER]) >> 4, err);
    }
617
    rsi.wiener_info[tile_idx].level = 0;
618
  }
619
  // Cost for Wiener filtering
620
621
  bits = frame_level_restore_bits[rsi.frame_restoration_type]
         << AV1_PROB_COST_SHIFT;
622
  for (tile_idx = 0; tile_idx < ntiles; ++tile_idx) {
623
624
625
    bits += av1_cost_bit(RESTORE_NONE_WIENER_PROB, wiener_info[tile_idx].level);
    rsi.wiener_info[tile_idx].level = wiener_info[tile_idx].level;
    if (wiener_info[tile_idx].level) {
626
      bits += (WIENER_FILT_BITS << AV1_PROB_COST_SHIFT);
627
628
629
630
631
      for (i = 0; i < RESTORATION_HALFWIN; ++i) {
        rsi.wiener_info[tile_idx].vfilter[i] = wiener_info[tile_idx].vfilter[i];
        rsi.wiener_info[tile_idx].hfilter[i] = wiener_info[tile_idx].hfilter[i];
      }
    }
Aamir Anis's avatar
Aamir Anis committed
632
  }
633
  err = try_restoration_frame(src, cpi, &rsi, partial_frame);
634
  cost_wiener = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
635
  aom_free(rsi.wiener_info);
636

Yaowu Xu's avatar
Yaowu Xu committed
637
  aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);
638
  return cost_wiener;
639
640
}

641
642
643
644
645
static double search_norestore(const YV12_BUFFER_CONFIG *src, AV1_COMP *cpi,
                               int filter_level, int partial_frame,
                               RestorationInfo *info, double *best_tile_cost) {
  double err, cost_norestore;
  int bits;
646
  MACROBLOCK *x = &cpi->td.mb;
647
648
  AV1_COMMON *const cm = &cpi->common;
  int tile_idx, tile_width, tile_height, nhtiles, nvtiles;
649
650
651
  int h_start, h_end, v_start, v_end;
  const int ntiles = av1_get_rest_ntiles(cm->width, cm->height, &tile_width,
                                         &tile_height, &nhtiles, &nvtiles);
652
  (void)info;
653
654
655
656
657
658
659
660
661
662
663
664
665

  //  Make a copy of the unfiltered / processed recon buffer
  aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);
  av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filter_level,
                        1, partial_frame);
  aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_db);

  for (tile_idx = 0; tile_idx < ntiles; ++tile_idx) {
    av1_get_rest_tile_limits(tile_idx, 0, 0, nhtiles, nvtiles, tile_width,
                             tile_height, cm->width, cm->height, 0, 0, &h_start,
                             &h_end, &v_start, &v_end);
    err = sse_restoration_tile(src, cm, h_start, h_end - h_start, v_start,
                               v_end - v_start);
666
    best_tile_cost[tile_idx] =
667
668
        RDCOST_DBL(x->rdmult, x->rddiv,
                   (cpi->switchable_restore_cost[RESTORE_NONE] >> 4), err);
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
  }
  // RD cost associated with no restoration
  err = sse_restoration_tile(src, cm, 0, cm->width, 0, cm->height);
  bits = frame_level_restore_bits[RESTORE_NONE] << AV1_PROB_COST_SHIFT;
  cost_norestore = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
  aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);
  return cost_norestore;
}

static double search_switchable_restoration(
    AV1_COMP *cpi, int filter_level, int partial_frame, RestorationInfo *rsi,
    double *tile_cost[RESTORE_SWITCHABLE_TYPES]) {
  AV1_COMMON *const cm = &cpi->common;
  MACROBLOCK *x = &cpi->td.mb;
  double cost_switchable = 0;
  int r, bits, tile_idx;
  const int ntiles =
      av1_get_rest_ntiles(cm->width, cm->height, NULL, NULL, NULL, NULL);

  //  Make a copy of the unfiltered / processed recon buffer
  aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);
  av1_loop_filter_frame(cm->frame_to_show, cm, &cpi->td.mb.e_mbd, filter_level,
                        1, partial_frame);
  aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_db);

  rsi->frame_restoration_type = RESTORE_SWITCHABLE;
  bits = frame_level_restore_bits[rsi->frame_restoration_type]
         << AV1_PROB_COST_SHIFT;
  cost_switchable = RDCOST_DBL(x->rdmult, x->rddiv, bits >> 4, 0);
  for (tile_idx = 0; tile_idx < ntiles; ++tile_idx) {
    double best_cost = tile_cost[RESTORE_NONE][tile_idx];
    rsi->restoration_type[tile_idx] = RESTORE_NONE;
    for (r = 1; r < RESTORE_SWITCHABLE_TYPES; r++) {
      if (tile_cost[r][tile_idx] < best_cost) {
        rsi->restoration_type[tile_idx] = r;
        best_cost = tile_cost[r][tile_idx];
705
706
      }
    }
707
    cost_switchable += best_cost;
708
709
  }
  aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);
710
  return cost_switchable;
711
712
713
}

void av1_pick_filter_restoration(const YV12_BUFFER_CONFIG *src, AV1_COMP *cpi,
Yaowu Xu's avatar
Yaowu Xu committed
714
                                 LPF_PICK_METHOD method) {
715
716
717
  static search_restore_type search_restore_fun[RESTORE_SWITCHABLE_TYPES] = {
    search_norestore, search_bilateral, search_wiener,
  };
Yaowu Xu's avatar
Yaowu Xu committed
718
  AV1_COMMON *const cm = &cpi->common;
719
  struct loopfilter *const lf = &cm->lf;
720
721
722
723
724
  double cost_restore[RESTORE_TYPES];
  double *tile_cost[RESTORE_SWITCHABLE_TYPES];
  double best_cost_restore;
  RestorationType r, best_restore;

725
726
727
728
729
  const int ntiles =
      av1_get_rest_ntiles(cm->width, cm->height, NULL, NULL, NULL, NULL);
  cm->rst_info.restoration_type = (RestorationType *)aom_realloc(
      cm->rst_info.restoration_type,
      sizeof(*cm->rst_info.restoration_type) * ntiles);
730
731
732
733
734
735
736
737
738
739
  cm->rst_info.bilateral_info = (BilateralInfo *)aom_realloc(
      cm->rst_info.bilateral_info,
      sizeof(*cm->rst_info.bilateral_info) * ntiles);
  assert(cm->rst_info.bilateral_info != NULL);
  cm->rst_info.wiener_info = (WienerInfo *)aom_realloc(
      cm->rst_info.wiener_info, sizeof(*cm->rst_info.wiener_info) * ntiles);
  assert(cm->rst_info.wiener_info != NULL);

  for (r = 0; r < RESTORE_SWITCHABLE_TYPES; r++)
    tile_cost[r] = (double *)aom_malloc(sizeof(*tile_cost[0]) * ntiles);
740

741
  lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0 : cpi->oxcf.sharpness;
742
743

  if (method == LPF_PICK_MINIMAL_LPF && lf->filter_level) {
744
    lf->filter_level = 0;
745
    cm->rst_info.frame_restoration_type = RESTORE_NONE;
746
747
  } else if (method >= LPF_PICK_FROM_Q) {
    const int min_filter_level = 0;
Yaowu Xu's avatar
Yaowu Xu committed
748
749
    const int max_filter_level = av1_get_max_filter_level(cpi);
    const int q = av1_ac_quant(cm->base_qindex, 0, cm->bit_depth);
750
751
// These values were determined by linear fitting the result of the
// searched level, filt_guess = q * 0.316206 + 3.87252
Yaowu Xu's avatar
Yaowu Xu committed
752
#if CONFIG_AOM_HIGHBITDEPTH
753
754
    int filt_guess;
    switch (cm->bit_depth) {
Yaowu Xu's avatar
Yaowu Xu committed
755
      case AOM_BITS_8:
756
757
        filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 1015158, 18);
        break;
Yaowu Xu's avatar
Yaowu Xu committed
758
      case AOM_BITS_10:
759
760
        filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 4060632, 20);
        break;
Yaowu Xu's avatar
Yaowu Xu committed
761
      case AOM_BITS_12:
762
763
764
        filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 16242526, 22);
        break;
      default:
765
        assert(0 &&
Yaowu Xu's avatar
Yaowu Xu committed
766
767
               "bit_depth should be AOM_BITS_8, AOM_BITS_10 "
               "or AOM_BITS_12");
768
769
770
771
        return;
    }
#else
    int filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 1015158, 18);
Yaowu Xu's avatar
Yaowu Xu committed
772
#endif  // CONFIG_AOM_HIGHBITDEPTH
773
    if (cm->frame_type == KEY_FRAME) filt_guess -= 4;
774
775
    lf->filter_level = clamp(filt_guess, min_filter_level, max_filter_level);
  } else {
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
    lf->filter_level =
        av1_search_filter_level(src, cpi, method == LPF_PICK_FROM_SUBIMAGE,
                                &cost_restore[RESTORE_NONE]);
  }
  for (r = 0; r < RESTORE_SWITCHABLE_TYPES; ++r) {
    cost_restore[r] = search_restore_fun[r](src, cpi, lf->filter_level,
                                            method == LPF_PICK_FROM_SUBIMAGE,
                                            &cm->rst_info, tile_cost[r]);
  }
  cost_restore[RESTORE_SWITCHABLE] = search_switchable_restoration(
      cpi, lf->filter_level, method == LPF_PICK_FROM_SUBIMAGE, &cm->rst_info,
      tile_cost);

  best_cost_restore = DBL_MAX;
  best_restore = 0;
  for (r = 0; r < RESTORE_TYPES; ++r) {
    if (cost_restore[r] < best_cost_restore) {
      best_restore = r;
      best_cost_restore = cost_restore[r];
    }
796
  }
797
798
799
800
801
802
803
804
  cm->rst_info.frame_restoration_type = best_restore;
  /*
  printf("Frame %d/%d frame_restore_type %d : %f %f %f %f\n",
         cm->current_video_frame, cm->show_frame,
         cm->rst_info.frame_restoration_type,
         cost_restore[0], cost_restore[1], cost_restore[2], cost_restore[3]);
         */
  for (r = 0; r < RESTORE_SWITCHABLE_TYPES; r++) aom_free(tile_cost[r]);
805
}