cc9c637d07
Previously, in evaluating reference motion vectors, MVs are always rounded to integer pixel position and SADs are calculated. This commit takes into account the subpixel portion of the mvs, and uses bilinear interpolation to produce reference pixel values in subpixel postions. In addition, SSE is used in place of SAD. Pixels used are 16x2 above and 2x16 to the left. This commmit intends to test the potential of this line of work in term of compression improvement, obviously, the change would increase decoder complexity significantly. Test results std-hd: 1.738%(avg) 1.779%(glb), 1.663%(ssim) derf: 0.472%(avg) 0.477%(glb), 0.418%(ssim) Change-Id: I3ae1b098f6289df78891134d9a5e4bb2fde87a0b
588 lines
18 KiB
C
588 lines
18 KiB
C
/*
|
|
* Copyright (c) 2010 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 "variance.h"
|
|
#include "vp8/common/filter.h"
|
|
|
|
|
|
unsigned int vp8_get_mb_ss_c
|
|
(
|
|
const short *src_ptr
|
|
) {
|
|
unsigned int i = 0, sum = 0;
|
|
|
|
do {
|
|
sum += (src_ptr[i] * src_ptr[i]);
|
|
i++;
|
|
} while (i < 256);
|
|
|
|
return sum;
|
|
}
|
|
|
|
|
|
static void variance(
|
|
const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
int w,
|
|
int h,
|
|
unsigned int *sse,
|
|
int *sum) {
|
|
int i, j;
|
|
int diff;
|
|
|
|
*sum = 0;
|
|
*sse = 0;
|
|
|
|
for (i = 0; i < h; i++) {
|
|
for (j = 0; j < w; j++) {
|
|
diff = src_ptr[j] - ref_ptr[j];
|
|
*sum += diff;
|
|
*sse += diff * diff;
|
|
}
|
|
|
|
src_ptr += source_stride;
|
|
ref_ptr += recon_stride;
|
|
}
|
|
}
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
unsigned int vp8_variance32x32_c(const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
unsigned int var;
|
|
int avg;
|
|
|
|
variance(src_ptr, source_stride, ref_ptr, recon_stride, 32, 32, &var, &avg);
|
|
*sse = var;
|
|
return (var - ((avg * avg) >> 10));
|
|
}
|
|
#endif
|
|
|
|
unsigned int vp8_variance16x16_c(
|
|
const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
unsigned int var;
|
|
int avg;
|
|
|
|
|
|
variance(src_ptr, source_stride, ref_ptr, recon_stride, 16, 16, &var, &avg);
|
|
*sse = var;
|
|
return (var - ((avg * avg) >> 8));
|
|
}
|
|
|
|
unsigned int vp8_variance8x16_c(
|
|
const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
unsigned int var;
|
|
int avg;
|
|
|
|
|
|
variance(src_ptr, source_stride, ref_ptr, recon_stride, 8, 16, &var, &avg);
|
|
*sse = var;
|
|
return (var - ((avg * avg) >> 7));
|
|
}
|
|
|
|
unsigned int vp8_variance16x8_c(
|
|
const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
unsigned int var;
|
|
int avg;
|
|
|
|
|
|
variance(src_ptr, source_stride, ref_ptr, recon_stride, 16, 8, &var, &avg);
|
|
*sse = var;
|
|
return (var - ((avg * avg) >> 7));
|
|
}
|
|
|
|
|
|
unsigned int vp8_variance8x8_c(
|
|
const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
unsigned int var;
|
|
int avg;
|
|
|
|
|
|
variance(src_ptr, source_stride, ref_ptr, recon_stride, 8, 8, &var, &avg);
|
|
*sse = var;
|
|
return (var - ((avg * avg) >> 6));
|
|
}
|
|
|
|
unsigned int vp8_variance4x4_c(
|
|
const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
unsigned int var;
|
|
int avg;
|
|
|
|
|
|
variance(src_ptr, source_stride, ref_ptr, recon_stride, 4, 4, &var, &avg);
|
|
*sse = var;
|
|
return (var - ((avg * avg) >> 4));
|
|
}
|
|
|
|
|
|
unsigned int vp8_mse16x16_c(
|
|
const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
unsigned int var;
|
|
int avg;
|
|
|
|
variance(src_ptr, source_stride, ref_ptr, recon_stride, 16, 16, &var, &avg);
|
|
*sse = var;
|
|
return var;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* ROUTINE : filter_block2d_bil_first_pass
|
|
*
|
|
* INPUTS : UINT8 *src_ptr : Pointer to source block.
|
|
* UINT32 src_pixels_per_line : Stride of input block.
|
|
* UINT32 pixel_step : Offset between filter input samples (see notes).
|
|
* UINT32 output_height : Input block height.
|
|
* UINT32 output_width : Input block width.
|
|
* INT32 *vp8_filter : Array of 2 bi-linear filter taps.
|
|
*
|
|
* OUTPUTS : INT32 *output_ptr : Pointer to filtered block.
|
|
*
|
|
* RETURNS : void
|
|
*
|
|
* FUNCTION : Applies a 1-D 2-tap bi-linear filter to the source block in
|
|
* either horizontal or vertical direction to produce the
|
|
* filtered output block. Used to implement first-pass
|
|
* of 2-D separable filter.
|
|
*
|
|
* SPECIAL NOTES : Produces INT32 output to retain precision for next pass.
|
|
* Two filter taps should sum to VP8_FILTER_WEIGHT.
|
|
* pixel_step defines whether the filter is applied
|
|
* horizontally (pixel_step=1) or vertically (pixel_step=stride).
|
|
* It defines the offset required to move from one input
|
|
* to the next.
|
|
*
|
|
****************************************************************************/
|
|
static void var_filter_block2d_bil_first_pass
|
|
(
|
|
const unsigned char *src_ptr,
|
|
unsigned short *output_ptr,
|
|
unsigned int src_pixels_per_line,
|
|
int pixel_step,
|
|
unsigned int output_height,
|
|
unsigned int output_width,
|
|
const short *vp8_filter
|
|
) {
|
|
unsigned int i, j;
|
|
|
|
for (i = 0; i < output_height; i++) {
|
|
for (j = 0; j < output_width; j++) {
|
|
// Apply bilinear filter
|
|
output_ptr[j] = (((int)src_ptr[0] * vp8_filter[0]) +
|
|
((int)src_ptr[pixel_step] * vp8_filter[1]) +
|
|
(VP8_FILTER_WEIGHT / 2)) >> VP8_FILTER_SHIFT;
|
|
src_ptr++;
|
|
}
|
|
|
|
// Next row...
|
|
src_ptr += src_pixels_per_line - output_width;
|
|
output_ptr += output_width;
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* ROUTINE : filter_block2d_bil_second_pass
|
|
*
|
|
* INPUTS : INT32 *src_ptr : Pointer to source block.
|
|
* UINT32 src_pixels_per_line : Stride of input block.
|
|
* UINT32 pixel_step : Offset between filter input samples (see notes).
|
|
* UINT32 output_height : Input block height.
|
|
* UINT32 output_width : Input block width.
|
|
* INT32 *vp8_filter : Array of 2 bi-linear filter taps.
|
|
*
|
|
* OUTPUTS : UINT16 *output_ptr : Pointer to filtered block.
|
|
*
|
|
* RETURNS : void
|
|
*
|
|
* FUNCTION : Applies a 1-D 2-tap bi-linear filter to the source block in
|
|
* either horizontal or vertical direction to produce the
|
|
* filtered output block. Used to implement second-pass
|
|
* of 2-D separable filter.
|
|
*
|
|
* SPECIAL NOTES : Requires 32-bit input as produced by filter_block2d_bil_first_pass.
|
|
* Two filter taps should sum to VP8_FILTER_WEIGHT.
|
|
* pixel_step defines whether the filter is applied
|
|
* horizontally (pixel_step=1) or vertically (pixel_step=stride).
|
|
* It defines the offset required to move from one input
|
|
* to the next.
|
|
*
|
|
****************************************************************************/
|
|
static void var_filter_block2d_bil_second_pass
|
|
(
|
|
const unsigned short *src_ptr,
|
|
unsigned char *output_ptr,
|
|
unsigned int src_pixels_per_line,
|
|
unsigned int pixel_step,
|
|
unsigned int output_height,
|
|
unsigned int output_width,
|
|
const short *vp8_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] * vp8_filter[0]) +
|
|
((int)src_ptr[pixel_step] * vp8_filter[1]) +
|
|
(VP8_FILTER_WEIGHT / 2);
|
|
output_ptr[j] = (unsigned int)(Temp >> VP8_FILTER_SHIFT);
|
|
src_ptr++;
|
|
}
|
|
|
|
// Next row...
|
|
src_ptr += src_pixels_per_line - output_width;
|
|
output_ptr += output_width;
|
|
}
|
|
}
|
|
|
|
|
|
unsigned int vp8_sub_pixel_variance4x4_c
|
|
(
|
|
const unsigned char *src_ptr,
|
|
int src_pixels_per_line,
|
|
int xoffset,
|
|
int yoffset,
|
|
const unsigned char *dst_ptr,
|
|
int dst_pixels_per_line,
|
|
unsigned int *sse
|
|
) {
|
|
unsigned char temp2[20 * 16];
|
|
const short *HFilter, *VFilter;
|
|
unsigned short FData3[5 * 4]; // Temp data bufffer used in filtering
|
|
|
|
HFilter = vp8_bilinear_filters[xoffset];
|
|
VFilter = vp8_bilinear_filters[yoffset];
|
|
|
|
// First filter 1d Horizontal
|
|
var_filter_block2d_bil_first_pass(src_ptr, FData3, src_pixels_per_line, 1, 5, 4, HFilter);
|
|
|
|
// Now filter Verticaly
|
|
var_filter_block2d_bil_second_pass(FData3, temp2, 4, 4, 4, 4, VFilter);
|
|
|
|
return vp8_variance4x4_c(temp2, 4, dst_ptr, dst_pixels_per_line, sse);
|
|
}
|
|
|
|
|
|
unsigned int vp8_sub_pixel_variance8x8_c
|
|
(
|
|
const unsigned char *src_ptr,
|
|
int src_pixels_per_line,
|
|
int xoffset,
|
|
int yoffset,
|
|
const unsigned char *dst_ptr,
|
|
int dst_pixels_per_line,
|
|
unsigned int *sse
|
|
) {
|
|
unsigned short FData3[9 * 8]; // Temp data bufffer used in filtering
|
|
unsigned char temp2[20 * 16];
|
|
const short *HFilter, *VFilter;
|
|
|
|
HFilter = vp8_bilinear_filters[xoffset];
|
|
VFilter = vp8_bilinear_filters[yoffset];
|
|
|
|
var_filter_block2d_bil_first_pass(src_ptr, FData3, src_pixels_per_line, 1, 9, 8, HFilter);
|
|
var_filter_block2d_bil_second_pass(FData3, temp2, 8, 8, 8, 8, VFilter);
|
|
|
|
return vp8_variance8x8_c(temp2, 8, dst_ptr, dst_pixels_per_line, sse);
|
|
}
|
|
|
|
unsigned int vp8_sub_pixel_variance16x16_c
|
|
(
|
|
const unsigned char *src_ptr,
|
|
int src_pixels_per_line,
|
|
int xoffset,
|
|
int yoffset,
|
|
const unsigned char *dst_ptr,
|
|
int dst_pixels_per_line,
|
|
unsigned int *sse
|
|
) {
|
|
unsigned short FData3[17 * 16]; // Temp data bufffer used in filtering
|
|
unsigned char temp2[20 * 16];
|
|
const short *HFilter, *VFilter;
|
|
|
|
HFilter = vp8_bilinear_filters[xoffset];
|
|
VFilter = vp8_bilinear_filters[yoffset];
|
|
|
|
var_filter_block2d_bil_first_pass(src_ptr, FData3, src_pixels_per_line, 1, 17, 16, HFilter);
|
|
var_filter_block2d_bil_second_pass(FData3, temp2, 16, 16, 16, 16, VFilter);
|
|
|
|
return vp8_variance16x16_c(temp2, 16, dst_ptr, dst_pixels_per_line, sse);
|
|
}
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
unsigned int vp8_sub_pixel_variance32x32_c(const unsigned char *src_ptr,
|
|
int src_pixels_per_line,
|
|
int xoffset,
|
|
int yoffset,
|
|
const unsigned char *dst_ptr,
|
|
int dst_pixels_per_line,
|
|
unsigned int *sse) {
|
|
unsigned short FData3[33 * 32]; // Temp data bufffer used in filtering
|
|
unsigned char temp2[36 * 32];
|
|
const short *HFilter, *VFilter;
|
|
|
|
HFilter = vp8_bilinear_filters[xoffset];
|
|
VFilter = vp8_bilinear_filters[yoffset];
|
|
|
|
var_filter_block2d_bil_first_pass(src_ptr, FData3, src_pixels_per_line, 1, 33, 32, HFilter);
|
|
var_filter_block2d_bil_second_pass(FData3, temp2, 32, 32, 32, 32, VFilter);
|
|
|
|
return vp8_variance32x32_c(temp2, 32, dst_ptr, dst_pixels_per_line, sse);
|
|
}
|
|
#endif
|
|
|
|
unsigned int vp8_variance_halfpixvar16x16_h_c(
|
|
const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
return vp8_sub_pixel_variance16x16_c(src_ptr, source_stride, 8, 0,
|
|
ref_ptr, recon_stride, sse);
|
|
}
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
unsigned int vp8_variance_halfpixvar32x32_h_c(const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
return vp8_sub_pixel_variance32x32_c(src_ptr, source_stride, 8, 0,
|
|
ref_ptr, recon_stride, sse);
|
|
}
|
|
#endif
|
|
|
|
|
|
unsigned int vp8_variance_halfpixvar16x16_v_c(const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
return vp8_sub_pixel_variance16x16_c(src_ptr, source_stride, 0, 8,
|
|
ref_ptr, recon_stride, sse);
|
|
}
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
unsigned int vp8_variance_halfpixvar32x32_v_c(
|
|
const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
return vp8_sub_pixel_variance32x32_c(src_ptr, source_stride, 0, 8,
|
|
ref_ptr, recon_stride, sse);
|
|
}
|
|
#endif
|
|
|
|
unsigned int vp8_variance_halfpixvar16x16_hv_c(
|
|
const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
return vp8_sub_pixel_variance16x16_c(src_ptr, source_stride, 8, 8,
|
|
ref_ptr, recon_stride, sse);
|
|
}
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
unsigned int vp8_variance_halfpixvar32x32_hv_c(const unsigned char *src_ptr,
|
|
int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
int recon_stride,
|
|
unsigned int *sse) {
|
|
return vp8_sub_pixel_variance32x32_c(src_ptr, source_stride, 8, 8,
|
|
ref_ptr, recon_stride, sse);
|
|
}
|
|
#endif
|
|
|
|
unsigned int vp8_sub_pixel_mse16x16_c
|
|
(
|
|
const unsigned char *src_ptr,
|
|
int src_pixels_per_line,
|
|
int xoffset,
|
|
int yoffset,
|
|
const unsigned char *dst_ptr,
|
|
int dst_pixels_per_line,
|
|
unsigned int *sse
|
|
) {
|
|
vp8_sub_pixel_variance16x16_c(src_ptr, src_pixels_per_line, xoffset, yoffset, dst_ptr, dst_pixels_per_line, sse);
|
|
return *sse;
|
|
}
|
|
|
|
#if CONFIG_SUPERBLOCKS
|
|
unsigned int vp8_sub_pixel_mse32x32_c(const unsigned char *src_ptr,
|
|
int src_pixels_per_line,
|
|
int xoffset,
|
|
int yoffset,
|
|
const unsigned char *dst_ptr,
|
|
int dst_pixels_per_line,
|
|
unsigned int *sse) {
|
|
vp8_sub_pixel_variance32x32_c(src_ptr, src_pixels_per_line, xoffset, yoffset, dst_ptr, dst_pixels_per_line, sse);
|
|
return *sse;
|
|
}
|
|
#endif
|
|
|
|
unsigned int vp8_sub_pixel_variance16x8_c
|
|
(
|
|
const unsigned char *src_ptr,
|
|
int src_pixels_per_line,
|
|
int xoffset,
|
|
int yoffset,
|
|
const unsigned char *dst_ptr,
|
|
int dst_pixels_per_line,
|
|
unsigned int *sse
|
|
) {
|
|
unsigned short FData3[16 * 9]; // Temp data bufffer used in filtering
|
|
unsigned char temp2[20 * 16];
|
|
const short *HFilter, *VFilter;
|
|
|
|
HFilter = vp8_bilinear_filters[xoffset];
|
|
VFilter = vp8_bilinear_filters[yoffset];
|
|
|
|
var_filter_block2d_bil_first_pass(src_ptr, FData3, src_pixels_per_line, 1, 9, 16, HFilter);
|
|
var_filter_block2d_bil_second_pass(FData3, temp2, 16, 16, 8, 16, VFilter);
|
|
|
|
return vp8_variance16x8_c(temp2, 16, dst_ptr, dst_pixels_per_line, sse);
|
|
}
|
|
|
|
unsigned int vp8_sub_pixel_variance8x16_c
|
|
(
|
|
const unsigned char *src_ptr,
|
|
int src_pixels_per_line,
|
|
int xoffset,
|
|
int yoffset,
|
|
const unsigned char *dst_ptr,
|
|
int dst_pixels_per_line,
|
|
unsigned int *sse
|
|
) {
|
|
unsigned short FData3[9 * 16]; // Temp data bufffer used in filtering
|
|
unsigned char temp2[20 * 16];
|
|
const short *HFilter, *VFilter;
|
|
|
|
|
|
HFilter = vp8_bilinear_filters[xoffset];
|
|
VFilter = vp8_bilinear_filters[yoffset];
|
|
|
|
|
|
var_filter_block2d_bil_first_pass(src_ptr, FData3, src_pixels_per_line, 1, 17, 8, HFilter);
|
|
var_filter_block2d_bil_second_pass(FData3, temp2, 8, 8, 16, 8, VFilter);
|
|
|
|
return vp8_variance8x16_c(temp2, 8, dst_ptr, dst_pixels_per_line, sse);
|
|
}
|
|
#if CONFIG_NEWBESTREFMV
|
|
unsigned int vp8_variance2x16_c(
|
|
const unsigned char *src_ptr,
|
|
const int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
const int recon_stride,
|
|
unsigned int *sse) {
|
|
unsigned int var;
|
|
int avg;
|
|
|
|
variance(src_ptr, source_stride, ref_ptr, recon_stride, 2, 16, &var, &avg);
|
|
*sse = var;
|
|
return (var - ((avg * avg) >> 5));
|
|
}
|
|
|
|
unsigned int vp8_variance16x2_c(
|
|
const unsigned char *src_ptr,
|
|
const int source_stride,
|
|
const unsigned char *ref_ptr,
|
|
const int recon_stride,
|
|
unsigned int *sse) {
|
|
unsigned int var;
|
|
int avg;
|
|
|
|
variance(src_ptr, source_stride, ref_ptr, recon_stride, 16, 2, &var, &avg);
|
|
*sse = var;
|
|
return (var - ((avg * avg) >> 5));
|
|
}
|
|
|
|
unsigned int vp8_sub_pixel_variance16x2_c
|
|
(
|
|
const unsigned char *src_ptr,
|
|
const int src_pixels_per_line,
|
|
const int xoffset,
|
|
const int yoffset,
|
|
const unsigned char *dst_ptr,
|
|
const int dst_pixels_per_line,
|
|
unsigned int *sse
|
|
) {
|
|
unsigned short FData3[16 * 3]; // Temp data bufffer used in filtering
|
|
unsigned char temp2[20 * 16];
|
|
const short *HFilter, *VFilter;
|
|
|
|
HFilter = vp8_bilinear_filters[xoffset];
|
|
VFilter = vp8_bilinear_filters[yoffset];
|
|
|
|
var_filter_block2d_bil_first_pass(src_ptr, FData3,
|
|
src_pixels_per_line, 1, 3, 16, HFilter);
|
|
var_filter_block2d_bil_second_pass(FData3, temp2, 16, 16, 2, 16, VFilter);
|
|
|
|
return vp8_variance16x2_c(temp2, 16, dst_ptr, dst_pixels_per_line, sse);
|
|
}
|
|
|
|
unsigned int vp8_sub_pixel_variance2x16_c
|
|
(
|
|
const unsigned char *src_ptr,
|
|
const int src_pixels_per_line,
|
|
const int xoffset,
|
|
const int yoffset,
|
|
const unsigned char *dst_ptr,
|
|
const int dst_pixels_per_line,
|
|
unsigned int *sse
|
|
) {
|
|
unsigned short FData3[2 * 17]; // Temp data bufffer used in filtering
|
|
unsigned char temp2[2 * 16];
|
|
const short *HFilter, *VFilter;
|
|
|
|
HFilter = vp8_bilinear_filters[xoffset];
|
|
VFilter = vp8_bilinear_filters[yoffset];
|
|
|
|
var_filter_block2d_bil_first_pass(src_ptr, FData3,
|
|
src_pixels_per_line, 1, 17, 2, HFilter);
|
|
var_filter_block2d_bil_second_pass(FData3, temp2, 2, 2, 16, 2, VFilter);
|
|
|
|
return vp8_variance2x16_c(temp2, 2, dst_ptr, dst_pixels_per_line, sse);
|
|
}
|
|
#endif
|