OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright (c) 2012 The WebM project authors. All Rights Reserved. |
| 3 * |
| 4 * Use of this source code is governed by a BSD-style license |
| 5 * that can be found in the LICENSE file in the root of the source |
| 6 * 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. |
| 9 */ |
| 10 |
| 11 #include <assert.h> |
| 12 #include "vpx_scale/yv12config.h" |
| 13 #include "vpx/vpx_integer.h" |
| 14 #include "vp9/encoder/vp9_denoiser.h" |
| 15 |
| 16 static const int widths[] = {4, 4, 8, 8, 8, 16, 16, 16, 32, 32, 32, 64, 64}; |
| 17 static const int heights[] = {4, 8, 4, 8, 16, 8, 16, 32, 16, 32, 64, 32, 64}; |
| 18 |
| 19 int vp9_denoiser_filter() { |
| 20 return 0; |
| 21 } |
| 22 |
| 23 static int update_running_avg(const uint8_t *mc_avg, int mc_avg_stride, |
| 24 uint8_t *avg, int avg_stride, |
| 25 const uint8_t *sig, int sig_stride, |
| 26 int increase_denoising, BLOCK_SIZE bs) { |
| 27 int r, c; |
| 28 int diff, adj, absdiff; |
| 29 int shift_inc1 = 0, shift_inc2 = 1; |
| 30 int adj_val[] = {3, 4, 6}; |
| 31 int total_adj = 0; |
| 32 |
| 33 if (increase_denoising) { |
| 34 shift_inc1 = 1; |
| 35 shift_inc2 = 2; |
| 36 } |
| 37 |
| 38 for (r = 0; r < heights[bs]; ++r) { |
| 39 for (c = 0; c < widths[bs]; ++c) { |
| 40 diff = mc_avg[c] - sig[c]; |
| 41 absdiff = abs(diff); |
| 42 |
| 43 if (absdiff <= 3 + shift_inc1) { |
| 44 avg[c] = mc_avg[c]; |
| 45 total_adj += diff; |
| 46 } else { |
| 47 switch (absdiff) { |
| 48 case 4: case 5: case 6: case 7: |
| 49 adj = adj_val[0]; |
| 50 break; |
| 51 case 8: case 9: case 10: case 11: |
| 52 case 12: case 13: case 14: case 15: |
| 53 adj = adj_val[1]; |
| 54 break; |
| 55 default: |
| 56 adj = adj_val[2]; |
| 57 } |
| 58 if (diff > 0) { |
| 59 avg[c] = MIN(UINT8_MAX, sig[c] + adj); |
| 60 total_adj += adj; |
| 61 } else { |
| 62 avg[c] = MAX(0, sig[c] - adj); |
| 63 total_adj -= adj; |
| 64 } |
| 65 } |
| 66 } |
| 67 sig += sig_stride; |
| 68 avg += avg_stride; |
| 69 mc_avg += mc_avg_stride; |
| 70 } |
| 71 return total_adj; |
| 72 } |
| 73 |
| 74 static uint8_t *block_start(uint8_t *framebuf, int stride, |
| 75 int mi_row, int mi_col) { |
| 76 return framebuf + (stride * mi_row * 8) + (mi_col * 8); |
| 77 } |
| 78 |
| 79 void copy_block(uint8_t *dest, int dest_stride, |
| 80 uint8_t *src, int src_stride, BLOCK_SIZE bs) { |
| 81 int r, c; |
| 82 for (r = 0; r < heights[bs]; ++r) { |
| 83 for (c = 0; c < widths[bs]; ++c) { |
| 84 dest[c] = src[c]; |
| 85 } |
| 86 dest += dest_stride; |
| 87 src += src_stride; |
| 88 } |
| 89 } |
| 90 |
| 91 void vp9_denoiser_denoise(VP9_DENOISER *denoiser, MACROBLOCK *mb, |
| 92 int mi_row, int mi_col, BLOCK_SIZE bs) { |
| 93 int decision = COPY_BLOCK; |
| 94 |
| 95 YV12_BUFFER_CONFIG avg = denoiser->running_avg_y[INTRA_FRAME]; |
| 96 struct buf_2d src = mb->plane[0].src; |
| 97 |
| 98 update_running_avg(denoiser->mc_running_avg_y.y_buffer, |
| 99 denoiser->mc_running_avg_y.y_stride, |
| 100 denoiser->running_avg_y[INTRA_FRAME].y_buffer, |
| 101 denoiser->running_avg_y[INTRA_FRAME].y_stride, |
| 102 mb->plane[0].src.buf, mb->plane[0].src.stride, 0, bs); |
| 103 |
| 104 if (decision == FILTER_BLOCK) { |
| 105 // TODO(tkopp) |
| 106 } |
| 107 if (decision == COPY_BLOCK) { |
| 108 copy_block(block_start(avg.y_buffer, avg.y_stride, mi_row, mi_col), |
| 109 avg.y_stride, src.buf, src.stride, bs); |
| 110 } |
| 111 } |
| 112 |
| 113 static void copy_frame(YV12_BUFFER_CONFIG dest, const YV12_BUFFER_CONFIG src) { |
| 114 int r, c; |
| 115 const uint8_t *srcbuf = src.y_buffer; |
| 116 uint8_t *destbuf = dest.y_buffer; |
| 117 assert(dest.y_width == src.y_width); |
| 118 assert(dest.y_height == src.y_height); |
| 119 |
| 120 for (r = 0; r < dest.y_height; ++r) { |
| 121 for (c = 0; c < dest.y_width; ++c) { |
| 122 destbuf[c] = srcbuf[c]; |
| 123 } |
| 124 destbuf += dest.y_stride; |
| 125 srcbuf += src.y_stride; |
| 126 } |
| 127 } |
| 128 |
| 129 void vp9_denoiser_update_frame_info(VP9_DENOISER *denoiser, |
| 130 YV12_BUFFER_CONFIG src, |
| 131 FRAME_TYPE frame_type, |
| 132 int refresh_alt_ref_frame, |
| 133 int refresh_golden_frame, |
| 134 int refresh_last_frame) { |
| 135 if (frame_type == KEY_FRAME) { |
| 136 int i; |
| 137 copy_frame(denoiser->running_avg_y[LAST_FRAME], src); |
| 138 for (i = 2; i < MAX_REF_FRAMES - 1; i++) { |
| 139 copy_frame(denoiser->running_avg_y[i], |
| 140 denoiser->running_avg_y[LAST_FRAME]); |
| 141 } |
| 142 } else { /* For non key frames */ |
| 143 if (refresh_alt_ref_frame) { |
| 144 copy_frame(denoiser->running_avg_y[ALTREF_FRAME], |
| 145 denoiser->running_avg_y[INTRA_FRAME]); |
| 146 } |
| 147 if (refresh_golden_frame) { |
| 148 copy_frame(denoiser->running_avg_y[GOLDEN_FRAME], |
| 149 denoiser->running_avg_y[INTRA_FRAME]); |
| 150 } |
| 151 if (refresh_last_frame) { |
| 152 copy_frame(denoiser->running_avg_y[LAST_FRAME], |
| 153 denoiser->running_avg_y[INTRA_FRAME]); |
| 154 } |
| 155 } |
| 156 } |
| 157 |
| 158 void vp9_denoiser_update_frame_stats() { |
| 159 } |
| 160 |
| 161 int vp9_denoiser_alloc(VP9_DENOISER *denoiser, int width, int height, |
| 162 int ssx, int ssy, int border) { |
| 163 int i, fail; |
| 164 assert(denoiser != NULL); |
| 165 |
| 166 for (i = 0; i < MAX_REF_FRAMES; ++i) { |
| 167 fail = vp9_alloc_frame_buffer(&denoiser->running_avg_y[i], width, height, |
| 168 ssx, ssy, border); |
| 169 if (fail) { |
| 170 vp9_denoiser_free(denoiser); |
| 171 return 1; |
| 172 } |
| 173 } |
| 174 |
| 175 fail = vp9_alloc_frame_buffer(&denoiser->mc_running_avg_y, width, height, |
| 176 ssx, ssy, border); |
| 177 if (fail) { |
| 178 vp9_denoiser_free(denoiser); |
| 179 return 1; |
| 180 } |
| 181 |
| 182 return 0; |
| 183 } |
| 184 |
| 185 void vp9_denoiser_free(VP9_DENOISER *denoiser) { |
| 186 int i; |
| 187 if (denoiser == NULL) { |
| 188 return; |
| 189 } |
| 190 for (i = 0; i < MAX_REF_FRAMES; ++i) { |
| 191 if (&denoiser->running_avg_y[i] != NULL) { |
| 192 vp9_free_frame_buffer(&denoiser->running_avg_y[i]); |
| 193 } |
| 194 } |
| 195 if (&denoiser->mc_running_avg_y != NULL) { |
| 196 vp9_free_frame_buffer(&denoiser->mc_running_avg_y); |
| 197 } |
| 198 } |
OLD | NEW |