restoration.h (17111B)
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 22 extern "C" { 23 #endif 24 25 /*! @file */ 26 27 /*!\cond */ 28 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 stripe 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 tile size to be 91 // stored 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 typedef struct { 184 int r[2]; // radii 185 int s[2]; // sgr parameters for r[0] and r[1], based on GenSgrprojVtable() 186 } sgr_params_type; 187 /*!\endcond */ 188 189 /*!\brief Parameters related to Restoration Unit Info */ 190 typedef struct { 191 /*! 192 * restoration type 193 */ 194 RestorationType restoration_type; 195 196 /*! 197 * Wiener filter parameters if restoration_type indicates Wiener 198 */ 199 WienerInfo wiener_info; 200 201 /*! 202 * Sgrproj filter parameters if restoration_type indicates Sgrproj 203 */ 204 SgrprojInfo sgrproj_info; 205 } RestorationUnitInfo; 206 207 /*!\cond */ 208 209 // A restoration line buffer needs space for two lines plus a horizontal filter 210 // margin of RESTORATION_EXTRA_HORZ on each side. 211 #define RESTORATION_LINEBUFFER_WIDTH \ 212 (RESTORATION_UNITSIZE_MAX * 3 / 2 + 2 * RESTORATION_EXTRA_HORZ) 213 214 typedef struct { 215 // Temporary buffers to save/restore 3 lines above/below the restoration 216 // stripe. 217 uint16_t tmp_save_above[RESTORATION_BORDER][RESTORATION_LINEBUFFER_WIDTH]; 218 uint16_t tmp_save_below[RESTORATION_BORDER][RESTORATION_LINEBUFFER_WIDTH]; 219 } RestorationLineBuffers; 220 /*!\endcond */ 221 222 /*!\brief Parameters related to Restoration Stripe boundaries */ 223 typedef struct { 224 /*! 225 * stripe boundary above 226 */ 227 uint8_t *stripe_boundary_above; 228 229 /*! 230 * stripe boundary below 231 */ 232 uint8_t *stripe_boundary_below; 233 234 /*! 235 * strides for stripe boundaries above and below 236 */ 237 int stripe_boundary_stride; 238 239 /*! 240 * size of stripe boundaries above and below 241 */ 242 int stripe_boundary_size; 243 } RestorationStripeBoundaries; 244 245 /*!\brief Parameters related to Restoration Info */ 246 typedef struct { 247 /*! 248 * Restoration type for frame 249 */ 250 RestorationType frame_restoration_type; 251 252 /*! 253 * Restoration unit size 254 */ 255 int restoration_unit_size; 256 257 /** 258 * \name Fields allocated and initialised by av1_alloc_restoration_struct. 259 */ 260 /**@{*/ 261 /*! 262 * Total number of restoration units in this plane 263 */ 264 int num_rest_units; 265 266 /*! 267 * Number of vertical restoration units in this plane 268 */ 269 int vert_units; 270 271 /*! 272 * Number of horizontal restoration units in this plane 273 */ 274 int horz_units; 275 /**@}*/ 276 277 /*! 278 * Parameters for each restoration unit in this plane 279 */ 280 RestorationUnitInfo *unit_info; 281 282 /*! 283 * Restoration Stripe boundary info 284 */ 285 RestorationStripeBoundaries boundaries; 286 287 /*! 288 * Whether optimized lr can be used for speed. 289 * That includes cases of no cdef and no superres, or if fast trial runs 290 * are used on the encoder side. 291 */ 292 int optimized_lr; 293 } RestorationInfo; 294 295 /*!\cond */ 296 297 static inline void set_default_sgrproj(SgrprojInfo *sgrproj_info) { 298 sgrproj_info->xqd[0] = (SGRPROJ_PRJ_MIN0 + SGRPROJ_PRJ_MAX0) / 2; 299 sgrproj_info->xqd[1] = (SGRPROJ_PRJ_MIN1 + SGRPROJ_PRJ_MAX1) / 2; 300 } 301 302 static inline void set_default_wiener(WienerInfo *wiener_info) { 303 wiener_info->vfilter[0] = wiener_info->hfilter[0] = WIENER_FILT_TAP0_MIDV; 304 wiener_info->vfilter[1] = wiener_info->hfilter[1] = WIENER_FILT_TAP1_MIDV; 305 wiener_info->vfilter[2] = wiener_info->hfilter[2] = WIENER_FILT_TAP2_MIDV; 306 wiener_info->vfilter[WIENER_HALFWIN] = wiener_info->hfilter[WIENER_HALFWIN] = 307 -2 * 308 (WIENER_FILT_TAP2_MIDV + WIENER_FILT_TAP1_MIDV + WIENER_FILT_TAP0_MIDV); 309 wiener_info->vfilter[4] = wiener_info->hfilter[4] = WIENER_FILT_TAP2_MIDV; 310 wiener_info->vfilter[5] = wiener_info->hfilter[5] = WIENER_FILT_TAP1_MIDV; 311 wiener_info->vfilter[6] = wiener_info->hfilter[6] = WIENER_FILT_TAP0_MIDV; 312 } 313 314 typedef struct { 315 int h_start, h_end, v_start, v_end; 316 } RestorationTileLimits; 317 318 typedef void (*rest_unit_visitor_t)(const RestorationTileLimits *limits, 319 int rest_unit_idx, void *priv, 320 int32_t *tmpbuf, 321 RestorationLineBuffers *rlbs, 322 struct aom_internal_error_info *error_info); 323 324 typedef struct FilterFrameCtxt { 325 const RestorationInfo *rsi; 326 int ss_x, ss_y; 327 int plane_w, plane_h; 328 int highbd, bit_depth; 329 uint8_t *data8, *dst8; 330 int data_stride, dst_stride; 331 } FilterFrameCtxt; 332 333 typedef struct AV1LrStruct { 334 rest_unit_visitor_t on_rest_unit; 335 FilterFrameCtxt ctxt[MAX_MB_PLANE]; 336 YV12_BUFFER_CONFIG *frame; 337 YV12_BUFFER_CONFIG *dst; 338 } AV1LrStruct; 339 340 extern const sgr_params_type av1_sgr_params[SGRPROJ_PARAMS]; 341 extern int sgrproj_mtable[SGRPROJ_PARAMS][2]; 342 extern const int32_t av1_x_by_xplus1[256]; 343 extern const int32_t av1_one_by_x[MAX_NELEM]; 344 345 void av1_alloc_restoration_struct(struct AV1Common *cm, RestorationInfo *rsi, 346 int is_uv); 347 void av1_free_restoration_struct(RestorationInfo *rst_info); 348 349 void av1_extend_frame(uint8_t *data, int width, int height, int stride, 350 int border_horz, int border_vert, int highbd); 351 void av1_decode_xq(const int *xqd, int *xq, const sgr_params_type *params); 352 353 /*!\endcond */ 354 355 /*!\brief Function for applying loop restoration filter to a single unit. 356 * 357 * \ingroup in_loop_restoration 358 * This function applies the loop restoration filter to a single 359 * loop restoration unit. 360 * 361 * \param[in] limits Limits of the unit 362 * \param[in] rui The parameters to use for this unit and its 363 * coefficients 364 * \param[in] rsb Deblocked pixels to use for stripe boundaries 365 * \param[in] rlbs Space to use as a scratch buffer 366 * \param[in] ss_x Horizontal subsampling for plane 367 * \param[in] ss_y Vertical subsampling for plane 368 * \param[in] plane_w Width of the current plane 369 * \param[in] plane_h Height of the current plane 370 * \param[in] highbd Whether high bitdepth pipeline is used 371 * \param[in] bit_depth Bit-depth of the video 372 * \param[in] data8 Frame data (pointing at the top-left corner of 373 * the frame, not the restoration unit). 374 * \param[in] stride Stride of \c data8 375 * \param[out] dst8 Buffer where the results will be written. Like 376 * \c data8, \c dst8 should point at the top-left 377 * corner of the frame 378 * \param[in] dst_stride Stride of \c dst8 379 * \param[in] tmpbuf Scratch buffer used by the sgrproj filter 380 * which should be at least SGRPROJ_TMPBUF_SIZE 381 * big. 382 * \param[in] optimized_lr Whether to use fast optimized Loop Restoration 383 * \param[in,out] error_info Error info for reporting errors 384 * 385 * \remark Nothing is returned. Instead, the filtered unit is output in 386 * \c dst8 at the proper restoration unit offset. 387 */ 388 void av1_loop_restoration_filter_unit( 389 const RestorationTileLimits *limits, const RestorationUnitInfo *rui, 390 const RestorationStripeBoundaries *rsb, RestorationLineBuffers *rlbs, 391 int plane_w, int plane_h, int ss_x, int ss_y, int highbd, int bit_depth, 392 uint8_t *data8, int stride, uint8_t *dst8, int dst_stride, int32_t *tmpbuf, 393 int optimized_lr, struct aom_internal_error_info *error_info); 394 395 /*!\brief Function for applying loop restoration filter to a frame 396 * 397 * \ingroup in_loop_restoration 398 * This function applies the loop restoration filter to a frame. 399 * 400 * \param[in,out] frame Compressed frame buffer 401 * \param[in,out] cm Pointer to top level common structure 402 * \param[in] optimized_lr Whether to use fast optimized Loop Restoration 403 * \param[in] lr_ctxt Loop restoration context 404 * 405 * \remark Nothing is returned. Instead, the filtered frame is output in 406 * \c frame. 407 */ 408 void av1_loop_restoration_filter_frame(YV12_BUFFER_CONFIG *frame, 409 struct AV1Common *cm, int optimized_lr, 410 void *lr_ctxt); 411 /*!\cond */ 412 413 void av1_loop_restoration_precal(void); 414 415 struct AV1LrSyncData; 416 417 typedef void (*sync_read_fn_t)(void *const lr_sync, int r, int c, int plane); 418 419 typedef void (*sync_write_fn_t)(void *const lr_sync, int r, int c, 420 const int sb_cols, int plane); 421 422 // Return 1 iff the block at mi_row, mi_col with size bsize is a 423 // top-level superblock containing the top-left corner of at least one 424 // loop restoration unit. 425 // 426 // If the block is a top-level superblock, the function writes to 427 // *rcol0, *rcol1, *rrow0, *rrow1. This means that the parameters for all 428 // restoration units in the rectangle [*rcol0, *rcol1) x [*rrow0, *rrow1) 429 // are signaled in this superblock. 430 int av1_loop_restoration_corners_in_sb(const struct AV1Common *cm, int plane, 431 int mi_row, int mi_col, BLOCK_SIZE bsize, 432 int *rcol0, int *rcol1, int *rrow0, 433 int *rrow1); 434 435 void av1_loop_restoration_save_boundary_lines(const YV12_BUFFER_CONFIG *frame, 436 struct AV1Common *cm, 437 int after_cdef); 438 void av1_loop_restoration_filter_frame_init(AV1LrStruct *lr_ctxt, 439 YV12_BUFFER_CONFIG *frame, 440 struct AV1Common *cm, 441 int optimized_lr, int num_planes); 442 void av1_foreach_rest_unit_in_row( 443 RestorationTileLimits *limits, int plane_w, 444 rest_unit_visitor_t on_rest_unit, int row_number, int unit_size, 445 int hnum_rest_units, int vnum_rest_units, int plane, void *priv, 446 int32_t *tmpbuf, RestorationLineBuffers *rlbs, sync_read_fn_t on_sync_read, 447 sync_write_fn_t on_sync_write, struct AV1LrSyncData *const lr_sync, 448 struct aom_internal_error_info *error_info); 449 450 void av1_get_upsampled_plane_size(const struct AV1Common *cm, int is_uv, 451 int *plane_w, int *plane_h); 452 int av1_lr_count_units(int unit_size, int plane_size); 453 void av1_lr_sync_read_dummy(void *const lr_sync, int r, int c, int plane); 454 void av1_lr_sync_write_dummy(void *const lr_sync, int r, int c, 455 const int sb_cols, int plane); 456 457 /*!\endcond */ 458 459 #ifdef __cplusplus 460 } // extern "C" 461 #endif 462 463 #endif // AOM_AV1_COMMON_RESTORATION_H_