generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Adding VP9_FILTER_BITS constant.

Browse Source 
Removing VP9_FILTER_WEIGHT, VP9_FILTER_SHIFT, BLOCK_WIDTH_HEIGHT
constants. Using ROUND_POWER_OF_TWO for rounding.

Change-Id: I2e8d6858dcd600a87096138209731137d7decc24
This commit is contained in:
Dmitry Kovalev 2013-08-20 00:42:25 -07:00
parent c4048dbdd3
commit 2612b99cc7
4 changed files with 35 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
vp9/common/vp9_convolve.c
View File

@ -17,9 +17,6 @@
#include "vpx/vpx_integer.h"
#include "vpx_ports/mem.h"
#define VP9_FILTER_WEIGHT 128
#define VP9_FILTER_SHIFT 7
/* Assume a bank of 16 filters to choose from. There are two implementations
* for filter wrapping behavior, since we want to be able to pick which filter
* to start with. We could either:
@ -43,7 +40,7 @@ static void convolve_horiz_c(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_x0, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int taps) {
int x, y, k, sum;
int x, y, k;
const int16_t *filter_x_base = filter_x0;
#if ALIGN_FILTERS_256
@ -64,12 +61,12 @@ static void convolve_horiz_c(const uint8_t *src, ptrdiff_t src_stride,
for (x = 0; x < w; ++x) {
/* Per-pixel src offset */
int src_x = (x_q4 - x0_q4) >> 4;
int sum = 0;
for (sum = 0, k = 0; k < taps; ++k) {
for (k = 0; k < taps; ++k)
sum += src[src_x + k] * filter_x[k];
}
sum += (VP9_FILTER_WEIGHT >> 1);
dst[x] = clip_pixel(sum >> VP9_FILTER_SHIFT);
dst[x] = clip_pixel(ROUND_POWER_OF_TWO(sum, VP9_FILTER_BITS));
/* Adjust source and filter to use for the next pixel */
x_q4 += x_step_q4;
@ -85,7 +82,7 @@ static void convolve_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_x0, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int taps) {
int x, y, k, sum;
int x, y, k;
const int16_t *filter_x_base = filter_x0;
#if ALIGN_FILTERS_256
@ -106,12 +103,13 @@ static void convolve_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride,
for (x = 0; x < w; ++x) {
/* Per-pixel src offset */
int src_x = (x_q4 - x0_q4) >> 4;
int sum = 0;
for (sum = 0, k = 0; k < taps; ++k) {
for (k = 0; k < taps; ++k)
sum += src[src_x + k] * filter_x[k];
}
sum += (VP9_FILTER_WEIGHT >> 1);
dst[x] = (dst[x] + clip_pixel(sum >> VP9_FILTER_SHIFT) + 1) >> 1;
dst[x] = ROUND_POWER_OF_TWO(dst[x] +
clip_pixel(ROUND_POWER_OF_TWO(sum, VP9_FILTER_BITS)), 1);
/* Adjust source and filter to use for the next pixel */
x_q4 += x_step_q4;
@ -127,7 +125,7 @@ static void convolve_vert_c(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y0, int y_step_q4,
int w, int h, int taps) {
int x, y, k, sum;
int x, y, k;
const int16_t *filter_y_base = filter_y0;
@ -148,12 +146,13 @@ static void convolve_vert_c(const uint8_t *src, ptrdiff_t src_stride,
for (y = 0; y < h; ++y) {
/* Per-pixel src offset */
int src_y = (y_q4 - y0_q4) >> 4;
int sum = 0;
for (sum = 0, k = 0; k < taps; ++k) {
for (k = 0; k < taps; ++k)
sum += src[(src_y + k) * src_stride] * filter_y[k];
}
sum += (VP9_FILTER_WEIGHT >> 1);
dst[y * dst_stride] = clip_pixel(sum >> VP9_FILTER_SHIFT);
dst[y * dst_stride] =
clip_pixel(ROUND_POWER_OF_TWO(sum, VP9_FILTER_BITS));
/* Adjust source and filter to use for the next pixel */
y_q4 += y_step_q4;
@ -169,7 +168,7 @@ static void convolve_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y0, int y_step_q4,
int w, int h, int taps) {
int x, y, k, sum;
int x, y, k;
const int16_t *filter_y_base = filter_y0;
@ -190,13 +189,13 @@ static void convolve_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride,
for (y = 0; y < h; ++y) {
/* Per-pixel src offset */
int src_y = (y_q4 - y0_q4) >> 4;
int sum = 0;
for (sum = 0, k = 0; k < taps; ++k) {
for (k = 0; k < taps; ++k)
sum += src[(src_y + k) * src_stride] * filter_y[k];
}
sum += (VP9_FILTER_WEIGHT >> 1);
dst[y * dst_stride] =
(dst[y * dst_stride] + clip_pixel(sum >> VP9_FILTER_SHIFT) + 1) >> 1;
dst[y * dst_stride] = ROUND_POWER_OF_TWO(dst[y * dst_stride] +
clip_pixel(ROUND_POWER_OF_TWO(sum, VP9_FILTER_BITS)), 1);
/* Adjust source and filter to use for the next pixel */
y_q4 += y_step_q4;

2
vp9/common/vp9_convolve.h
View File

@ -13,6 +13,8 @@
#include "./vpx_config.h"
#include "vpx/vpx_integer.h"
#define VP9_FILTER_BITS 7
typedef void (*convolve_fn_t)(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,

5
vp9/common/vp9_filter.h
View File

@ -12,13 +12,8 @@
#define VP9_COMMON_VP9_FILTER_H_
#include "vpx_config.h"
#include "vpx_scale/yv12config.h"
#include "vpx/vpx_integer.h"
#define BLOCK_HEIGHT_WIDTH 4
#define VP9_FILTER_WEIGHT 128
#define VP9_FILTER_SHIFT 7
#define SUBPEL_BITS 4
#define SUBPEL_MASK ((1 << SUBPEL_BITS) - 1)
#define SUBPEL_SHIFTS (1 << SUBPEL_BITS)

23
vp9/common/vp9_subpelvar.h
View File

@ -11,7 +11,8 @@
#ifndef VP9_COMMON_VP9_SUBPELVAR_H_
#define VP9_COMMON_VP9_SUBPELVAR_H_
#include "vp9/common/vp9_filter.h"
#include "vp9/common/vp9_common.h"
#include "vp9/common/vp9_convolve.h"
static void variance(const uint8_t *src_ptr,
int source_stride,
@ -78,10 +79,10 @@ static void var_filter_block2d_bil_first_pass(const uint8_t *src_ptr,
for (i = 0; i < output_height; i++) {
for (j = 0; j < output_width; j++) {
// Apply bilinear filter
output_ptr[j] = (((int)src_ptr[0] * vp9_filter[0]) +
((int)src_ptr[pixel_step] * vp9_filter[1]) +
(VP9_FILTER_WEIGHT / 2)) >> VP9_FILTER_SHIFT;
output_ptr[j] = ROUND_POWER_OF_TWO((int)src_ptr[0] * vp9_filter[0] +
(int)src_ptr[pixel_step] * vp9_filter[1],
VP9_FILTER_BITS);
src_ptr++;
}
@ -127,20 +128,16 @@ static void var_filter_block2d_bil_second_pass(const uint16_t *src_ptr,
unsigned int output_width,
const int16_t *vp9_filter) {
unsigned int i, j;
int Temp;
for (i = 0; i < output_height; i++) {
for (j = 0; j < output_width; j++) {
// Apply filter
Temp = ((int)src_ptr[0] * vp9_filter[0]) +
((int)src_ptr[pixel_step] * vp9_filter[1]) +
(VP9_FILTER_WEIGHT / 2);
output_ptr[j] = (unsigned int)(Temp >> VP9_FILTER_SHIFT);
output_ptr[j] = ROUND_POWER_OF_TWO((int)src_ptr[0] * vp9_filter[0] +
(int)src_ptr[pixel_step] * vp9_filter[1],
VP9_FILTER_BITS);
src_ptr++;
}
// Next row...
src_ptr += src_pixels_per_line - output_width;
src_ptr += src_pixels_per_line - output_width;
output_ptr += output_width;
}
}