AOMedia AV1 Codec: av1/common/restoration.h Source File

| AOMedia AV1 Codec

restoration.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3 *
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10 */
11
12#ifndef AOM_AV1_COMMON_RESTORATION_H_
13#define AOM_AV1_COMMON_RESTORATION_H_
14
15#include "aom_ports/mem.h"
16#include "config/aom_config.h"
17
18#include "av1/common/blockd.h"
19#include "av1/common/enums.h"
20
21#ifdef __cplusplus
22extern "C" {
23#endif
24
29// Border for Loop restoration buffer
30#define AOM_RESTORATION_FRAME_BORDER 32
31#define CLIP(x, lo, hi) ((x) < (lo) ? (lo) : (x) > (hi) ? (hi) : (x))
32#define RINT(x) ((x) < 0 ? (int)((x)-0.5) : (int)((x) + 0.5))
33
34#define RESTORATION_PROC_UNIT_SIZE 64
35
36// Filter tile grid offset upwards compared to the superblock grid
37#define RESTORATION_UNIT_OFFSET 8
38
39#define SGRPROJ_BORDER_VERT 3 // Vertical border used for Sgr
40#define SGRPROJ_BORDER_HORZ 3 // Horizontal border used for Sgr
41
42#define WIENER_BORDER_VERT 2 // Vertical border used for Wiener
43#define WIENER_HALFWIN 3
44#define WIENER_BORDER_HORZ (WIENER_HALFWIN) // Horizontal border for Wiener
45
46// RESTORATION_BORDER_VERT determines line buffer requirement for LR.
47// Should be set at the max of SGRPROJ_BORDER_VERT and WIENER_BORDER_VERT.
48// Note the line buffer needed is twice the value of this macro.
49#if SGRPROJ_BORDER_VERT >= WIENER_BORDER_VERT
50#define RESTORATION_BORDER_VERT (SGRPROJ_BORDER_VERT)
51#else
52#define RESTORATION_BORDER_VERT (WIENER_BORDER_VERT)
53#endif // SGRPROJ_BORDER_VERT >= WIENER_BORDER_VERT
54
55#if SGRPROJ_BORDER_HORZ >= WIENER_BORDER_HORZ
56#define RESTORATION_BORDER_HORZ (SGRPROJ_BORDER_HORZ)
57#else
58#define RESTORATION_BORDER_HORZ (WIENER_BORDER_HORZ)
59#endif // SGRPROJ_BORDER_VERT >= WIENER_BORDER_VERT
60
61// How many border pixels do we need for each processing unit?
62#define RESTORATION_BORDER 3
63
64// How many rows of deblocked pixels do we save above/below each processing
65// stripe?
66#define RESTORATION_CTX_VERT 2
67
68// Additional pixels to the left and right in above/below buffers
69// It is RESTORATION_BORDER_HORZ rounded up to get nicer buffer alignment
70#define RESTORATION_EXTRA_HORZ 4
71
72// Pad up to 20 more (may be much less is needed)
73#define RESTORATION_PADDING 20
74#define RESTORATION_PROC_UNIT_PELS \
75 ((RESTORATION_PROC_UNIT_SIZE + RESTORATION_BORDER_HORZ * 2 + \
76 RESTORATION_PADDING) * \
77 (RESTORATION_PROC_UNIT_SIZE + RESTORATION_BORDER_VERT * 2 + \
78 RESTORATION_PADDING))
79
80#define RESTORATION_UNITSIZE_MAX 256
81#define RESTORATION_UNITPELS_HORZ_MAX \
82 (RESTORATION_UNITSIZE_MAX * 3 / 2 + 2 * RESTORATION_BORDER_HORZ + 16)
83#define RESTORATION_UNITPELS_VERT_MAX \
84 ((RESTORATION_UNITSIZE_MAX * 3 / 2 + 2 * RESTORATION_BORDER_VERT + \
85 RESTORATION_UNIT_OFFSET))
86#define RESTORATION_UNITPELS_MAX \
87 (RESTORATION_UNITPELS_HORZ_MAX * RESTORATION_UNITPELS_VERT_MAX)
88
89// Two 32-bit buffers needed for the restored versions from two filters
90// TODO(debargha, rupert): Refactor to not need the large tilesize to be stored
91// on the decoder side.
92#define SGRPROJ_TMPBUF_SIZE (RESTORATION_UNITPELS_MAX * 2 * sizeof(int32_t))
93
94#define SGRPROJ_EXTBUF_SIZE (0)
95#define SGRPROJ_PARAMS_BITS 4
96#define SGRPROJ_PARAMS (1 << SGRPROJ_PARAMS_BITS)
97
98// Precision bits for projection
99#define SGRPROJ_PRJ_BITS 7
100// Restoration precision bits generated higher than source before projection
101#define SGRPROJ_RST_BITS 4
102// Internal precision bits for core selfguided_restoration
103#define SGRPROJ_SGR_BITS 8
104#define SGRPROJ_SGR (1 << SGRPROJ_SGR_BITS)
105
106#define SGRPROJ_PRJ_MIN0 (-(1 << SGRPROJ_PRJ_BITS) * 3 / 4)
107#define SGRPROJ_PRJ_MAX0 (SGRPROJ_PRJ_MIN0 + (1 << SGRPROJ_PRJ_BITS) - 1)
108#define SGRPROJ_PRJ_MIN1 (-(1 << SGRPROJ_PRJ_BITS) / 4)
109#define SGRPROJ_PRJ_MAX1 (SGRPROJ_PRJ_MIN1 + (1 << SGRPROJ_PRJ_BITS) - 1)
110
111#define SGRPROJ_PRJ_SUBEXP_K 4
112
113#define SGRPROJ_BITS (SGRPROJ_PRJ_BITS * 2 + SGRPROJ_PARAMS_BITS)
114
115#define MAX_RADIUS 2 // Only 1, 2, 3 allowed
116#define MAX_NELEM ((2 * MAX_RADIUS + 1) * (2 * MAX_RADIUS + 1))
117#define SGRPROJ_MTABLE_BITS 20
118#define SGRPROJ_RECIP_BITS 12
119
120#define WIENER_HALFWIN1 (WIENER_HALFWIN + 1)
121#define WIENER_WIN (2 * WIENER_HALFWIN + 1)
122#define WIENER_WIN2 ((WIENER_WIN) * (WIENER_WIN))
123#define WIENER_TMPBUF_SIZE (0)
124#define WIENER_EXTBUF_SIZE (0)
125
126// If WIENER_WIN_CHROMA == WIENER_WIN - 2, that implies 5x5 filters are used for
127// chroma. To use 7x7 for chroma set WIENER_WIN_CHROMA to WIENER_WIN.
128#define WIENER_WIN_CHROMA (WIENER_WIN - 2)
129#define WIENER_WIN_REDUCED (WIENER_WIN - 2)
130#define WIENER_WIN2_CHROMA ((WIENER_WIN_CHROMA) * (WIENER_WIN_CHROMA))
131#define WIENER_STATS_DOWNSAMPLE_FACTOR 4
132
133#define WIENER_FILT_PREC_BITS 7
134#define WIENER_FILT_STEP (1 << WIENER_FILT_PREC_BITS)
135
136// Central values for the taps
137#define WIENER_FILT_TAP0_MIDV (3)
138#define WIENER_FILT_TAP1_MIDV (-7)
139#define WIENER_FILT_TAP2_MIDV (15)
140#define WIENER_FILT_TAP3_MIDV \
141 (WIENER_FILT_STEP - 2 * (WIENER_FILT_TAP0_MIDV + WIENER_FILT_TAP1_MIDV + \
142 WIENER_FILT_TAP2_MIDV))
143
144#define WIENER_FILT_TAP0_BITS 4
145#define WIENER_FILT_TAP1_BITS 5
146#define WIENER_FILT_TAP2_BITS 6
147
148#define WIENER_FILT_BITS \
149 ((WIENER_FILT_TAP0_BITS + WIENER_FILT_TAP1_BITS + WIENER_FILT_TAP2_BITS) * 2)
150
151#define WIENER_FILT_TAP0_MINV \
152 (WIENER_FILT_TAP0_MIDV - (1 << WIENER_FILT_TAP0_BITS) / 2)
153#define WIENER_FILT_TAP1_MINV \
154 (WIENER_FILT_TAP1_MIDV - (1 << WIENER_FILT_TAP1_BITS) / 2)
155#define WIENER_FILT_TAP2_MINV \
156 (WIENER_FILT_TAP2_MIDV - (1 << WIENER_FILT_TAP2_BITS) / 2)
157
158#define WIENER_FILT_TAP0_MAXV \
159 (WIENER_FILT_TAP0_MIDV - 1 + (1 << WIENER_FILT_TAP0_BITS) / 2)
160#define WIENER_FILT_TAP1_MAXV \
161 (WIENER_FILT_TAP1_MIDV - 1 + (1 << WIENER_FILT_TAP1_BITS) / 2)
162#define WIENER_FILT_TAP2_MAXV \
163 (WIENER_FILT_TAP2_MIDV - 1 + (1 << WIENER_FILT_TAP2_BITS) / 2)
164
165#define WIENER_FILT_TAP0_SUBEXP_K 1
166#define WIENER_FILT_TAP1_SUBEXP_K 2
167#define WIENER_FILT_TAP2_SUBEXP_K 3
168
169// Max of SGRPROJ_TMPBUF_SIZE, DOMAINTXFMRF_TMPBUF_SIZE, WIENER_TMPBUF_SIZE
170#define RESTORATION_TMPBUF_SIZE (SGRPROJ_TMPBUF_SIZE)
171
172// Max of SGRPROJ_EXTBUF_SIZE, WIENER_EXTBUF_SIZE
173#define RESTORATION_EXTBUF_SIZE (WIENER_EXTBUF_SIZE)
174
175// Check the assumptions of the existing code
176#if SUBPEL_TAPS != WIENER_WIN + 1
177#error "Wiener filter currently only works if SUBPEL_TAPS == WIENER_WIN + 1"
178#endif
179#if WIENER_FILT_PREC_BITS != 7
180#error "Wiener filter currently only works if WIENER_FILT_PREC_BITS == 7"
181#endif
182
183#define LR_TILE_ROW 0
184#define LR_TILE_COL 0
185#define LR_TILE_COLS 1
186
187typedef struct {
188 int r[2]; // radii
189 int s[2]; // sgr parameters for r[0] and r[1], based on GenSgrprojVtable()
190} sgr_params_type;
194 typedef struct {
198 RestorationType restoration_type;
199
203 WienerInfo wiener_info;
204
208 SgrprojInfo sgrproj_info;
209} RestorationUnitInfo;
210
213// A restoration line buffer needs space for two lines plus a horizontal filter
214// margin of RESTORATION_EXTRA_HORZ on each side.
215#define RESTORATION_LINEBUFFER_WIDTH \
216 (RESTORATION_UNITSIZE_MAX * 3 / 2 + 2 * RESTORATION_EXTRA_HORZ)
217
218// Similarly, the column buffers (used when we're at a vertical tile edge
219// that we can't filter across) need space for one processing unit's worth
220// of pixels, plus the top/bottom border width
221#define RESTORATION_COLBUFFER_HEIGHT \
222 (RESTORATION_PROC_UNIT_SIZE + 2 * RESTORATION_BORDER)
223
224typedef struct {
225 // Temporary buffers to save/restore 3 lines above/below the restoration
226 // stripe.
227 uint16_t tmp_save_above[RESTORATION_BORDER][RESTORATION_LINEBUFFER_WIDTH];
228 uint16_t tmp_save_below[RESTORATION_BORDER][RESTORATION_LINEBUFFER_WIDTH];
229} RestorationLineBuffers;
233 typedef struct {
237 uint8_t *stripe_boundary_above;
238
242 uint8_t *stripe_boundary_below;
243
247 int stripe_boundary_stride;
248
252 int stripe_boundary_size;
253} RestorationStripeBoundaries;
254
256 typedef struct {
260 RestorationType frame_restoration_type;
261
265 int restoration_unit_size;
266
276 int units_per_tile;
277
281 int vert_units_per_tile;
282
286 int horz_units_per_tile;
296 RestorationUnitInfo *unit_info;
297
301 RestorationStripeBoundaries boundaries;
302
308 int optimized_lr;
309} RestorationInfo;
310
313static INLINE void set_default_sgrproj(SgrprojInfo *sgrproj_info) {
314 sgrproj_info->xqd[0] = (SGRPROJ_PRJ_MIN0 + SGRPROJ_PRJ_MAX0) / 2;
315 sgrproj_info->xqd[1] = (SGRPROJ_PRJ_MIN1 + SGRPROJ_PRJ_MAX1) / 2;
316}
317
318static INLINE void set_default_wiener(WienerInfo *wiener_info) {
319 wiener_info->vfilter[0] = wiener_info->hfilter[0] = WIENER_FILT_TAP0_MIDV;
320 wiener_info->vfilter[1] = wiener_info->hfilter[1] = WIENER_FILT_TAP1_MIDV;
321 wiener_info->vfilter[2] = wiener_info->hfilter[2] = WIENER_FILT_TAP2_MIDV;
322 wiener_info->vfilter[WIENER_HALFWIN] = wiener_info->hfilter[WIENER_HALFWIN] =
323 -2 *
324 (WIENER_FILT_TAP2_MIDV + WIENER_FILT_TAP1_MIDV + WIENER_FILT_TAP0_MIDV);
325 wiener_info->vfilter[4] = wiener_info->hfilter[4] = WIENER_FILT_TAP2_MIDV;
326 wiener_info->vfilter[5] = wiener_info->hfilter[5] = WIENER_FILT_TAP1_MIDV;
327 wiener_info->vfilter[6] = wiener_info->hfilter[6] = WIENER_FILT_TAP0_MIDV;
328}
329
330typedef struct {
331 int h_start, h_end, v_start, v_end;
332} RestorationTileLimits;
333
334typedef void (*rest_unit_visitor_t)(const RestorationTileLimits *limits,
335 const PixelRect *tile_rect,
336 int rest_unit_idx, void *priv,
337 int32_t *tmpbuf,
338 RestorationLineBuffers *rlbs);
339
340typedef struct FilterFrameCtxt {
341 const RestorationInfo *rsi;
342 int tile_stripe0;
343 int ss_x, ss_y;
344 int highbd, bit_depth;
345 uint8_t *data8, *dst8;
346 int data_stride, dst_stride;
347 PixelRect tile_rect;
348} FilterFrameCtxt;
349
350typedef struct AV1LrStruct {
351 rest_unit_visitor_t on_rest_unit;
352 FilterFrameCtxt ctxt[MAX_MB_PLANE];
353 YV12_BUFFER_CONFIG *frame;
354 YV12_BUFFER_CONFIG *dst;
355} AV1LrStruct;
356
357extern const sgr_params_type av1_sgr_params[SGRPROJ_PARAMS];
358extern int sgrproj_mtable[SGRPROJ_PARAMS][2];
359extern const int32_t av1_x_by_xplus1[256];
360extern const int32_t av1_one_by_x[MAX_NELEM];
361
362void av1_alloc_restoration_struct(struct AV1Common *cm, RestorationInfo *rsi,
363 int is_uv);
364void av1_free_restoration_struct(RestorationInfo *rst_info);
365
366void av1_extend_frame(uint8_t *data, int width, int height, int stride,
367 int border_horz, int border_vert, int highbd);
368void av1_decode_xq(const int *xqd, int *xq, const sgr_params_type *params);
369
403 void av1_loop_restoration_filter_unit(
404 const RestorationTileLimits *limits, const RestorationUnitInfo *rui,
405 const RestorationStripeBoundaries *rsb, RestorationLineBuffers *rlbs,
406 const PixelRect *tile_rect, int tile_stripe0, int ss_x, int ss_y,
407 int highbd, int bit_depth, uint8_t *data8, int stride, uint8_t *dst8,
408 int dst_stride, int32_t *tmpbuf, int optimized_lr);
409
423 void av1_loop_restoration_filter_frame(YV12_BUFFER_CONFIG *frame,
424 struct AV1Common *cm, int optimized_lr,
425 void *lr_ctxt);
428void av1_loop_restoration_precal();
429
430typedef void (*rest_tile_start_visitor_t)(int tile_row, int tile_col,
431 void *priv);
432struct AV1LrSyncData;
433
434typedef void (*sync_read_fn_t)(void *const lr_sync, int r, int c, int plane);
435
436typedef void (*sync_write_fn_t)(void *const lr_sync, int r, int c,
437 const int sb_cols, int plane);
438
439// Call on_rest_unit for each loop restoration unit in the plane.
440void av1_foreach_rest_unit_in_plane(const struct AV1Common *cm, int plane,
441 rest_unit_visitor_t on_rest_unit,
442 void *priv, PixelRect *tile_rect,
443 int32_t *tmpbuf,
444 RestorationLineBuffers *rlbs);
445
446// Return 1 iff the block at mi_row, mi_col with size bsize is a
447// top-level superblock containing the top-left corner of at least one
448// loop restoration unit.
449//
450// If the block is a top-level superblock, the function writes to
451// *rcol0, *rcol1, *rrow0, *rrow1. The rectangle of restoration unit
452// indices given by [*rcol0, *rcol1) x [*rrow0, *rrow1) are relative
453// to the current tile, whose starting index is returned as
454// *tile_tl_idx.
455int av1_loop_restoration_corners_in_sb(const struct AV1Common *cm, int plane,
456 int mi_row, int mi_col, BLOCK_SIZE bsize,
457 int *rcol0, int *rcol1, int *rrow0,
458 int *rrow1);
459
460void av1_loop_restoration_save_boundary_lines(const YV12_BUFFER_CONFIG *frame,
461 struct AV1Common *cm,
462 int after_cdef);
463void av1_loop_restoration_filter_frame_init(AV1LrStruct *lr_ctxt,
464 YV12_BUFFER_CONFIG *frame,
465 struct AV1Common *cm,
466 int optimized_lr, int num_planes);
467void av1_loop_restoration_copy_planes(AV1LrStruct *loop_rest_ctxt,
468 struct AV1Common *cm, int num_planes);
469void av1_foreach_rest_unit_in_row(
470 RestorationTileLimits *limits, const PixelRect *tile_rect,
471 rest_unit_visitor_t on_rest_unit, int row_number, int unit_size,
472 int unit_idx0, int hunits_per_tile, int vunits_per_tile, int plane,
473 void *priv, int32_t *tmpbuf, RestorationLineBuffers *rlbs,
474 sync_read_fn_t on_sync_read, sync_write_fn_t on_sync_write,
475 struct AV1LrSyncData *const lr_sync);
476PixelRect av1_whole_frame_rect(const struct AV1Common *cm, int is_uv);
477int av1_lr_count_units_in_tile(int unit_size, int tile_size);
478void av1_lr_sync_read_dummy(void *const lr_sync, int r, int c, int plane);
479void av1_lr_sync_write_dummy(void *const lr_sync, int r, int c,
480 const int sb_cols, int plane);
481
484#ifdef __cplusplus
485} // extern "C"
486#endif
487
488#endif // AOM_AV1_COMMON_RESTORATION_H_
enums.h
RestorationType
RestorationType
This enumeration defines various restoration types supported.
Definition: enums.h:603
av1_loop_restoration_filter_frame
void av1_loop_restoration_filter_frame(YV12_BUFFER_CONFIG *frame, struct AV1Common *cm, int optimized_lr, void *lr_ctxt)
Function for applying loop restoration filter to a frame.
av1_loop_restoration_filter_unit
void av1_loop_restoration_filter_unit(const RestorationTileLimits *limits, const RestorationUnitInfo *rui, const RestorationStripeBoundaries *rsb, RestorationLineBuffers *rlbs, const PixelRect *tile_rect, int tile_stripe0, int ss_x, int ss_y, int highbd, int bit_depth, uint8_t *data8, int stride, uint8_t *dst8, int dst_stride, int32_t *tmpbuf, int optimized_lr)
Function for applying loop restoration filter to a single unit.
AV1Common
Top level common structure used by both encoder and decoder.
Definition: av1_common_int.h:750
RestorationInfo
Parameters related to Restoration Info.
Definition: restoration.h:256
RestorationInfo::boundaries
RestorationStripeBoundaries boundaries
Definition: restoration.h:301
RestorationInfo::unit_info
RestorationUnitInfo * unit_info
Definition: restoration.h:296
RestorationInfo::vert_units_per_tile
int vert_units_per_tile
Definition: restoration.h:281
RestorationInfo::frame_restoration_type
RestorationType frame_restoration_type
Definition: restoration.h:260
RestorationInfo::optimized_lr
int optimized_lr
Definition: restoration.h:308
RestorationInfo::restoration_unit_size
int restoration_unit_size
Definition: restoration.h:265
RestorationInfo::horz_units_per_tile
int horz_units_per_tile
Definition: restoration.h:286
RestorationInfo::units_per_tile
int units_per_tile
Definition: restoration.h:276
RestorationStripeBoundaries
Parameters related to Restoration Stripe boundaries.
Definition: restoration.h:233
RestorationStripeBoundaries::stripe_boundary_stride
int stripe_boundary_stride
Definition: restoration.h:247
RestorationStripeBoundaries::stripe_boundary_size
int stripe_boundary_size
Definition: restoration.h:252
RestorationStripeBoundaries::stripe_boundary_above
uint8_t * stripe_boundary_above
Definition: restoration.h:237
RestorationStripeBoundaries::stripe_boundary_below
uint8_t * stripe_boundary_below
Definition: restoration.h:242
RestorationUnitInfo
Parameters related to Restoration Unit Info.
Definition: restoration.h:194
RestorationUnitInfo::wiener_info
WienerInfo wiener_info
Definition: restoration.h:203
RestorationUnitInfo::restoration_type
RestorationType restoration_type
Definition: restoration.h:198
RestorationUnitInfo::sgrproj_info
SgrprojInfo sgrproj_info
Definition: restoration.h:208
SgrprojInfo
Parameters related to Sgrproj Filter.
Definition: blockd.h:507
SgrprojInfo::xqd
int xqd[2]
Definition: blockd.h:516
WienerInfo
Parameters related to Wiener Filter.
Definition: blockd.h:494
WienerInfo::hfilter
InterpKernel hfilter
Definition: blockd.h:503
WienerInfo::vfilter
InterpKernel vfilter
Definition: blockd.h:498
yv12_buffer_config
YV12 frame buffer data structure.
Definition: yv12config.h:39