2010-05-18 17:58:33 +02:00
|
|
|
/*
|
2010-09-09 14:16:39 +02:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 17:58:33 +02:00
|
|
|
*
|
2010-06-18 18:39:21 +02:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-04 22:19:40 +02:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-18 18:39:21 +02:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-04 22:19:40 +02:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 17:58:33 +02:00
|
|
|
*/
|
|
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
#include <assert.h>
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-12-23 16:20:10 +01:00
|
|
|
#include "./vpx_config.h"
|
2011-07-25 16:11:24 +02:00
|
|
|
#include "vpx/vpx_integer.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/common/vp9_blockd.h"
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
#include "vp9/common/vp9_filter.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/common/vp9_reconinter.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_reconintra.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_setup_interp_filters(MACROBLOCKD *xd,
|
2012-07-18 22:43:01 +02:00
|
|
|
INTERPOLATIONFILTERTYPE mcomp_filter_type,
|
2012-10-31 01:53:32 +01:00
|
|
|
VP9_COMMON *cm) {
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
// TODO(agrange): Investigate the best choice of functions to use here
|
|
|
|
|
// for EIGHTTAP_SMOOTH. Since it is not interpolating, need to choose what
|
|
|
|
|
// to do at full-pel offsets. The current selection, where the filter is
|
|
|
|
|
// applied in one direction only, and not at all for 0,0, seems to give the
|
|
|
|
|
// best quality, but it may be worth trying an additional mode that does
|
|
|
|
|
// do the filtering on full-pel.
|
|
|
|
|
xd->subpix.predict[0][0][0] = vp9_convolve_copy;
|
|
|
|
|
xd->subpix.predict[0][0][1] = vp9_convolve_avg;
|
|
|
|
|
xd->subpix.predict[0][1][0] = vp9_convolve8_vert;
|
|
|
|
|
xd->subpix.predict[0][1][1] = vp9_convolve8_avg_vert;
|
|
|
|
|
xd->subpix.predict[1][0][0] = vp9_convolve8_horiz;
|
|
|
|
|
xd->subpix.predict[1][0][1] = vp9_convolve8_avg_horiz;
|
|
|
|
|
xd->subpix.predict[1][1][0] = vp9_convolve8;
|
|
|
|
|
xd->subpix.predict[1][1][1] = vp9_convolve8_avg;
|
|
|
|
|
|
|
|
|
|
xd->subpix.x_step_q4 = 16;
|
|
|
|
|
xd->subpix.y_step_q4 = 16;
|
|
|
|
|
switch (mcomp_filter_type) {
|
|
|
|
|
case EIGHTTAP:
|
|
|
|
|
case SWITCHABLE:
|
|
|
|
|
xd->subpix.filter_x = xd->subpix.filter_y = vp9_sub_pel_filters_8;
|
|
|
|
|
break;
|
|
|
|
|
case EIGHTTAP_SMOOTH:
|
|
|
|
|
xd->subpix.filter_x = xd->subpix.filter_y = vp9_sub_pel_filters_8lp;
|
|
|
|
|
break;
|
|
|
|
|
case EIGHTTAP_SHARP:
|
|
|
|
|
xd->subpix.filter_x = xd->subpix.filter_y = vp9_sub_pel_filters_8s;
|
|
|
|
|
break;
|
|
|
|
|
case BILINEAR:
|
|
|
|
|
xd->subpix.filter_x = xd->subpix.filter_y = vp9_bilinear_filters;
|
|
|
|
|
break;
|
2013-01-08 23:14:01 +01:00
|
|
|
#if CONFIG_ENABLE_6TAP
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
case SIXTAP:
|
|
|
|
|
xd->subpix.filter_x = xd->subpix.filter_y = vp9_sub_pel_filters_6;
|
|
|
|
|
break;
|
2013-01-08 23:14:01 +01:00
|
|
|
#endif
|
|
|
|
|
}
|
2012-07-18 22:43:01 +02:00
|
|
|
}
|
|
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
void vp9_copy_mem16x16_c(const uint8_t *src,
|
2012-11-01 00:09:17 +01:00
|
|
|
int src_stride,
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *dst,
|
2012-11-01 00:09:17 +01:00
|
|
|
int dst_stride) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int r;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (r = 0; r < 16; r++) {
|
2011-07-25 16:11:24 +02:00
|
|
|
#if !(CONFIG_FAST_UNALIGNED)
|
2012-07-14 00:21:29 +02:00
|
|
|
dst[0] = src[0];
|
|
|
|
|
dst[1] = src[1];
|
|
|
|
|
dst[2] = src[2];
|
|
|
|
|
dst[3] = src[3];
|
|
|
|
|
dst[4] = src[4];
|
|
|
|
|
dst[5] = src[5];
|
|
|
|
|
dst[6] = src[6];
|
|
|
|
|
dst[7] = src[7];
|
|
|
|
|
dst[8] = src[8];
|
|
|
|
|
dst[9] = src[9];
|
|
|
|
|
dst[10] = src[10];
|
|
|
|
|
dst[11] = src[11];
|
|
|
|
|
dst[12] = src[12];
|
|
|
|
|
dst[13] = src[13];
|
|
|
|
|
dst[14] = src[14];
|
|
|
|
|
dst[15] = src[15];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
#else
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
((uint32_t *)dst)[0] = ((const uint32_t *)src)[0];
|
|
|
|
|
((uint32_t *)dst)[1] = ((const uint32_t *)src)[1];
|
|
|
|
|
((uint32_t *)dst)[2] = ((const uint32_t *)src)[2];
|
|
|
|
|
((uint32_t *)dst)[3] = ((const uint32_t *)src)[3];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
src += src_stride;
|
|
|
|
|
dst += dst_stride;
|
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
void vp9_copy_mem8x8_c(const uint8_t *src,
|
2012-11-01 00:09:17 +01:00
|
|
|
int src_stride,
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *dst,
|
2012-11-01 00:09:17 +01:00
|
|
|
int dst_stride) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
|
|
for (r = 0; r < 8; r++) {
|
2011-07-25 16:11:24 +02:00
|
|
|
#if !(CONFIG_FAST_UNALIGNED)
|
2012-07-14 00:21:29 +02:00
|
|
|
dst[0] = src[0];
|
|
|
|
|
dst[1] = src[1];
|
|
|
|
|
dst[2] = src[2];
|
|
|
|
|
dst[3] = src[3];
|
|
|
|
|
dst[4] = src[4];
|
|
|
|
|
dst[5] = src[5];
|
|
|
|
|
dst[6] = src[6];
|
|
|
|
|
dst[7] = src[7];
|
2010-05-18 17:58:33 +02:00
|
|
|
#else
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
((uint32_t *)dst)[0] = ((const uint32_t *)src)[0];
|
|
|
|
|
((uint32_t *)dst)[1] = ((const uint32_t *)src)[1];
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
src += src_stride;
|
|
|
|
|
dst += dst_stride;
|
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
void vp9_copy_mem8x4_c(const uint8_t *src,
|
2012-11-01 00:09:17 +01:00
|
|
|
int src_stride,
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *dst,
|
2012-11-01 00:09:17 +01:00
|
|
|
int dst_stride) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
|
|
for (r = 0; r < 4; r++) {
|
2011-07-25 16:11:24 +02:00
|
|
|
#if !(CONFIG_FAST_UNALIGNED)
|
2012-07-14 00:21:29 +02:00
|
|
|
dst[0] = src[0];
|
|
|
|
|
dst[1] = src[1];
|
|
|
|
|
dst[2] = src[2];
|
|
|
|
|
dst[3] = src[3];
|
|
|
|
|
dst[4] = src[4];
|
|
|
|
|
dst[5] = src[5];
|
|
|
|
|
dst[6] = src[6];
|
|
|
|
|
dst[7] = src[7];
|
2010-05-18 17:58:33 +02:00
|
|
|
#else
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
((uint32_t *)dst)[0] = ((const uint32_t *)src)[0];
|
|
|
|
|
((uint32_t *)dst)[1] = ((const uint32_t *)src)[1];
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
src += src_stride;
|
|
|
|
|
dst += dst_stride;
|
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
void vp9_build_inter_predictors_b(BLOCKD *d, int pitch,
|
|
|
|
|
struct subpix_fn_table *subpix) {
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *ptr_base;
|
|
|
|
|
uint8_t *ptr;
|
|
|
|
|
uint8_t *pred_ptr = d->predictor;
|
2012-07-14 00:21:29 +02:00
|
|
|
int_mv mv;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
ptr_base = *(d->base_pre);
|
2013-02-09 04:46:36 +01:00
|
|
|
mv.as_int = d->bmi.as_mv[0].as_int;
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
|
|
|
|
|
(mv.as_mv.col >> 3);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
subpix->predict[!!(mv.as_mv.col & 7)][!!(mv.as_mv.row & 7)][0](
|
|
|
|
|
ptr, d->pre_stride, pred_ptr, pitch,
|
|
|
|
|
subpix->filter_x[(mv.as_mv.col & 7) << 1], subpix->x_step_q4,
|
|
|
|
|
subpix->filter_y[(mv.as_mv.row & 7) << 1], subpix->y_step_q4,
|
|
|
|
|
4, 4);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
2012-04-18 22:51:58 +02:00
|
|
|
/*
|
2012-10-31 00:25:53 +01:00
|
|
|
* Similar to vp9_build_inter_predictors_b(), but instead of storing the
|
2012-04-18 22:51:58 +02:00
|
|
|
* results in d->predictor, we average the contents of d->predictor (which
|
2012-10-31 00:25:53 +01:00
|
|
|
* come from an earlier call to vp9_build_inter_predictors_b()) with the
|
2012-04-18 22:51:58 +02:00
|
|
|
* predictor of the second reference frame / motion vector.
|
|
|
|
|
*/
|
2012-11-01 00:09:17 +01:00
|
|
|
void vp9_build_2nd_inter_predictors_b(BLOCKD *d, int pitch,
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
struct subpix_fn_table *subpix) {
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *ptr_base;
|
|
|
|
|
uint8_t *ptr;
|
|
|
|
|
uint8_t *pred_ptr = d->predictor;
|
2012-07-14 00:21:29 +02:00
|
|
|
int_mv mv;
|
|
|
|
|
|
|
|
|
|
ptr_base = *(d->base_second_pre);
|
2013-02-09 04:46:36 +01:00
|
|
|
mv.as_int = d->bmi.as_mv[1].as_int;
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
|
|
|
|
|
(mv.as_mv.col >> 3);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
subpix->predict[!!(mv.as_mv.col & 7)][!!(mv.as_mv.row & 7)][1](
|
|
|
|
|
ptr, d->pre_stride, pred_ptr, pitch,
|
|
|
|
|
subpix->filter_x[(mv.as_mv.col & 7) << 1], subpix->x_step_q4,
|
|
|
|
|
subpix->filter_y[(mv.as_mv.row & 7) << 1], subpix->y_step_q4,
|
|
|
|
|
4, 4);
|
2012-04-18 22:51:58 +02:00
|
|
|
}
|
|
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_build_inter_predictors4b(MACROBLOCKD *xd, BLOCKD *d, int pitch) {
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *ptr_base;
|
|
|
|
|
uint8_t *ptr;
|
|
|
|
|
uint8_t *pred_ptr = d->predictor;
|
2012-07-14 00:21:29 +02:00
|
|
|
int_mv mv;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
ptr_base = *(d->base_pre);
|
2013-02-09 04:46:36 +01:00
|
|
|
mv.as_int = d->bmi.as_mv[0].as_int;
|
2012-08-15 12:00:53 +02:00
|
|
|
ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
|
|
|
|
|
(mv.as_mv.col >> 3);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
xd->subpix.predict[!!(mv.as_mv.col & 7)][!!(mv.as_mv.row & 7)][0](
|
|
|
|
|
ptr, d->pre_stride, pred_ptr, pitch,
|
|
|
|
|
xd->subpix.filter_x[(mv.as_mv.col & 7) << 1], xd->subpix.x_step_q4,
|
|
|
|
|
xd->subpix.filter_y[(mv.as_mv.row & 7) << 1], xd->subpix.y_step_q4,
|
|
|
|
|
8, 8);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
2012-04-18 22:51:58 +02:00
|
|
|
/*
|
|
|
|
|
* Similar to build_inter_predictors_4b(), but instead of storing the
|
|
|
|
|
* results in d->predictor, we average the contents of d->predictor (which
|
|
|
|
|
* come from an earlier call to build_inter_predictors_4b()) with the
|
|
|
|
|
* predictor of the second reference frame / motion vector.
|
|
|
|
|
*/
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_build_2nd_inter_predictors4b(MACROBLOCKD *xd,
|
2012-10-17 20:40:00 +02:00
|
|
|
BLOCKD *d, int pitch) {
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *ptr_base;
|
|
|
|
|
uint8_t *ptr;
|
|
|
|
|
uint8_t *pred_ptr = d->predictor;
|
2012-07-14 00:21:29 +02:00
|
|
|
int_mv mv;
|
|
|
|
|
|
|
|
|
|
ptr_base = *(d->base_second_pre);
|
2013-02-09 04:46:36 +01:00
|
|
|
mv.as_int = d->bmi.as_mv[1].as_int;
|
2012-08-15 12:00:53 +02:00
|
|
|
ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
|
|
|
|
|
(mv.as_mv.col >> 3);
|
2012-04-18 22:51:58 +02:00
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
xd->subpix.predict[!!(mv.as_mv.col & 7)][!!(mv.as_mv.row & 7)][1](
|
|
|
|
|
ptr, d->pre_stride, pred_ptr, pitch,
|
|
|
|
|
xd->subpix.filter_x[(mv.as_mv.col & 7) << 1], xd->subpix.x_step_q4,
|
|
|
|
|
xd->subpix.filter_y[(mv.as_mv.row & 7) << 1], xd->subpix.y_step_q4,
|
|
|
|
|
8, 8);
|
2012-04-18 22:51:58 +02:00
|
|
|
}
|
|
|
|
|
|
2012-08-15 12:00:53 +02:00
|
|
|
static void build_inter_predictors2b(MACROBLOCKD *xd, BLOCKD *d, int pitch) {
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *ptr_base;
|
|
|
|
|
uint8_t *ptr;
|
|
|
|
|
uint8_t *pred_ptr = d->predictor;
|
2012-07-14 00:21:29 +02:00
|
|
|
int_mv mv;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
ptr_base = *(d->base_pre);
|
2013-02-09 04:46:36 +01:00
|
|
|
mv.as_int = d->bmi.as_mv[0].as_int;
|
2012-08-15 12:00:53 +02:00
|
|
|
ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
|
|
|
|
|
(mv.as_mv.col >> 3);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
xd->subpix.predict[!!(mv.as_mv.col & 7)][!!(mv.as_mv.row & 7)][0](
|
|
|
|
|
ptr, d->pre_stride, pred_ptr, pitch,
|
|
|
|
|
xd->subpix.filter_x[(mv.as_mv.col & 7) << 1], xd->subpix.x_step_q4,
|
|
|
|
|
xd->subpix.filter_y[(mv.as_mv.row & 7) << 1], xd->subpix.y_step_q4,
|
|
|
|
|
8, 4);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
2011-08-24 20:42:26 +02:00
|
|
|
/*encoder only*/
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_build_inter4x4_predictors_mbuv(MACROBLOCKD *xd) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int i, j;
|
2012-08-14 12:32:29 +02:00
|
|
|
BLOCKD *blockd = xd->block;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
/* build uv mvs */
|
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
|
for (j = 0; j < 2; j++) {
|
|
|
|
|
int yoffset = i * 8 + j * 2;
|
|
|
|
|
int uoffset = 16 + i * 2 + j;
|
|
|
|
|
int voffset = 20 + i * 2 + j;
|
|
|
|
|
int temp;
|
|
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
temp = blockd[yoffset ].bmi.as_mv[0].as_mv.row
|
|
|
|
|
+ blockd[yoffset + 1].bmi.as_mv[0].as_mv.row
|
|
|
|
|
+ blockd[yoffset + 4].bmi.as_mv[0].as_mv.row
|
|
|
|
|
+ blockd[yoffset + 5].bmi.as_mv[0].as_mv.row;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
if (temp < 0) temp -= 4;
|
|
|
|
|
else temp += 4;
|
|
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
xd->block[uoffset].bmi.as_mv[0].as_mv.row = (temp / 8) &
|
2012-08-14 12:32:29 +02:00
|
|
|
xd->fullpixel_mask;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
temp = blockd[yoffset ].bmi.as_mv[0].as_mv.col
|
|
|
|
|
+ blockd[yoffset + 1].bmi.as_mv[0].as_mv.col
|
|
|
|
|
+ blockd[yoffset + 4].bmi.as_mv[0].as_mv.col
|
|
|
|
|
+ blockd[yoffset + 5].bmi.as_mv[0].as_mv.col;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
if (temp < 0) temp -= 4;
|
|
|
|
|
else temp += 4;
|
|
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
blockd[uoffset].bmi.as_mv[0].as_mv.col = (temp / 8) &
|
2012-08-14 12:32:29 +02:00
|
|
|
xd->fullpixel_mask;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
blockd[voffset].bmi.as_mv[0].as_mv.row =
|
|
|
|
|
blockd[uoffset].bmi.as_mv[0].as_mv.row;
|
|
|
|
|
blockd[voffset].bmi.as_mv[0].as_mv.col =
|
|
|
|
|
blockd[uoffset].bmi.as_mv[0].as_mv.col;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-11-07 15:50:25 +01:00
|
|
|
if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
|
2013-02-09 04:46:36 +01:00
|
|
|
temp = blockd[yoffset ].bmi.as_mv[1].as_mv.row
|
|
|
|
|
+ blockd[yoffset + 1].bmi.as_mv[1].as_mv.row
|
|
|
|
|
+ blockd[yoffset + 4].bmi.as_mv[1].as_mv.row
|
|
|
|
|
+ blockd[yoffset + 5].bmi.as_mv[1].as_mv.row;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
if (temp < 0) {
|
|
|
|
|
temp -= 4;
|
|
|
|
|
} else {
|
|
|
|
|
temp += 4;
|
2011-08-24 20:42:26 +02:00
|
|
|
}
|
|
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
blockd[uoffset].bmi.as_mv[1].as_mv.row = (temp / 8) &
|
2012-08-14 12:32:29 +02:00
|
|
|
xd->fullpixel_mask;
|
2012-04-18 22:51:58 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
temp = blockd[yoffset ].bmi.as_mv[1].as_mv.col
|
|
|
|
|
+ blockd[yoffset + 1].bmi.as_mv[1].as_mv.col
|
|
|
|
|
+ blockd[yoffset + 4].bmi.as_mv[1].as_mv.col
|
|
|
|
|
+ blockd[yoffset + 5].bmi.as_mv[1].as_mv.col;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
if (temp < 0) {
|
|
|
|
|
temp -= 4;
|
|
|
|
|
} else {
|
|
|
|
|
temp += 4;
|
2012-04-18 22:51:58 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
blockd[uoffset].bmi.as_mv[1].as_mv.col = (temp / 8) &
|
2012-08-14 12:32:29 +02:00
|
|
|
xd->fullpixel_mask;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
blockd[voffset].bmi.as_mv[1].as_mv.row =
|
|
|
|
|
blockd[uoffset].bmi.as_mv[1].as_mv.row;
|
|
|
|
|
blockd[voffset].bmi.as_mv[1].as_mv.col =
|
|
|
|
|
blockd[uoffset].bmi.as_mv[1].as_mv.col;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 16; i < 24; i += 2) {
|
2012-08-14 12:32:29 +02:00
|
|
|
BLOCKD *d0 = &blockd[i];
|
|
|
|
|
BLOCKD *d1 = &blockd[i + 1];
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
if (d0->bmi.as_mv[0].as_int == d1->bmi.as_mv[0].as_int)
|
2012-08-14 12:32:29 +02:00
|
|
|
build_inter_predictors2b(xd, d0, 8);
|
2012-07-14 00:21:29 +02:00
|
|
|
else {
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
vp9_build_inter_predictors_b(d0, 8, &xd->subpix);
|
|
|
|
|
vp9_build_inter_predictors_b(d1, 8, &xd->subpix);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
2012-11-07 15:50:25 +01:00
|
|
|
if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
vp9_build_2nd_inter_predictors_b(d0, 8, &xd->subpix);
|
|
|
|
|
vp9_build_2nd_inter_predictors_b(d1, 8, &xd->subpix);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static void clamp_mv_to_umv_border(MV *mv, const MACROBLOCKD *xd) {
|
|
|
|
|
/* If the MV points so far into the UMV border that no visible pixels
|
|
|
|
|
* are used for reconstruction, the subpel part of the MV can be
|
|
|
|
|
* discarded and the MV limited to 16 pixels with equivalent results.
|
|
|
|
|
*
|
|
|
|
|
* This limit kicks in at 19 pixels for the top and left edges, for
|
|
|
|
|
* the 16 pixels plus 3 taps right of the central pixel when subpel
|
|
|
|
|
* filtering. The bottom and right edges use 16 pixels plus 2 pixels
|
|
|
|
|
* left of the central pixel when filtering.
|
|
|
|
|
*/
|
2012-11-02 01:53:44 +01:00
|
|
|
if (mv->col < (xd->mb_to_left_edge - ((16 + VP9_INTERP_EXTEND) << 3)))
|
2012-07-14 00:21:29 +02:00
|
|
|
mv->col = xd->mb_to_left_edge - (16 << 3);
|
2012-11-02 01:53:44 +01:00
|
|
|
else if (mv->col > xd->mb_to_right_edge + ((15 + VP9_INTERP_EXTEND) << 3))
|
2012-07-14 00:21:29 +02:00
|
|
|
mv->col = xd->mb_to_right_edge + (16 << 3);
|
|
|
|
|
|
2012-11-02 01:53:44 +01:00
|
|
|
if (mv->row < (xd->mb_to_top_edge - ((16 + VP9_INTERP_EXTEND) << 3)))
|
2012-07-14 00:21:29 +02:00
|
|
|
mv->row = xd->mb_to_top_edge - (16 << 3);
|
2012-11-02 01:53:44 +01:00
|
|
|
else if (mv->row > xd->mb_to_bottom_edge + ((15 + VP9_INTERP_EXTEND) << 3))
|
2012-07-14 00:21:29 +02:00
|
|
|
mv->row = xd->mb_to_bottom_edge + (16 << 3);
|
2012-02-01 23:27:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* A version of the above function for chroma block MVs.*/
|
2012-07-14 00:21:29 +02:00
|
|
|
static void clamp_uvmv_to_umv_border(MV *mv, const MACROBLOCKD *xd) {
|
2012-11-02 01:53:44 +01:00
|
|
|
const int extend = VP9_INTERP_EXTEND;
|
|
|
|
|
|
|
|
|
|
mv->col = (2 * mv->col < (xd->mb_to_left_edge - ((16 + extend) << 3))) ?
|
2012-07-14 00:21:29 +02:00
|
|
|
(xd->mb_to_left_edge - (16 << 3)) >> 1 : mv->col;
|
2012-11-02 01:53:44 +01:00
|
|
|
mv->col = (2 * mv->col > xd->mb_to_right_edge + ((15 + extend) << 3)) ?
|
2012-07-14 00:21:29 +02:00
|
|
|
(xd->mb_to_right_edge + (16 << 3)) >> 1 : mv->col;
|
|
|
|
|
|
2012-11-02 01:53:44 +01:00
|
|
|
mv->row = (2 * mv->row < (xd->mb_to_top_edge - ((16 + extend) << 3))) ?
|
2012-07-14 00:21:29 +02:00
|
|
|
(xd->mb_to_top_edge - (16 << 3)) >> 1 : mv->row;
|
2012-11-02 01:53:44 +01:00
|
|
|
mv->row = (2 * mv->row > xd->mb_to_bottom_edge + ((15 + extend) << 3)) ?
|
2012-07-14 00:21:29 +02:00
|
|
|
(xd->mb_to_bottom_edge + (16 << 3)) >> 1 : mv->row;
|
2012-02-01 23:27:50 +01:00
|
|
|
}
|
|
|
|
|
|
2012-08-09 02:12:12 +02:00
|
|
|
/*encoder only*/
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_build_1st_inter16x16_predictors_mby(MACROBLOCKD *xd,
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *dst_y,
|
2012-08-16 20:04:34 +02:00
|
|
|
int dst_ystride,
|
|
|
|
|
int clamp_mvs) {
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *ptr_base = xd->pre.y_buffer;
|
|
|
|
|
uint8_t *ptr;
|
2012-08-09 02:12:12 +02:00
|
|
|
int pre_stride = xd->block[0].pre_stride;
|
|
|
|
|
int_mv ymv;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-10 01:07:41 +02:00
|
|
|
ymv.as_int = xd->mode_info_context->mbmi.mv[0].as_int;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-16 20:04:34 +02:00
|
|
|
if (clamp_mvs)
|
2012-08-09 02:12:12 +02:00
|
|
|
clamp_mv_to_umv_border(&ymv.as_mv, xd);
|
2012-02-01 23:27:50 +01:00
|
|
|
|
2012-08-09 02:12:12 +02:00
|
|
|
ptr = ptr_base + (ymv.as_mv.row >> 3) * pre_stride + (ymv.as_mv.col >> 3);
|
2012-06-26 01:23:58 +02:00
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
xd->subpix.predict[!!(ymv.as_mv.col & 7)][!!(ymv.as_mv.row & 7)][0](
|
|
|
|
|
ptr, pre_stride, dst_y, dst_ystride,
|
|
|
|
|
xd->subpix.filter_x[(ymv.as_mv.col & 7) << 1], xd->subpix.x_step_q4,
|
|
|
|
|
xd->subpix.filter_y[(ymv.as_mv.row & 7) << 1], xd->subpix.y_step_q4,
|
|
|
|
|
16, 16);
|
2012-08-09 02:12:12 +02:00
|
|
|
}
|
|
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_build_1st_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *dst_u,
|
|
|
|
|
uint8_t *dst_v,
|
2012-08-09 02:12:12 +02:00
|
|
|
int dst_uvstride) {
|
|
|
|
|
int offset;
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *uptr, *vptr;
|
2012-08-14 12:32:29 +02:00
|
|
|
int pre_stride = xd->block[0].pre_stride;
|
2012-08-09 02:12:12 +02:00
|
|
|
int_mv _o16x16mv;
|
|
|
|
|
int_mv _16x16mv;
|
|
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
_16x16mv.as_int = xd->mode_info_context->mbmi.mv[0].as_int;
|
2012-08-09 02:12:12 +02:00
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
if (xd->mode_info_context->mbmi.need_to_clamp_mvs)
|
|
|
|
|
clamp_mv_to_umv_border(&_16x16mv.as_mv, xd);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
_o16x16mv = _16x16mv;
|
|
|
|
|
/* calc uv motion vectors */
|
|
|
|
|
if (_16x16mv.as_mv.row < 0)
|
|
|
|
|
_16x16mv.as_mv.row -= 1;
|
|
|
|
|
else
|
|
|
|
|
_16x16mv.as_mv.row += 1;
|
2011-08-24 20:42:26 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (_16x16mv.as_mv.col < 0)
|
|
|
|
|
_16x16mv.as_mv.col -= 1;
|
|
|
|
|
else
|
|
|
|
|
_16x16mv.as_mv.col += 1;
|
2011-08-24 20:42:26 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
_16x16mv.as_mv.row /= 2;
|
|
|
|
|
_16x16mv.as_mv.col /= 2;
|
2011-08-24 20:42:26 +02:00
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
_16x16mv.as_mv.row &= xd->fullpixel_mask;
|
|
|
|
|
_16x16mv.as_mv.col &= xd->fullpixel_mask;
|
2011-08-24 20:42:26 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pre_stride >>= 1;
|
|
|
|
|
offset = (_16x16mv.as_mv.row >> 3) * pre_stride + (_16x16mv.as_mv.col >> 3);
|
2012-08-14 12:32:29 +02:00
|
|
|
uptr = xd->pre.u_buffer + offset;
|
|
|
|
|
vptr = xd->pre.v_buffer + offset;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
xd->subpix.predict[!!(_o16x16mv.as_mv.col & 15)]
|
|
|
|
|
[!!(_o16x16mv.as_mv.row & 15)][0](
|
|
|
|
|
uptr, pre_stride, dst_u, dst_uvstride,
|
|
|
|
|
xd->subpix.filter_x[_o16x16mv.as_mv.col & 15], xd->subpix.x_step_q4,
|
|
|
|
|
xd->subpix.filter_y[_o16x16mv.as_mv.row & 15], xd->subpix.y_step_q4,
|
|
|
|
|
8, 8);
|
|
|
|
|
|
|
|
|
|
xd->subpix.predict[!!(_o16x16mv.as_mv.col & 15)]
|
|
|
|
|
[!!(_o16x16mv.as_mv.row & 15)][0](
|
|
|
|
|
vptr, pre_stride, dst_v, dst_uvstride,
|
|
|
|
|
xd->subpix.filter_x[_o16x16mv.as_mv.col & 15], xd->subpix.x_step_q4,
|
|
|
|
|
xd->subpix.filter_y[_o16x16mv.as_mv.row & 15], xd->subpix.y_step_q4,
|
|
|
|
|
8, 8);
|
2012-08-09 02:12:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_build_1st_inter16x16_predictors_mb(MACROBLOCKD *xd,
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *dst_y,
|
|
|
|
|
uint8_t *dst_u,
|
|
|
|
|
uint8_t *dst_v,
|
2012-08-09 02:12:12 +02:00
|
|
|
int dst_ystride, int dst_uvstride) {
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_build_1st_inter16x16_predictors_mby(xd, dst_y, dst_ystride,
|
2012-08-16 20:04:34 +02:00
|
|
|
xd->mode_info_context->mbmi.need_to_clamp_mvs);
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_build_1st_inter16x16_predictors_mbuv(xd, dst_u, dst_v, dst_uvstride);
|
2011-04-28 16:53:59 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_build_inter32x32_predictors_sb(MACROBLOCKD *x,
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *dst_y,
|
|
|
|
|
uint8_t *dst_u,
|
|
|
|
|
uint8_t *dst_v,
|
2012-08-20 23:43:34 +02:00
|
|
|
int dst_ystride,
|
|
|
|
|
int dst_uvstride) {
|
|
|
|
|
uint8_t *y1 = x->pre.y_buffer, *u1 = x->pre.u_buffer, *v1 = x->pre.v_buffer;
|
|
|
|
|
uint8_t *y2 = x->second_pre.y_buffer, *u2 = x->second_pre.u_buffer,
|
|
|
|
|
*v2 = x->second_pre.v_buffer;
|
2012-11-13 00:43:11 +01:00
|
|
|
int edge[4], n;
|
2012-08-20 23:43:34 +02:00
|
|
|
|
2012-11-13 00:43:11 +01:00
|
|
|
edge[0] = x->mb_to_top_edge;
|
|
|
|
|
edge[1] = x->mb_to_bottom_edge;
|
|
|
|
|
edge[2] = x->mb_to_left_edge;
|
|
|
|
|
edge[3] = x->mb_to_right_edge;
|
|
|
|
|
|
|
|
|
|
for (n = 0; n < 4; n++) {
|
2012-08-20 23:43:34 +02:00
|
|
|
const int x_idx = n & 1, y_idx = n >> 1;
|
|
|
|
|
|
2012-11-13 00:43:11 +01:00
|
|
|
x->mb_to_top_edge = edge[0] - ((y_idx * 16) << 3);
|
|
|
|
|
x->mb_to_bottom_edge = edge[1] + (((1 - y_idx) * 16) << 3);
|
|
|
|
|
x->mb_to_left_edge = edge[2] - ((x_idx * 16) << 3);
|
|
|
|
|
x->mb_to_right_edge = edge[3] + (((1 - x_idx) * 16) << 3);
|
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
x->pre.y_buffer = y1 + y_idx * 16 * x->pre.y_stride + x_idx * 16;
|
|
|
|
|
x->pre.u_buffer = u1 + y_idx * 8 * x->pre.uv_stride + x_idx * 8;
|
|
|
|
|
x->pre.v_buffer = v1 + y_idx * 8 * x->pre.uv_stride + x_idx * 8;
|
|
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_build_1st_inter16x16_predictors_mb(x,
|
2012-08-20 23:43:34 +02:00
|
|
|
dst_y + y_idx * 16 * dst_ystride + x_idx * 16,
|
|
|
|
|
dst_u + y_idx * 8 * dst_uvstride + x_idx * 8,
|
|
|
|
|
dst_v + y_idx * 8 * dst_uvstride + x_idx * 8,
|
|
|
|
|
dst_ystride, dst_uvstride);
|
2012-11-07 15:50:25 +01:00
|
|
|
if (x->mode_info_context->mbmi.second_ref_frame > 0) {
|
2012-08-20 23:43:34 +02:00
|
|
|
x->second_pre.y_buffer = y2 + y_idx * 16 * x->pre.y_stride + x_idx * 16;
|
|
|
|
|
x->second_pre.u_buffer = u2 + y_idx * 8 * x->pre.uv_stride + x_idx * 8;
|
|
|
|
|
x->second_pre.v_buffer = v2 + y_idx * 8 * x->pre.uv_stride + x_idx * 8;
|
|
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_build_2nd_inter16x16_predictors_mb(x,
|
2012-08-20 23:43:34 +02:00
|
|
|
dst_y + y_idx * 16 * dst_ystride + x_idx * 16,
|
|
|
|
|
dst_u + y_idx * 8 * dst_uvstride + x_idx * 8,
|
|
|
|
|
dst_v + y_idx * 8 * dst_uvstride + x_idx * 8,
|
|
|
|
|
dst_ystride, dst_uvstride);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-13 00:43:11 +01:00
|
|
|
x->mb_to_top_edge = edge[0];
|
|
|
|
|
x->mb_to_bottom_edge = edge[1];
|
|
|
|
|
x->mb_to_left_edge = edge[2];
|
|
|
|
|
x->mb_to_right_edge = edge[3];
|
|
|
|
|
|
2012-08-20 23:43:34 +02:00
|
|
|
x->pre.y_buffer = y1;
|
|
|
|
|
x->pre.u_buffer = u1;
|
|
|
|
|
x->pre.v_buffer = v1;
|
|
|
|
|
|
2012-11-07 15:50:25 +01:00
|
|
|
if (x->mode_info_context->mbmi.second_ref_frame > 0) {
|
2012-08-20 23:43:34 +02:00
|
|
|
x->second_pre.y_buffer = y2;
|
|
|
|
|
x->second_pre.u_buffer = u2;
|
|
|
|
|
x->second_pre.v_buffer = v2;
|
|
|
|
|
}
|
2012-11-30 20:46:20 +01:00
|
|
|
|
|
|
|
|
#if CONFIG_COMP_INTERINTRA_PRED
|
|
|
|
|
if (x->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
|
|
|
|
|
vp9_build_interintra_32x32_predictors_sb(
|
|
|
|
|
x, dst_y, dst_u, dst_v, dst_ystride, dst_uvstride);
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void vp9_build_inter64x64_predictors_sb(MACROBLOCKD *x,
|
|
|
|
|
uint8_t *dst_y,
|
|
|
|
|
uint8_t *dst_u,
|
|
|
|
|
uint8_t *dst_v,
|
|
|
|
|
int dst_ystride,
|
|
|
|
|
int dst_uvstride) {
|
|
|
|
|
uint8_t *y1 = x->pre.y_buffer, *u1 = x->pre.u_buffer, *v1 = x->pre.v_buffer;
|
|
|
|
|
uint8_t *y2 = x->second_pre.y_buffer, *u2 = x->second_pre.u_buffer,
|
|
|
|
|
*v2 = x->second_pre.v_buffer;
|
|
|
|
|
int edge[4], n;
|
|
|
|
|
|
|
|
|
|
edge[0] = x->mb_to_top_edge;
|
|
|
|
|
edge[1] = x->mb_to_bottom_edge;
|
|
|
|
|
edge[2] = x->mb_to_left_edge;
|
|
|
|
|
edge[3] = x->mb_to_right_edge;
|
|
|
|
|
|
|
|
|
|
for (n = 0; n < 4; n++) {
|
|
|
|
|
const int x_idx = n & 1, y_idx = n >> 1;
|
|
|
|
|
|
|
|
|
|
x->mb_to_top_edge = edge[0] - ((y_idx * 32) << 3);
|
|
|
|
|
x->mb_to_bottom_edge = edge[1] + (((1 - y_idx) * 32) << 3);
|
|
|
|
|
x->mb_to_left_edge = edge[2] - ((x_idx * 32) << 3);
|
|
|
|
|
x->mb_to_right_edge = edge[3] + (((1 - x_idx) * 32) << 3);
|
|
|
|
|
|
|
|
|
|
x->pre.y_buffer = y1 + y_idx * 32 * x->pre.y_stride + x_idx * 32;
|
|
|
|
|
x->pre.u_buffer = u1 + y_idx * 16 * x->pre.uv_stride + x_idx * 16;
|
|
|
|
|
x->pre.v_buffer = v1 + y_idx * 16 * x->pre.uv_stride + x_idx * 16;
|
|
|
|
|
|
|
|
|
|
if (x->mode_info_context->mbmi.second_ref_frame > 0) {
|
|
|
|
|
x->second_pre.y_buffer = y2 + y_idx * 32 * x->pre.y_stride + x_idx * 32;
|
|
|
|
|
x->second_pre.u_buffer = u2 + y_idx * 16 * x->pre.uv_stride + x_idx * 16;
|
|
|
|
|
x->second_pre.v_buffer = v2 + y_idx * 16 * x->pre.uv_stride + x_idx * 16;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
vp9_build_inter32x32_predictors_sb(x,
|
|
|
|
|
dst_y + y_idx * 32 * dst_ystride + x_idx * 32,
|
|
|
|
|
dst_u + y_idx * 16 * dst_uvstride + x_idx * 16,
|
|
|
|
|
dst_v + y_idx * 16 * dst_uvstride + x_idx * 16,
|
|
|
|
|
dst_ystride, dst_uvstride);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
x->mb_to_top_edge = edge[0];
|
|
|
|
|
x->mb_to_bottom_edge = edge[1];
|
|
|
|
|
x->mb_to_left_edge = edge[2];
|
|
|
|
|
x->mb_to_right_edge = edge[3];
|
|
|
|
|
|
|
|
|
|
x->pre.y_buffer = y1;
|
|
|
|
|
x->pre.u_buffer = u1;
|
|
|
|
|
x->pre.v_buffer = v1;
|
|
|
|
|
|
|
|
|
|
if (x->mode_info_context->mbmi.second_ref_frame > 0) {
|
|
|
|
|
x->second_pre.y_buffer = y2;
|
|
|
|
|
x->second_pre.u_buffer = u2;
|
|
|
|
|
x->second_pre.v_buffer = v2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if CONFIG_COMP_INTERINTRA_PRED
|
|
|
|
|
if (x->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
|
|
|
|
|
vp9_build_interintra_64x64_predictors_sb(x, dst_y, dst_u, dst_v,
|
|
|
|
|
dst_ystride, dst_uvstride);
|
2012-11-30 20:46:20 +01:00
|
|
|
}
|
|
|
|
|
#endif
|
2012-08-20 23:43:34 +02:00
|
|
|
}
|
|
|
|
|
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
/*
|
2012-08-09 02:12:12 +02:00
|
|
|
* The following functions should be called after an initial
|
2012-10-31 22:40:53 +01:00
|
|
|
* call to vp9_build_1st_inter16x16_predictors_mb() or _mby()/_mbuv().
|
2013-01-08 23:14:01 +01:00
|
|
|
* It will run a second filter on a (different) ref
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
* frame and average the result with the output of the
|
2013-01-08 23:14:01 +01:00
|
|
|
* first filter. The second reference frame is stored
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
* in x->second_pre (the reference frame index is in
|
|
|
|
|
* x->mode_info_context->mbmi.second_ref_frame). The second
|
|
|
|
|
* motion vector is x->mode_info_context->mbmi.second_mv.
|
|
|
|
|
*
|
|
|
|
|
* This allows blending prediction from two reference frames
|
|
|
|
|
* which sometimes leads to better prediction than from a
|
|
|
|
|
* single reference framer.
|
|
|
|
|
*/
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_build_2nd_inter16x16_predictors_mby(MACROBLOCKD *xd,
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *dst_y,
|
2012-08-09 02:12:12 +02:00
|
|
|
int dst_ystride) {
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *ptr;
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int_mv _16x16mv;
|
|
|
|
|
int mv_row;
|
|
|
|
|
int mv_col;
|
2012-03-13 18:26:53 +01:00
|
|
|
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *ptr_base = xd->second_pre.y_buffer;
|
2012-08-14 12:32:29 +02:00
|
|
|
int pre_stride = xd->block[0].pre_stride;
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
_16x16mv.as_int = xd->mode_info_context->mbmi.mv[1].as_int;
|
2012-03-13 18:26:53 +01:00
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
if (xd->mode_info_context->mbmi.need_to_clamp_secondmv)
|
|
|
|
|
clamp_mv_to_umv_border(&_16x16mv.as_mv, xd);
|
2012-03-13 18:26:53 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
mv_row = _16x16mv.as_mv.row;
|
|
|
|
|
mv_col = _16x16mv.as_mv.col;
|
2012-03-13 18:26:53 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
ptr = ptr_base + (mv_row >> 3) * pre_stride + (mv_col >> 3);
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
xd->subpix.predict[!!(mv_col & 7)][!!(mv_row & 7)][1](
|
|
|
|
|
ptr, pre_stride, dst_y, dst_ystride,
|
|
|
|
|
xd->subpix.filter_x[(mv_col & 7) << 1], xd->subpix.x_step_q4,
|
|
|
|
|
xd->subpix.filter_y[(mv_row & 7) << 1], xd->subpix.y_step_q4,
|
|
|
|
|
16, 16);
|
2012-08-09 02:12:12 +02:00
|
|
|
}
|
|
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_build_2nd_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *dst_u,
|
|
|
|
|
uint8_t *dst_v,
|
2012-08-09 02:12:12 +02:00
|
|
|
int dst_uvstride) {
|
|
|
|
|
int offset;
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *uptr, *vptr;
|
2012-08-09 02:12:12 +02:00
|
|
|
|
|
|
|
|
int_mv _16x16mv;
|
|
|
|
|
int mv_row;
|
|
|
|
|
int mv_col;
|
|
|
|
|
int omv_row, omv_col;
|
|
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
int pre_stride = xd->block[0].pre_stride;
|
2012-08-09 02:12:12 +02:00
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
_16x16mv.as_int = xd->mode_info_context->mbmi.mv[1].as_int;
|
2012-08-09 02:12:12 +02:00
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
if (xd->mode_info_context->mbmi.need_to_clamp_secondmv)
|
|
|
|
|
clamp_mv_to_umv_border(&_16x16mv.as_mv, xd);
|
2012-08-09 02:12:12 +02:00
|
|
|
|
|
|
|
|
mv_row = _16x16mv.as_mv.row;
|
|
|
|
|
mv_col = _16x16mv.as_mv.col;
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* calc uv motion vectors */
|
|
|
|
|
omv_row = mv_row;
|
|
|
|
|
omv_col = mv_col;
|
|
|
|
|
mv_row = (mv_row + (mv_row > 0)) >> 1;
|
|
|
|
|
mv_col = (mv_col + (mv_col > 0)) >> 1;
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
mv_row &= xd->fullpixel_mask;
|
|
|
|
|
mv_col &= xd->fullpixel_mask;
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pre_stride >>= 1;
|
|
|
|
|
offset = (mv_row >> 3) * pre_stride + (mv_col >> 3);
|
2012-08-14 12:32:29 +02:00
|
|
|
uptr = xd->second_pre.u_buffer + offset;
|
|
|
|
|
vptr = xd->second_pre.v_buffer + offset;
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
xd->subpix.predict[!!(omv_col & 15)][!!(omv_row & 15)][1](
|
|
|
|
|
uptr, pre_stride, dst_u, dst_uvstride,
|
|
|
|
|
xd->subpix.filter_x[omv_col & 15], xd->subpix.x_step_q4,
|
|
|
|
|
xd->subpix.filter_y[omv_row & 15], xd->subpix.y_step_q4,
|
|
|
|
|
8, 8);
|
|
|
|
|
|
|
|
|
|
xd->subpix.predict[!!(omv_col & 15)][!!(omv_row & 15)][1](
|
|
|
|
|
vptr, pre_stride, dst_v, dst_uvstride,
|
|
|
|
|
xd->subpix.filter_x[omv_col & 15], xd->subpix.x_step_q4,
|
|
|
|
|
xd->subpix.filter_y[omv_row & 15], xd->subpix.y_step_q4,
|
|
|
|
|
8, 8);
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
}
|
|
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_build_2nd_inter16x16_predictors_mb(MACROBLOCKD *xd,
|
2012-12-19 00:31:19 +01:00
|
|
|
uint8_t *dst_y,
|
|
|
|
|
uint8_t *dst_u,
|
|
|
|
|
uint8_t *dst_v,
|
2012-08-09 02:12:12 +02:00
|
|
|
int dst_ystride,
|
|
|
|
|
int dst_uvstride) {
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_build_2nd_inter16x16_predictors_mby(xd, dst_y, dst_ystride);
|
|
|
|
|
vp9_build_2nd_inter16x16_predictors_mbuv(xd, dst_u, dst_v, dst_uvstride);
|
2012-08-09 02:12:12 +02:00
|
|
|
}
|
|
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
static void build_inter4x4_predictors_mb(MACROBLOCKD *xd) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int i;
|
2012-08-14 12:32:29 +02:00
|
|
|
MB_MODE_INFO * mbmi = &xd->mode_info_context->mbmi;
|
|
|
|
|
BLOCKD *blockd = xd->block;
|
|
|
|
|
|
2012-10-22 20:25:48 +02:00
|
|
|
if (xd->mode_info_context->mbmi.partitioning != PARTITIONING_4X4) {
|
2012-08-14 12:32:29 +02:00
|
|
|
blockd[ 0].bmi = xd->mode_info_context->bmi[ 0];
|
|
|
|
|
blockd[ 2].bmi = xd->mode_info_context->bmi[ 2];
|
|
|
|
|
blockd[ 8].bmi = xd->mode_info_context->bmi[ 8];
|
|
|
|
|
blockd[10].bmi = xd->mode_info_context->bmi[10];
|
|
|
|
|
|
|
|
|
|
if (mbmi->need_to_clamp_mvs) {
|
2013-02-09 04:46:36 +01:00
|
|
|
clamp_mv_to_umv_border(&blockd[ 0].bmi.as_mv[0].as_mv, xd);
|
|
|
|
|
clamp_mv_to_umv_border(&blockd[ 2].bmi.as_mv[0].as_mv, xd);
|
|
|
|
|
clamp_mv_to_umv_border(&blockd[ 8].bmi.as_mv[0].as_mv, xd);
|
|
|
|
|
clamp_mv_to_umv_border(&blockd[10].bmi.as_mv[0].as_mv, xd);
|
2012-11-07 15:50:25 +01:00
|
|
|
if (mbmi->second_ref_frame > 0) {
|
2013-02-09 04:46:36 +01:00
|
|
|
clamp_mv_to_umv_border(&blockd[ 0].bmi.as_mv[1].as_mv, xd);
|
|
|
|
|
clamp_mv_to_umv_border(&blockd[ 2].bmi.as_mv[1].as_mv, xd);
|
|
|
|
|
clamp_mv_to_umv_border(&blockd[ 8].bmi.as_mv[1].as_mv, xd);
|
|
|
|
|
clamp_mv_to_umv_border(&blockd[10].bmi.as_mv[1].as_mv, xd);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
}
|
2012-02-01 23:27:50 +01:00
|
|
|
|
Improved coding using 8x8 transform
In summary, this commit encompasses a series of changes in attempt to
improve the 8x8 transform based coding to help overall compression
quality, please refer to the detailed commit history below for what
are the rationale underly the series of changes:
a. A frame level flag to indicate if 8x8 transform is used at all.
b. 8x8 transform is not used for key frames and small image size.
c. On inter coded frame, macroblocks using modes B_PRED, SPLIT_MV
and I8X8_PRED are forced to using 4x4 transform based coding, the
rest uses 8x8 transform based coding.
d. Encoder and decoder has the same assumption on the relationship
between prediction modes and transform size, therefore no signaling
is encoded in bitstream.
e. Mode decision process now calculate the rate and distortion scores
using their respective transforms.
Overall test results:
1. HD set
http://www.corp.google.com/~yaowu/no_crawl/t8x8/HD_t8x8_20120206.html
(avg psnr: 3.09% glb psnr: 3.22%, ssim: 3.90%)
2. Cif set:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif_t8x8_20120206.html
(avg psnr: -0.03%, glb psnr: -0.02%, ssim: -0.04%)
It should be noted here, as 8x8 transform coding itself is disabled
for cif size clips, the 0.03% loss is purely from the 1 bit/frame
flag overhead on if 8x8 transform is used or not for the frame.
---patch history for future reference---
Patch 1:
this commit tries to select transform size based on macroblock
prediction mode. If the size of a prediction mode is 16x16, then
the macroblock is forced to use 8x8 transform. If the prediction
mode is B_PRED, SPLITMV or I8X8_PRED, then the macroblock is forced
to use 4x4 transform. Tests on the following HD clips showed mixed
results: (all hd clips only used first 100 frames in the test)
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8.html
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8_log.html
while the results are mixed and overall negative, it is interesting to
see 8x8 helped a few of the clips.
Patch 2:
this patch tries to hard-wire selection of transform size based on
prediction modes without using segmentation to signal the transform size.
encoder and decoder both takes the same assumption that all macroblocks
use 8x8 transform except when prediciton mode is B_PRED, I8X8_PRED or
SPLITMV. Test results are as follows:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cifmodebase8x8_0125.html
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdmodebased8x8_0125log.html
Interestingly, by removing the overhead or coding the segmentation, the
results on this limited HD set have turn positive on average.
Patch 3:
this patch disabled the usage of 8x8 transform on key frames, and kept the
logic from patch 2 for inter frames only. test results on HD set turned
decidedly positive with 8x8 transform enabled on inter frame with 16x16
prediction modes: (avg psnr: .81% glb psnr: .82 ssim: .55%)
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hdintermode8x8_0125.html
results on cif set still negative overall
Patch 4:
continued from last patch, but now in mode decision process, the rate and
distortion estimates are computed based on 8x8 transform results for MBs
with modes associated with 8x8 transform. This patch also fixed a problem
related to segment based eob coding when 8x8 transform is used. The patch
significantly improved the results on HD clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/hd8x8RDintermode.html
(avg psnr: 2.70% glb psnr: 2.76% ssim: 3.34%)
results on cif also improved, though they are still negative compared to
baseline that uses 4x4 transform only:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif8x8RDintermode.html
(avg psnr: -.78% glb psnr: -.86% ssim: -.19%)
Patch 5:
This patch does 3 things:
a. a bunch of decoder bug fixes, encodings and decodings were verified
to have matched recon buffer on a number of encodes on cif size mobile and
hd version of _pedestrian.
b. the patch further improved the rate distortion calculation of MBS that
use 8x8 transform. This provided some further gain on compression.
c. the patch also got the experimental work SEG_LVL_EOB to work with 8x8
transformed macroblock, test results indicates it improves the cif set
but hurt the HD set slightly.
Tests results on HD clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/HD_t8x8_20120201.html
(avg psnr: 3.19% glb psnr: 3.30% ssim: 3.93%)
Test results on cif clips:
http://www.corp.google.com/~yaowu/no_crawl/t8x8/cif_t8x8_20120201.html
(avg psnr: -.47% glb psnr: -.51% ssim: +.28%)
Patch 6:
Added a frame level flag to indicate if 8x8 transform is allowed at all.
temporarily the decision is based on frame size, can be optimized later
one. This get the cif results to basically unchanged, with one bit per
frame overhead on both cif and hd clips.
Patch 8:
Rebase and Merge to head by PGW.
Fixed some suspect 4s that look like hey should be 64s in regard
to segmented EOB. Perhaps #defines would be bette.
Bulit and tested without T8x8 enabled and produces unchanged
output.
Patch 9:
Corrected misalligned code/decode of "txfm_mode" bit.
Limited testing for correct encode and decode with
T8x8 configured on derf clips.
Change-Id: I156e1405d25f81579d579dff8ab9af53944ec49c
2012-02-10 01:12:23 +01:00
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_build_inter_predictors4b(xd, &blockd[ 0], 16);
|
|
|
|
|
vp9_build_inter_predictors4b(xd, &blockd[ 2], 16);
|
|
|
|
|
vp9_build_inter_predictors4b(xd, &blockd[ 8], 16);
|
|
|
|
|
vp9_build_inter_predictors4b(xd, &blockd[10], 16);
|
2012-04-18 22:51:58 +02:00
|
|
|
|
2012-11-07 15:50:25 +01:00
|
|
|
if (mbmi->second_ref_frame > 0) {
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_build_2nd_inter_predictors4b(xd, &blockd[ 0], 16);
|
|
|
|
|
vp9_build_2nd_inter_predictors4b(xd, &blockd[ 2], 16);
|
|
|
|
|
vp9_build_2nd_inter_predictors4b(xd, &blockd[ 8], 16);
|
|
|
|
|
vp9_build_2nd_inter_predictors4b(xd, &blockd[10], 16);
|
2011-04-28 16:53:59 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
|
|
|
|
for (i = 0; i < 16; i += 2) {
|
2012-08-14 12:32:29 +02:00
|
|
|
BLOCKD *d0 = &blockd[i];
|
|
|
|
|
BLOCKD *d1 = &blockd[i + 1];
|
|
|
|
|
|
|
|
|
|
blockd[i + 0].bmi = xd->mode_info_context->bmi[i + 0];
|
|
|
|
|
blockd[i + 1].bmi = xd->mode_info_context->bmi[i + 1];
|
|
|
|
|
|
|
|
|
|
if (mbmi->need_to_clamp_mvs) {
|
2013-02-09 04:46:36 +01:00
|
|
|
clamp_mv_to_umv_border(&blockd[i + 0].bmi.as_mv[0].as_mv, xd);
|
|
|
|
|
clamp_mv_to_umv_border(&blockd[i + 1].bmi.as_mv[0].as_mv, xd);
|
2012-11-07 15:50:25 +01:00
|
|
|
if (mbmi->second_ref_frame > 0) {
|
2013-02-09 04:46:36 +01:00
|
|
|
clamp_mv_to_umv_border(&blockd[i + 0].bmi.as_mv[1].as_mv, xd);
|
|
|
|
|
clamp_mv_to_umv_border(&blockd[i + 1].bmi.as_mv[1].as_mv, xd);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
if (d0->bmi.as_mv[0].as_int == d1->bmi.as_mv[0].as_int)
|
2012-08-14 12:32:29 +02:00
|
|
|
build_inter_predictors2b(xd, d0, 16);
|
2012-07-14 00:21:29 +02:00
|
|
|
else {
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
vp9_build_inter_predictors_b(d0, 16, &xd->subpix);
|
|
|
|
|
vp9_build_inter_predictors_b(d1, 16, &xd->subpix);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
2012-11-07 15:50:25 +01:00
|
|
|
if (mbmi->second_ref_frame > 0) {
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
vp9_build_2nd_inter_predictors_b(d0, 16, &xd->subpix);
|
|
|
|
|
vp9_build_2nd_inter_predictors_b(d1, 16, &xd->subpix);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-04-28 16:53:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (i = 16; i < 24; i += 2) {
|
2012-08-14 12:32:29 +02:00
|
|
|
BLOCKD *d0 = &blockd[i];
|
|
|
|
|
BLOCKD *d1 = &blockd[i + 1];
|
2012-04-18 22:51:58 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
if (d0->bmi.as_mv[0].as_int == d1->bmi.as_mv[0].as_int)
|
2012-08-14 12:32:29 +02:00
|
|
|
build_inter_predictors2b(xd, d0, 8);
|
2012-07-14 00:21:29 +02:00
|
|
|
else {
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
vp9_build_inter_predictors_b(d0, 8, &xd->subpix);
|
|
|
|
|
vp9_build_inter_predictors_b(d1, 8, &xd->subpix);
|
2011-04-28 16:53:59 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-11-07 15:50:25 +01:00
|
|
|
if (mbmi->second_ref_frame > 0) {
|
Convert subpixel filters to use convolve framework
Update the code to call the new convolution functions to do subpixel
prediction rather than the existing functions. Remove the old C and
assembly code, since it is unused. This causes a 50% performance
reduction on the decoder, but that will be resolved when the asm for
the new functions is available.
There is no consensus for whether 6-tap or 2-tap predictors will be
supported in the final codec, so these filters are implemented in
terms of the 8-tap code, so that quality testing of these modes
can continue. Implementing the lower complexity algorithms is a
simple exercise, should it be necessary.
This code produces slightly better results in the EIGHTTAP_SMOOTH
case, since the filter is now applied in only one direction when
the subpel motion is only in one direction. Like the previous code,
the filtering is skipped entirely on full-pel MVs. This combination
seems to give the best quality gains, but this may be indicative of a
bug in the encoder's filter selection, since the encoder could
achieve the result of skipping the filtering on full-pel by selecting
one of the other filters. This should be revisited.
Quality gains on derf positive on almost all clips. The only clip
that seemed to be hurt at all datarates was football
(-0.115% PSNR average, -0.587% min). Overall averages 0.375% PSNR,
0.347% SSIM.
Change-Id: I7d469716091b1d89b4b08adde5863999319d69ff
2013-01-29 01:59:03 +01:00
|
|
|
vp9_build_2nd_inter_predictors_b(d0, 8, &xd->subpix);
|
|
|
|
|
vp9_build_2nd_inter_predictors_b(d1, 8, &xd->subpix);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
}
|
2011-04-28 16:53:59 +02:00
|
|
|
}
|
|
|
|
|
|
2011-08-24 20:42:26 +02:00
|
|
|
static
|
2012-08-14 12:32:29 +02:00
|
|
|
void build_4x4uvmvs(MACROBLOCKD *xd) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int i, j;
|
2012-08-14 12:32:29 +02:00
|
|
|
BLOCKD *blockd = xd->block;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
|
for (j = 0; j < 2; j++) {
|
|
|
|
|
int yoffset = i * 8 + j * 2;
|
|
|
|
|
int uoffset = 16 + i * 2 + j;
|
|
|
|
|
int voffset = 20 + i * 2 + j;
|
|
|
|
|
|
|
|
|
|
int temp;
|
|
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
temp = xd->mode_info_context->bmi[yoffset + 0].as_mv[0].as_mv.row
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 1].as_mv[0].as_mv.row
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 4].as_mv[0].as_mv.row
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 5].as_mv[0].as_mv.row;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
if (temp < 0) temp -= 4;
|
|
|
|
|
else temp += 4;
|
|
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
blockd[uoffset].bmi.as_mv[0].as_mv.row = (temp / 8) &
|
2012-08-14 12:32:29 +02:00
|
|
|
xd->fullpixel_mask;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
temp = xd->mode_info_context->bmi[yoffset + 0].as_mv[0].as_mv.col
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 1].as_mv[0].as_mv.col
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 4].as_mv[0].as_mv.col
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 5].as_mv[0].as_mv.col;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
if (temp < 0) temp -= 4;
|
|
|
|
|
else temp += 4;
|
|
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
blockd[uoffset].bmi.as_mv[0].as_mv.col = (temp / 8) &
|
2012-08-14 12:32:29 +02:00
|
|
|
xd->fullpixel_mask;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
// if (x->mode_info_context->mbmi.need_to_clamp_mvs)
|
2013-02-09 04:46:36 +01:00
|
|
|
clamp_uvmv_to_umv_border(&blockd[uoffset].bmi.as_mv[0].as_mv, xd);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
// if (x->mode_info_context->mbmi.need_to_clamp_mvs)
|
2013-02-09 04:46:36 +01:00
|
|
|
clamp_uvmv_to_umv_border(&blockd[uoffset].bmi.as_mv[0].as_mv, xd);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
blockd[voffset].bmi.as_mv[0].as_mv.row =
|
|
|
|
|
blockd[uoffset].bmi.as_mv[0].as_mv.row;
|
|
|
|
|
blockd[voffset].bmi.as_mv[0].as_mv.col =
|
|
|
|
|
blockd[uoffset].bmi.as_mv[0].as_mv.col;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-11-07 15:50:25 +01:00
|
|
|
if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
|
2013-02-09 04:46:36 +01:00
|
|
|
temp = xd->mode_info_context->bmi[yoffset + 0].as_mv[1].as_mv.row
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 1].as_mv[1].as_mv.row
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 4].as_mv[1].as_mv.row
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 5].as_mv[1].as_mv.row;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
if (temp < 0) {
|
|
|
|
|
temp -= 4;
|
|
|
|
|
} else {
|
|
|
|
|
temp += 4;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2011-08-24 20:42:26 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
blockd[uoffset].bmi.as_mv[1].as_mv.row = (temp / 8) &
|
2012-08-14 12:32:29 +02:00
|
|
|
xd->fullpixel_mask;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
temp = xd->mode_info_context->bmi[yoffset + 0].as_mv[1].as_mv.col
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 1].as_mv[1].as_mv.col
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 4].as_mv[1].as_mv.col
|
|
|
|
|
+ xd->mode_info_context->bmi[yoffset + 5].as_mv[1].as_mv.col;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
|
if (temp < 0) {
|
|
|
|
|
temp -= 4;
|
|
|
|
|
} else {
|
|
|
|
|
temp += 4;
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
blockd[uoffset].bmi.as_mv[1].as_mv.col = (temp / 8) &
|
2012-08-14 12:32:29 +02:00
|
|
|
xd->fullpixel_mask;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
// if (mbmi->need_to_clamp_mvs)
|
|
|
|
|
clamp_uvmv_to_umv_border(
|
2013-02-09 04:46:36 +01:00
|
|
|
&blockd[uoffset].bmi.as_mv[1].as_mv, xd);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-08-14 12:32:29 +02:00
|
|
|
// if (mbmi->need_to_clamp_mvs)
|
|
|
|
|
clamp_uvmv_to_umv_border(
|
2013-02-09 04:46:36 +01:00
|
|
|
&blockd[uoffset].bmi.as_mv[1].as_mv, xd);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-02-09 04:46:36 +01:00
|
|
|
blockd[voffset].bmi.as_mv[1].as_mv.row =
|
|
|
|
|
blockd[uoffset].bmi.as_mv[1].as_mv.row;
|
|
|
|
|
blockd[voffset].bmi.as_mv[1].as_mv.col =
|
|
|
|
|
blockd[uoffset].bmi.as_mv[1].as_mv.col;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-08-24 20:42:26 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
void vp9_build_inter_predictors_mb(MACROBLOCKD *xd) {
|
2012-08-14 12:32:29 +02:00
|
|
|
if (xd->mode_info_context->mbmi.mode != SPLITMV) {
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_build_1st_inter16x16_predictors_mb(xd, xd->predictor,
|
2012-08-14 12:32:29 +02:00
|
|
|
&xd->predictor[256],
|
|
|
|
|
&xd->predictor[320], 16, 8);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-11-07 15:50:25 +01:00
|
|
|
if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
|
2012-07-14 00:21:29 +02:00
|
|
|
/* 256 = offset of U plane in Y+U+V buffer;
|
|
|
|
|
* 320 = offset of V plane in Y+U+V buffer.
|
|
|
|
|
* (256=16x16, 320=16x16+8x8). */
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_build_2nd_inter16x16_predictors_mb(xd, xd->predictor,
|
2012-08-14 12:32:29 +02:00
|
|
|
&xd->predictor[256],
|
|
|
|
|
&xd->predictor[320], 16, 8);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-11-07 15:50:25 +01:00
|
|
|
#if CONFIG_COMP_INTERINTRA_PRED
|
|
|
|
|
else if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
|
|
|
|
|
vp9_build_interintra_16x16_predictors_mb(xd, xd->predictor,
|
|
|
|
|
&xd->predictor[256],
|
|
|
|
|
&xd->predictor[320], 16, 8);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
2012-08-14 12:32:29 +02:00
|
|
|
build_4x4uvmvs(xd);
|
|
|
|
|
build_inter4x4_predictors_mb(xd);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|