64075c9b01
The denoiser function was modified to reduce the computational
complexity.
1. The denoiser c function modification:
The original implementation calculated pixel's filter_coefficient
based on the pixel value difference between current raw frame and last
denoised raw frame, and stored them in lookup tables. For each pixel c,
find its coefficient using
filter_coefficient[c] = LUT[abs_diff[c]];
and then apply filtering operation for the pixel.
The denoising filter costed about 12% of encoding time when it was
turned on, and half of the time was spent on finding coefficients in
lookup tables. In order to simplify the process, a short cut was taken.
The pixel adjustments vs. pixel diff value were calculated ahead of time.
adjustment = filtered_value - current_raw
= (filter_coefficient * diff + 128) >> 8
The adjustment vs. diff curve becomes flat very quick when diff increases.
This allowed us to use only several levels to get a close approximation
of the curve. Following the denoiser algorithm, the adjustments are
further modified according to how big the motion magnitude is.
2. The sse2 function was rewritten.
This change made denoiser filter function 3x faster, and improved the
encoder performance by 7% ~ 10% with the denoiser on.
Change-Id: I93a4308963b8e80c7307f96ffa8b8c667425bf50
120 lines
4.7 KiB
C
120 lines
4.7 KiB
C
/*
|
|
* Copyright (c) 2012 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 "vp8/encoder/denoising.h"
|
|
#include "vp8/common/reconinter.h"
|
|
#include "vpx/vpx_integer.h"
|
|
#include "vpx_mem/vpx_mem.h"
|
|
#include "vpx_rtcd.h"
|
|
|
|
#include <emmintrin.h>
|
|
|
|
union sum_union {
|
|
__m128i v;
|
|
signed char e[16];
|
|
};
|
|
|
|
int vp8_denoiser_filter_sse2(YV12_BUFFER_CONFIG *mc_running_avg,
|
|
YV12_BUFFER_CONFIG *running_avg,
|
|
MACROBLOCK *signal, unsigned int motion_magnitude,
|
|
int y_offset, int uv_offset)
|
|
{
|
|
unsigned char *sig = signal->thismb;
|
|
int sig_stride = 16;
|
|
unsigned char *mc_running_avg_y = mc_running_avg->y_buffer + y_offset;
|
|
int mc_avg_y_stride = mc_running_avg->y_stride;
|
|
unsigned char *running_avg_y = running_avg->y_buffer + y_offset;
|
|
int avg_y_stride = running_avg->y_stride;
|
|
int r;
|
|
__m128i acc_diff = _mm_setzero_si128();
|
|
const __m128i k_0 = _mm_setzero_si128();
|
|
const __m128i k_4 = _mm_set1_epi8(4);
|
|
const __m128i k_8 = _mm_set1_epi8(8);
|
|
const __m128i k_16 = _mm_set1_epi8(16);
|
|
/* Modify each level's adjustment according to motion_magnitude. */
|
|
const __m128i l3 = _mm_set1_epi8(
|
|
(motion_magnitude <= MOTION_MAGNITUDE_THRESHOLD) ? 7 : 6);
|
|
/* Difference between level 3 and level 2 is 2. */
|
|
const __m128i l32 = _mm_set1_epi8(2);
|
|
/* Difference between level 2 and level 1 is 1. */
|
|
const __m128i l21 = _mm_set1_epi8(1);
|
|
|
|
for (r = 0; r < 16; ++r)
|
|
{
|
|
/* Calculate differences */
|
|
const __m128i v_sig = _mm_loadu_si128((__m128i *)(&sig[0]));
|
|
const __m128i v_mc_running_avg_y = _mm_loadu_si128(
|
|
(__m128i *)(&mc_running_avg_y[0]));
|
|
__m128i v_running_avg_y;
|
|
const __m128i pdiff = _mm_subs_epu8(v_mc_running_avg_y, v_sig);
|
|
const __m128i ndiff = _mm_subs_epu8(v_sig, v_mc_running_avg_y);
|
|
/* Obtain the sign. FF if diff is negative. */
|
|
const __m128i diff_sign = _mm_cmpeq_epi8(pdiff, k_0);
|
|
/* Clamp absolute difference to 16 to be used to get mask. Doing this
|
|
* allows us to use _mm_cmpgt_epi8, which operates on signed byte. */
|
|
const __m128i clamped_absdiff = _mm_min_epu8(
|
|
_mm_or_si128(pdiff, ndiff), k_16);
|
|
/* Get masks for l2 l1 and l0 adjustments */
|
|
const __m128i mask2 = _mm_cmpgt_epi8(k_16, clamped_absdiff);
|
|
const __m128i mask1 = _mm_cmpgt_epi8(k_8, clamped_absdiff);
|
|
const __m128i mask0 = _mm_cmpgt_epi8(k_4, clamped_absdiff);
|
|
/* Get adjustments for l2, l1, and l0 */
|
|
__m128i adj2 = _mm_and_si128(mask2, l32);
|
|
const __m128i adj1 = _mm_and_si128(mask1, l21);
|
|
const __m128i adj0 = _mm_and_si128(mask0, clamped_absdiff);
|
|
__m128i adj, padj, nadj;
|
|
|
|
/* Combine the adjustments and get absolute adjustments. */
|
|
adj2 = _mm_add_epi8(adj2, adj1);
|
|
adj = _mm_sub_epi8(l3, adj2);
|
|
adj = _mm_andnot_si128(mask0, adj);
|
|
adj = _mm_or_si128(adj, adj0);
|
|
|
|
/* Restore the sign and get positive and negative adjustments. */
|
|
padj = _mm_andnot_si128(diff_sign, adj);
|
|
nadj = _mm_and_si128(diff_sign, adj);
|
|
|
|
/* Calculate filtered value. */
|
|
v_running_avg_y = _mm_adds_epu8(v_sig, padj);
|
|
v_running_avg_y = _mm_subs_epu8(v_running_avg_y, nadj);
|
|
_mm_storeu_si128((__m128i *)running_avg_y, v_running_avg_y);
|
|
|
|
/* Adjustments <=7, and each element in acc_diff can fit in signed
|
|
* char.
|
|
*/
|
|
acc_diff = _mm_adds_epi8(acc_diff, padj);
|
|
acc_diff = _mm_subs_epi8(acc_diff, nadj);
|
|
|
|
/* Update pointers for next iteration. */
|
|
sig += sig_stride;
|
|
mc_running_avg_y += mc_avg_y_stride;
|
|
running_avg_y += avg_y_stride;
|
|
}
|
|
|
|
{
|
|
/* Compute the sum of all pixel differences of this MB. */
|
|
union sum_union s;
|
|
int sum_diff = 0;
|
|
s.v = acc_diff;
|
|
sum_diff = s.e[0] + s.e[1] + s.e[2] + s.e[3] + s.e[4] + s.e[5]
|
|
+ s.e[6] + s.e[7] + s.e[8] + s.e[9] + s.e[10] + s.e[11]
|
|
+ s.e[12] + s.e[13] + s.e[14] + s.e[15];
|
|
|
|
if (abs(sum_diff) > SUM_DIFF_THRESHOLD)
|
|
{
|
|
return COPY_BLOCK;
|
|
}
|
|
}
|
|
|
|
vp8_copy_mem16x16(running_avg->y_buffer + y_offset, avg_y_stride,
|
|
signal->thismb, sig_stride);
|
|
return FILTER_BLOCK;
|
|
}
|