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
|
|
|
*/
|
|
|
|
|
2012-12-23 16:20:10 +01:00
|
|
|
#include "./vpx_config.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/encoder/vp9_encodemb.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_reconinter.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/encoder/vp9_quantize.h"
|
|
|
|
#include "vp9/encoder/vp9_tokenize.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_invtrans.h"
|
|
|
|
#include "vp9/common/vp9_reconintra.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "vpx_mem/vpx_mem.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/encoder/vp9_rdopt.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_systemdependent.h"
|
2012-11-09 02:09:30 +01:00
|
|
|
#include "vp9_rtcd.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
void vp9_subtract_block(int rows, int cols,
|
|
|
|
int16_t *diff_ptr, int diff_stride,
|
|
|
|
const uint8_t *src_ptr, int src_stride,
|
|
|
|
const uint8_t *pred_ptr, int pred_stride) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int r, c;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
for (r = 0; r < rows; r++) {
|
|
|
|
for (c = 0; c < cols; c++)
|
2012-07-14 00:21:29 +02:00
|
|
|
diff_ptr[c] = src_ptr[c] - pred_ptr[c];
|
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
diff_ptr += diff_stride;
|
|
|
|
pred_ptr += pred_stride;
|
2012-07-14 00:21:29 +02:00
|
|
|
src_ptr += src_stride;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-10-13 17:15:51 +02:00
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
static void subtract_plane(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize, int plane) {
|
|
|
|
const MACROBLOCKD * const xd = &x->e_mbd;
|
|
|
|
const int bw = 4 << (b_width_log2(bsize) - xd->plane[plane].subsampling_x);
|
|
|
|
const int bh = 4 << (b_height_log2(bsize) - xd->plane[plane].subsampling_y);
|
2013-04-24 01:22:47 +02:00
|
|
|
const uint8_t *src = x->plane[plane].src.buf;
|
|
|
|
const int src_stride = x->plane[plane].src.stride;
|
2013-02-28 22:18:02 +01:00
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
assert(plane < 3);
|
|
|
|
vp9_subtract_block(bh, bw,
|
|
|
|
x->plane[plane].src_diff, bw, src, src_stride,
|
|
|
|
xd->plane[plane].dst.buf, xd->plane[plane].dst.stride);
|
2011-08-05 01:30:27 +02:00
|
|
|
}
|
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
void vp9_subtract_sby(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
|
|
|
|
subtract_plane(x, bsize, 0);
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
}
|
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
void vp9_subtract_sbuv(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
|
|
|
|
int i;
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
for (i = 1; i < MAX_MB_PLANE; i++)
|
|
|
|
subtract_plane(x, bsize, i);
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
void vp9_subtract_sb(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
|
|
|
|
vp9_subtract_sby(x, bsize);
|
|
|
|
vp9_subtract_sbuv(x, bsize);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_transform_sby_32x32(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize) - 3, bw = 1 << bwl;
|
|
|
|
const int bh = 1 << (b_height_log2(bsize) - 3);
|
2013-04-10 06:28:27 +02:00
|
|
|
const int stride = 32 << bwl;
|
2013-03-04 23:12:17 +01:00
|
|
|
int n;
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
vp9_short_fdct32x32(x->plane[0].src_diff + y_idx * stride * 32 + x_idx * 32,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[0].coeff + n * 1024, stride * 2);
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_transform_sby_16x16(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize) - 2, bw = 1 << bwl;
|
|
|
|
const int bh = 1 << (b_height_log2(bsize) - 2);
|
2013-04-10 06:28:27 +02:00
|
|
|
const int stride = 16 << bwl, bstride = 4 << bwl;
|
2013-03-06 00:18:06 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2013-03-04 23:12:17 +01:00
|
|
|
int n;
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
|
|
|
|
const TX_TYPE tx_type = get_tx_type_16x16(xd,
|
|
|
|
(y_idx * bstride + x_idx) * 4);
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-03-06 00:18:06 +01:00
|
|
|
if (tx_type != DCT_DCT) {
|
2013-04-23 17:26:10 +02:00
|
|
|
vp9_short_fht16x16(x->plane[0].src_diff +
|
|
|
|
y_idx * stride * 16 + x_idx * 16,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[0].coeff + n * 256, stride, tx_type);
|
2013-03-06 00:18:06 +01:00
|
|
|
} else {
|
2013-04-23 17:26:10 +02:00
|
|
|
x->fwd_txm16x16(x->plane[0].src_diff + y_idx * stride * 16 + x_idx * 16,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[0].coeff + n * 256, stride * 2);
|
2013-03-06 00:18:06 +01:00
|
|
|
}
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_transform_sby_8x8(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize) - 1, bw = 1 << bwl;
|
|
|
|
const int bh = 1 << (b_height_log2(bsize) - 1);
|
2013-04-10 06:28:27 +02:00
|
|
|
const int stride = 8 << bwl, bstride = 2 << bwl;
|
2013-03-06 00:18:06 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2013-03-04 23:12:17 +01:00
|
|
|
int n;
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
|
|
|
|
const TX_TYPE tx_type = get_tx_type_8x8(xd, (y_idx * bstride + x_idx) * 2);
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-03-06 00:18:06 +01:00
|
|
|
if (tx_type != DCT_DCT) {
|
2013-04-23 17:26:10 +02:00
|
|
|
vp9_short_fht8x8(x->plane[0].src_diff + y_idx * stride * 8 + x_idx * 8,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[0].coeff + n * 64, stride, tx_type);
|
2013-03-06 00:18:06 +01:00
|
|
|
} else {
|
2013-04-23 17:26:10 +02:00
|
|
|
x->fwd_txm8x8(x->plane[0].src_diff + y_idx * stride * 8 + x_idx * 8,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[0].coeff + n * 64, stride * 2);
|
2013-03-06 00:18:06 +01:00
|
|
|
}
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_transform_sby_4x4(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize), bw = 1 << bwl;
|
|
|
|
const int bh = 1 << b_height_log2(bsize);
|
2013-04-10 06:28:27 +02:00
|
|
|
const int stride = 4 << bwl;
|
2013-03-06 00:18:06 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2013-03-04 23:12:17 +01:00
|
|
|
int n;
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
|
|
|
|
const TX_TYPE tx_type = get_tx_type_4x4(xd, n);
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-03-06 00:18:06 +01:00
|
|
|
if (tx_type != DCT_DCT) {
|
2013-04-23 17:26:10 +02:00
|
|
|
vp9_short_fht4x4(x->plane[0].src_diff + y_idx * stride * 4 + x_idx * 4,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[0].coeff + n * 16, stride, tx_type);
|
2013-03-06 00:18:06 +01:00
|
|
|
} else {
|
2013-04-23 17:26:10 +02:00
|
|
|
x->fwd_txm4x4(x->plane[0].src_diff + y_idx * stride * 4 + x_idx * 4,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[0].coeff + n * 16, stride * 2);
|
2013-03-06 00:18:06 +01:00
|
|
|
}
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_transform_sbuv_32x32(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
|
|
|
|
assert(bsize == BLOCK_SIZE_SB64X64);
|
2013-03-04 23:12:17 +01:00
|
|
|
vp9_clear_system_state();
|
2013-04-23 18:51:09 +02:00
|
|
|
vp9_short_fdct32x32(x->plane[1].src_diff, x->plane[1].coeff, 64);
|
|
|
|
vp9_short_fdct32x32(x->plane[2].src_diff, x->plane[2].coeff, 64);
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_transform_sbuv_16x16(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize) - 2, bhl = b_height_log2(bsize) - 2;
|
2013-04-10 06:28:27 +02:00
|
|
|
const int bw = 1 << (bwl - 1), bh = 1 << (bhl - 1);
|
|
|
|
const int stride = 16 << (bwl - 1);
|
2013-03-04 23:12:17 +01:00
|
|
|
int n;
|
|
|
|
|
|
|
|
vp9_clear_system_state();
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> (bwl - 1);
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
x->fwd_txm16x16(x->plane[1].src_diff + y_idx * stride * 16 + x_idx * 16,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[1].coeff + n * 256, stride * 2);
|
2013-04-23 17:26:10 +02:00
|
|
|
x->fwd_txm16x16(x->plane[2].src_diff + y_idx * stride * 16 + x_idx * 16,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[2].coeff + n * 256, stride * 2);
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_transform_sbuv_8x8(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize) - 1, bhl = b_height_log2(bsize) - 1;
|
2013-04-10 06:28:27 +02:00
|
|
|
const int bw = 1 << (bwl - 1), bh = 1 << (bhl - 1);
|
|
|
|
const int stride = 8 << (bwl - 1);
|
2013-03-04 23:12:17 +01:00
|
|
|
int n;
|
|
|
|
|
|
|
|
vp9_clear_system_state();
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> (bwl - 1);
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
x->fwd_txm8x8(x->plane[1].src_diff + y_idx * stride * 8 + x_idx * 8,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[1].coeff + n * 64, stride * 2);
|
2013-04-23 17:26:10 +02:00
|
|
|
x->fwd_txm8x8(x->plane[2].src_diff + y_idx * stride * 8 + x_idx * 8,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[2].coeff + n * 64, stride * 2);
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_transform_sbuv_4x4(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
|
2013-04-10 06:28:27 +02:00
|
|
|
const int bw = 1 << (bwl - 1), bh = 1 << (bhl - 1);
|
|
|
|
const int stride = 4 << (bwl - 1);
|
2013-03-04 23:12:17 +01:00
|
|
|
int n;
|
|
|
|
|
|
|
|
vp9_clear_system_state();
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> (bwl - 1);
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-04-23 17:26:10 +02:00
|
|
|
x->fwd_txm4x4(x->plane[1].src_diff + y_idx * stride * 4 + x_idx * 4,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[1].coeff + n * 16, stride * 2);
|
2013-04-23 17:26:10 +02:00
|
|
|
x->fwd_txm4x4(x->plane[2].src_diff + y_idx * stride * 4 + x_idx * 4,
|
2013-04-23 18:51:09 +02:00
|
|
|
x->plane[2].coeff + n * 16, stride * 2);
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
}
|
|
|
|
|
2011-02-14 23:18:18 +01:00
|
|
|
#define RDTRUNC(RM,DM,R,D) ( (128+(R)*(RM)) & 0xFF )
|
|
|
|
#define RDTRUNC_8x8(RM,DM,R,D) ( (128+(R)*(RM)) & 0xFF )
|
2012-10-31 22:40:53 +01:00
|
|
|
typedef struct vp9_token_state vp9_token_state;
|
Add trellis quantization.
Replace the exponential search for optimal rounding during
quantization with a linear Viterbi trellis and enable it
by default when using --best.
Right now this operates on top of the output of the adaptive
zero-bin quantizer in vp8_regular_quantize_b() and gives a small
gain.
It can be tested as a replacement for that quantizer by
enabling the call to vp8_strict_quantize_b(), which uses
normal rounding and no zero bin offset.
Ultimately, the quantizer will have to become a function of lambda
in order to take advantage of activity masking, since there is
limited ability to change the quantization factor itself.
However, currently vp8_strict_quantize_b() plus the trellis
quantizer (which is lambda-dependent) loses to
vp8_regular_quantize_b() alone (which is not) on my test clip.
Patch Set 3:
Fix an issue related to the cost evaluation of successor
states when a coefficient is reduced to zero. With this
issue fixed, now the trellis search almost exactly matches
the exponential search.
Patch Set 2:
Overall, the goal of this patch set is to make "trellis"
search to produce encodings that match the exponential
search version. There are three main differences between
Patch Set 2 and 1:
a. Patch set 1 did not properly account for the scale of
2nd order error, so patch set 2 disable it all together
for 2nd blocks.
b. Patch set 1 was not consistent on when to enable the
the quantization optimization. Patch set 2 restore the
condition to be consistent.
c. Patch set 1 checks quantized level L-1, and L for any
input coefficient was quantized to L. Patch set 2 limits
the candidate coefficient to those that were rounded up
to L. It is worth noting here that a strategy to check
L and L+1 for coefficients that were truncated down to L
might work.
(a and b get trellis quant to basically match the exponential
search on all mid/low rate encodings on cif set, without
a, b, trellis quant can hurt the psnr by 0.2 to .3db at
200kbps for some cif clips)
(c gets trellis quant to match the exponential search
to match at Q0 encoding, without c, trellis quant can be
1.5 to 2db lower for encodings with fixed Q at 0 on most
derf cif clips)
Change-Id: Ib1a043b665d75fbf00cb0257b7c18e90eebab95e
2010-07-02 23:35:53 +02:00
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
struct vp9_token_state {
|
Add trellis quantization.
Replace the exponential search for optimal rounding during
quantization with a linear Viterbi trellis and enable it
by default when using --best.
Right now this operates on top of the output of the adaptive
zero-bin quantizer in vp8_regular_quantize_b() and gives a small
gain.
It can be tested as a replacement for that quantizer by
enabling the call to vp8_strict_quantize_b(), which uses
normal rounding and no zero bin offset.
Ultimately, the quantizer will have to become a function of lambda
in order to take advantage of activity masking, since there is
limited ability to change the quantization factor itself.
However, currently vp8_strict_quantize_b() plus the trellis
quantizer (which is lambda-dependent) loses to
vp8_regular_quantize_b() alone (which is not) on my test clip.
Patch Set 3:
Fix an issue related to the cost evaluation of successor
states when a coefficient is reduced to zero. With this
issue fixed, now the trellis search almost exactly matches
the exponential search.
Patch Set 2:
Overall, the goal of this patch set is to make "trellis"
search to produce encodings that match the exponential
search version. There are three main differences between
Patch Set 2 and 1:
a. Patch set 1 did not properly account for the scale of
2nd order error, so patch set 2 disable it all together
for 2nd blocks.
b. Patch set 1 was not consistent on when to enable the
the quantization optimization. Patch set 2 restore the
condition to be consistent.
c. Patch set 1 checks quantized level L-1, and L for any
input coefficient was quantized to L. Patch set 2 limits
the candidate coefficient to those that were rounded up
to L. It is worth noting here that a strategy to check
L and L+1 for coefficients that were truncated down to L
might work.
(a and b get trellis quant to basically match the exponential
search on all mid/low rate encodings on cif set, without
a, b, trellis quant can hurt the psnr by 0.2 to .3db at
200kbps for some cif clips)
(c gets trellis quant to match the exponential search
to match at Q0 encoding, without c, trellis quant can be
1.5 to 2db lower for encodings with fixed Q at 0 on most
derf cif clips)
Change-Id: Ib1a043b665d75fbf00cb0257b7c18e90eebab95e
2010-07-02 23:35:53 +02:00
|
|
|
int rate;
|
|
|
|
int error;
|
2012-08-03 02:03:14 +02:00
|
|
|
int next;
|
Add trellis quantization.
Replace the exponential search for optimal rounding during
quantization with a linear Viterbi trellis and enable it
by default when using --best.
Right now this operates on top of the output of the adaptive
zero-bin quantizer in vp8_regular_quantize_b() and gives a small
gain.
It can be tested as a replacement for that quantizer by
enabling the call to vp8_strict_quantize_b(), which uses
normal rounding and no zero bin offset.
Ultimately, the quantizer will have to become a function of lambda
in order to take advantage of activity masking, since there is
limited ability to change the quantization factor itself.
However, currently vp8_strict_quantize_b() plus the trellis
quantizer (which is lambda-dependent) loses to
vp8_regular_quantize_b() alone (which is not) on my test clip.
Patch Set 3:
Fix an issue related to the cost evaluation of successor
states when a coefficient is reduced to zero. With this
issue fixed, now the trellis search almost exactly matches
the exponential search.
Patch Set 2:
Overall, the goal of this patch set is to make "trellis"
search to produce encodings that match the exponential
search version. There are three main differences between
Patch Set 2 and 1:
a. Patch set 1 did not properly account for the scale of
2nd order error, so patch set 2 disable it all together
for 2nd blocks.
b. Patch set 1 was not consistent on when to enable the
the quantization optimization. Patch set 2 restore the
condition to be consistent.
c. Patch set 1 checks quantized level L-1, and L for any
input coefficient was quantized to L. Patch set 2 limits
the candidate coefficient to those that were rounded up
to L. It is worth noting here that a strategy to check
L and L+1 for coefficients that were truncated down to L
might work.
(a and b get trellis quant to basically match the exponential
search on all mid/low rate encodings on cif set, without
a, b, trellis quant can hurt the psnr by 0.2 to .3db at
200kbps for some cif clips)
(c gets trellis quant to match the exponential search
to match at Q0 encoding, without c, trellis quant can be
1.5 to 2db lower for encodings with fixed Q at 0 on most
derf cif clips)
Change-Id: Ib1a043b665d75fbf00cb0257b7c18e90eebab95e
2010-07-02 23:35:53 +02:00
|
|
|
signed char token;
|
|
|
|
short qc;
|
|
|
|
};
|
|
|
|
|
2010-10-01 05:41:37 +02:00
|
|
|
// TODO: experiments to find optimal multiple numbers
|
2010-12-06 22:33:01 +01:00
|
|
|
#define Y1_RD_MULT 4
|
|
|
|
#define UV_RD_MULT 2
|
2010-10-01 05:41:37 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static const int plane_rd_mult[4] = {
|
|
|
|
Y1_RD_MULT,
|
|
|
|
UV_RD_MULT,
|
2010-10-01 05:41:37 +02:00
|
|
|
};
|
|
|
|
|
2012-08-11 00:34:31 +02:00
|
|
|
#define UPDATE_RD_COST()\
|
|
|
|
{\
|
|
|
|
rd_cost0 = RDCOST(rdmult, rddiv, rate0, error0);\
|
|
|
|
rd_cost1 = RDCOST(rdmult, rddiv, rate1, error1);\
|
|
|
|
if (rd_cost0 == rd_cost1) {\
|
|
|
|
rd_cost0 = RDTRUNC(rdmult, rddiv, rate0, error0);\
|
|
|
|
rd_cost1 = RDTRUNC(rdmult, rddiv, rate1, error1);\
|
|
|
|
}\
|
|
|
|
}
|
|
|
|
|
2013-02-11 20:19:21 +01:00
|
|
|
// This function is a place holder for now but may ultimately need
|
|
|
|
// to scan previous tokens to work out the correct context.
|
2013-03-27 00:46:09 +01:00
|
|
|
static int trellis_get_coeff_context(const int *scan,
|
|
|
|
const int *nb,
|
|
|
|
int idx, int token,
|
|
|
|
uint8_t *token_cache,
|
|
|
|
int pad, int l) {
|
2013-03-28 18:42:23 +01:00
|
|
|
int bak = token_cache[scan[idx]], pt;
|
|
|
|
token_cache[scan[idx]] = token;
|
2013-03-27 00:46:09 +01:00
|
|
|
pt = vp9_get_coef_context(scan, nb, pad, token_cache, idx + 1, l);
|
2013-03-28 18:42:23 +01:00
|
|
|
token_cache[scan[idx]] = bak;
|
2013-03-27 00:46:09 +01:00
|
|
|
return pt;
|
2013-02-11 20:19:21 +01:00
|
|
|
}
|
|
|
|
|
2013-02-20 19:16:24 +01:00
|
|
|
static void optimize_b(VP9_COMMON *const cm,
|
|
|
|
MACROBLOCK *mb, int ib, PLANE_TYPE type,
|
2013-03-04 23:12:17 +01:00
|
|
|
const int16_t *dequant_ptr,
|
2012-10-30 05:02:36 +01:00
|
|
|
ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
|
2013-04-04 21:03:27 +02:00
|
|
|
int tx_size, int y_blocks) {
|
2013-02-19 22:36:38 +01:00
|
|
|
const int ref = mb->e_mbd.mode_info_context->mbmi.ref_frame != INTRA_FRAME;
|
2013-02-27 19:00:24 +01:00
|
|
|
MACROBLOCKD *const xd = &mb->e_mbd;
|
2013-03-04 23:12:17 +01:00
|
|
|
vp9_token_state tokens[1025][2];
|
|
|
|
unsigned best_index[1025][2];
|
2013-04-04 21:03:27 +02:00
|
|
|
const struct plane_block_idx pb_idx = plane_block_idx(y_blocks, ib);
|
2013-04-23 18:51:09 +02:00
|
|
|
const int16_t *coeff_ptr = BLOCK_OFFSET(mb->plane[pb_idx.plane].coeff,
|
|
|
|
pb_idx.block, 16);
|
2013-04-02 23:50:40 +02:00
|
|
|
int16_t *qcoeff_ptr;
|
|
|
|
int16_t *dqcoeff_ptr;
|
2013-04-04 21:03:27 +02:00
|
|
|
int eob = xd->plane[pb_idx.plane].eobs[pb_idx.block], final_eob, sz = 0;
|
2013-02-15 19:15:42 +01:00
|
|
|
const int i0 = 0;
|
2013-03-04 23:12:17 +01:00
|
|
|
int rc, x, next, i;
|
2012-12-03 23:53:45 +01:00
|
|
|
int64_t rdmult, rddiv, rd_cost0, rd_cost1;
|
|
|
|
int rate0, rate1, error0, error1, t0, t1;
|
|
|
|
int best, band, pt;
|
2012-07-14 00:21:29 +02:00
|
|
|
int err_mult = plane_rd_mult[type];
|
2013-03-27 00:46:09 +01:00
|
|
|
int default_eob, pad;
|
|
|
|
int const *scan, *nb;
|
2013-03-04 23:12:17 +01:00
|
|
|
const int mul = 1 + (tx_size == TX_32X32);
|
2013-03-27 00:46:09 +01:00
|
|
|
uint8_t token_cache[1024];
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-04-04 21:03:27 +02:00
|
|
|
assert((!type && !pb_idx.plane) || (type && pb_idx.plane));
|
2013-04-02 23:50:40 +02:00
|
|
|
dqcoeff_ptr = BLOCK_OFFSET(xd->plane[pb_idx.plane].dqcoeff, pb_idx.block, 16);
|
|
|
|
qcoeff_ptr = BLOCK_OFFSET(xd->plane[pb_idx.plane].qcoeff, pb_idx.block, 16);
|
2012-10-16 01:41:41 +02:00
|
|
|
switch (tx_size) {
|
2012-08-11 00:34:31 +02:00
|
|
|
default:
|
2013-03-06 00:18:06 +01:00
|
|
|
case TX_4X4: {
|
|
|
|
const TX_TYPE tx_type = get_tx_type_4x4(xd, ib);
|
2012-08-11 00:34:31 +02:00
|
|
|
default_eob = 16;
|
2013-04-22 23:08:41 +02:00
|
|
|
scan = get_scan_4x4(tx_type);
|
2012-08-11 00:34:31 +02:00
|
|
|
break;
|
2013-03-06 00:18:06 +01:00
|
|
|
}
|
2013-03-25 20:30:00 +01:00
|
|
|
case TX_8X8: {
|
|
|
|
const BLOCK_SIZE_TYPE sb_type = xd->mode_info_context->mbmi.sb_type;
|
2013-04-24 18:18:16 +02:00
|
|
|
const int sz = 1 + b_width_log2(sb_type);
|
2013-04-11 01:50:01 +02:00
|
|
|
const int x = ib & ((1 << sz) - 1), y = ib - x;
|
2013-03-25 20:30:00 +01:00
|
|
|
const TX_TYPE tx_type = get_tx_type_8x8(xd, y + (x >> 1));
|
2013-04-22 23:08:41 +02:00
|
|
|
scan = get_scan_8x8(tx_type);
|
2012-08-11 00:34:31 +02:00
|
|
|
default_eob = 64;
|
|
|
|
break;
|
2013-03-25 20:30:00 +01:00
|
|
|
}
|
|
|
|
case TX_16X16: {
|
|
|
|
const BLOCK_SIZE_TYPE sb_type = xd->mode_info_context->mbmi.sb_type;
|
2013-04-24 18:18:16 +02:00
|
|
|
const int sz = 2 + b_width_log2(sb_type);
|
2013-04-11 01:50:01 +02:00
|
|
|
const int x = ib & ((1 << sz) - 1), y = ib - x;
|
2013-03-25 20:30:00 +01:00
|
|
|
const TX_TYPE tx_type = get_tx_type_16x16(xd, y + (x >> 2));
|
2013-04-22 23:08:41 +02:00
|
|
|
scan = get_scan_16x16(tx_type);
|
2012-12-03 23:53:45 +01:00
|
|
|
default_eob = 256;
|
|
|
|
break;
|
2013-03-25 20:30:00 +01:00
|
|
|
}
|
2013-03-04 23:12:17 +01:00
|
|
|
case TX_32X32:
|
|
|
|
scan = vp9_default_zig_zag1d_32x32;
|
|
|
|
default_eob = 1024;
|
|
|
|
break;
|
2012-08-11 00:34:31 +02:00
|
|
|
}
|
2013-04-04 21:03:27 +02:00
|
|
|
assert(eob <= default_eob);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
/* Now set up a Viterbi trellis to evaluate alternative roundings. */
|
|
|
|
rdmult = mb->rdmult * err_mult;
|
|
|
|
if (mb->e_mbd.mode_info_context->mbmi.ref_frame == INTRA_FRAME)
|
|
|
|
rdmult = (rdmult * 9) >> 4;
|
|
|
|
rddiv = mb->rddiv;
|
2012-12-03 23:53:45 +01:00
|
|
|
memset(best_index, 0, sizeof(best_index));
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Initialize the sentinel node of the trellis. */
|
|
|
|
tokens[eob][0].rate = 0;
|
|
|
|
tokens[eob][0].error = 0;
|
2012-08-11 00:34:31 +02:00
|
|
|
tokens[eob][0].next = default_eob;
|
2012-07-14 00:21:29 +02:00
|
|
|
tokens[eob][0].token = DCT_EOB_TOKEN;
|
|
|
|
tokens[eob][0].qc = 0;
|
|
|
|
*(tokens[eob] + 1) = *(tokens[eob] + 0);
|
|
|
|
next = eob;
|
2013-03-27 00:46:09 +01:00
|
|
|
for (i = 0; i < eob; i++)
|
2013-03-28 18:42:23 +01:00
|
|
|
token_cache[scan[i]] = vp9_dct_value_tokens_ptr[qcoeff_ptr[scan[i]]].token;
|
2013-03-27 00:46:09 +01:00
|
|
|
nb = vp9_get_coef_neighbors_handle(scan, &pad);
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (i = eob; i-- > i0;) {
|
2012-12-03 23:53:45 +01:00
|
|
|
int base_bits, d2, dx;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-08-11 00:34:31 +02:00
|
|
|
rc = scan[i];
|
2012-07-14 00:21:29 +02:00
|
|
|
x = qcoeff_ptr[rc];
|
|
|
|
/* Only add a trellis state for non-zero coefficients. */
|
|
|
|
if (x) {
|
|
|
|
int shortcut = 0;
|
|
|
|
error0 = tokens[next][0].error;
|
|
|
|
error1 = tokens[next][1].error;
|
|
|
|
/* Evaluate the first possibility for this state. */
|
|
|
|
rate0 = tokens[next][0].rate;
|
|
|
|
rate1 = tokens[next][1].rate;
|
2013-04-19 01:18:08 +02:00
|
|
|
t0 = (vp9_dct_value_tokens_ptr + x)->token;
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Consider both possible successor states. */
|
2012-08-11 00:34:31 +02:00
|
|
|
if (next < default_eob) {
|
2013-03-25 20:28:24 +01:00
|
|
|
band = get_coef_band(scan, tx_size, i + 1);
|
2013-03-27 00:46:09 +01:00
|
|
|
pt = trellis_get_coeff_context(scan, nb, i, t0, token_cache,
|
|
|
|
pad, default_eob);
|
2012-07-14 00:21:29 +02:00
|
|
|
rate0 +=
|
2013-02-19 22:36:38 +01:00
|
|
|
mb->token_costs[tx_size][type][ref][band][pt][tokens[next][0].token];
|
2012-07-14 00:21:29 +02:00
|
|
|
rate1 +=
|
2013-02-19 22:36:38 +01:00
|
|
|
mb->token_costs[tx_size][type][ref][band][pt][tokens[next][1].token];
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-08-11 00:34:31 +02:00
|
|
|
UPDATE_RD_COST();
|
2012-07-14 00:21:29 +02:00
|
|
|
/* And pick the best. */
|
|
|
|
best = rd_cost1 < rd_cost0;
|
2012-10-31 01:12:12 +01:00
|
|
|
base_bits = *(vp9_dct_value_cost_ptr + x);
|
2013-03-04 23:12:17 +01:00
|
|
|
dx = mul * (dqcoeff_ptr[rc] - coeff_ptr[rc]);
|
2012-07-14 00:21:29 +02:00
|
|
|
d2 = dx * dx;
|
|
|
|
tokens[i][0].rate = base_bits + (best ? rate1 : rate0);
|
|
|
|
tokens[i][0].error = d2 + (best ? error1 : error0);
|
|
|
|
tokens[i][0].next = next;
|
|
|
|
tokens[i][0].token = t0;
|
|
|
|
tokens[i][0].qc = x;
|
2012-12-03 23:53:45 +01:00
|
|
|
best_index[i][0] = best;
|
2013-02-20 19:16:24 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Evaluate the second possibility for this state. */
|
|
|
|
rate0 = tokens[next][0].rate;
|
|
|
|
rate1 = tokens[next][1].rate;
|
|
|
|
|
2013-03-04 23:12:17 +01:00
|
|
|
if ((abs(x)*dequant_ptr[rc != 0] > abs(coeff_ptr[rc]) * mul) &&
|
|
|
|
(abs(x)*dequant_ptr[rc != 0] < abs(coeff_ptr[rc]) * mul +
|
|
|
|
dequant_ptr[rc != 0]))
|
2012-07-14 00:21:29 +02:00
|
|
|
shortcut = 1;
|
|
|
|
else
|
|
|
|
shortcut = 0;
|
|
|
|
|
|
|
|
if (shortcut) {
|
|
|
|
sz = -(x < 0);
|
|
|
|
x -= 2 * sz + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Consider both possible successor states. */
|
|
|
|
if (!x) {
|
|
|
|
/* If we reduced this coefficient to zero, check to see if
|
|
|
|
* we need to move the EOB back here.
|
Add trellis quantization.
Replace the exponential search for optimal rounding during
quantization with a linear Viterbi trellis and enable it
by default when using --best.
Right now this operates on top of the output of the adaptive
zero-bin quantizer in vp8_regular_quantize_b() and gives a small
gain.
It can be tested as a replacement for that quantizer by
enabling the call to vp8_strict_quantize_b(), which uses
normal rounding and no zero bin offset.
Ultimately, the quantizer will have to become a function of lambda
in order to take advantage of activity masking, since there is
limited ability to change the quantization factor itself.
However, currently vp8_strict_quantize_b() plus the trellis
quantizer (which is lambda-dependent) loses to
vp8_regular_quantize_b() alone (which is not) on my test clip.
Patch Set 3:
Fix an issue related to the cost evaluation of successor
states when a coefficient is reduced to zero. With this
issue fixed, now the trellis search almost exactly matches
the exponential search.
Patch Set 2:
Overall, the goal of this patch set is to make "trellis"
search to produce encodings that match the exponential
search version. There are three main differences between
Patch Set 2 and 1:
a. Patch set 1 did not properly account for the scale of
2nd order error, so patch set 2 disable it all together
for 2nd blocks.
b. Patch set 1 was not consistent on when to enable the
the quantization optimization. Patch set 2 restore the
condition to be consistent.
c. Patch set 1 checks quantized level L-1, and L for any
input coefficient was quantized to L. Patch set 2 limits
the candidate coefficient to those that were rounded up
to L. It is worth noting here that a strategy to check
L and L+1 for coefficients that were truncated down to L
might work.
(a and b get trellis quant to basically match the exponential
search on all mid/low rate encodings on cif set, without
a, b, trellis quant can hurt the psnr by 0.2 to .3db at
200kbps for some cif clips)
(c gets trellis quant to match the exponential search
to match at Q0 encoding, without c, trellis quant can be
1.5 to 2db lower for encodings with fixed Q at 0 on most
derf cif clips)
Change-Id: Ib1a043b665d75fbf00cb0257b7c18e90eebab95e
2010-07-02 23:35:53 +02:00
|
|
|
*/
|
2012-07-14 00:21:29 +02:00
|
|
|
t0 = tokens[next][0].token == DCT_EOB_TOKEN ?
|
|
|
|
DCT_EOB_TOKEN : ZERO_TOKEN;
|
|
|
|
t1 = tokens[next][1].token == DCT_EOB_TOKEN ?
|
|
|
|
DCT_EOB_TOKEN : ZERO_TOKEN;
|
|
|
|
} else {
|
2013-04-19 01:18:08 +02:00
|
|
|
t0 = t1 = (vp9_dct_value_tokens_ptr + x)->token;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-08-11 00:34:31 +02:00
|
|
|
if (next < default_eob) {
|
2013-03-25 20:28:24 +01:00
|
|
|
band = get_coef_band(scan, tx_size, i + 1);
|
2012-07-14 00:21:29 +02:00
|
|
|
if (t0 != DCT_EOB_TOKEN) {
|
2013-03-27 00:46:09 +01:00
|
|
|
pt = trellis_get_coeff_context(scan, nb, i, t0, token_cache,
|
|
|
|
pad, default_eob);
|
2013-02-19 22:36:38 +01:00
|
|
|
rate0 += mb->token_costs[tx_size][type][ref][band][pt][
|
2012-08-11 00:34:31 +02:00
|
|
|
tokens[next][0].token];
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
if (t1 != DCT_EOB_TOKEN) {
|
2013-03-27 00:46:09 +01:00
|
|
|
pt = trellis_get_coeff_context(scan, nb, i, t1, token_cache,
|
|
|
|
pad, default_eob);
|
2013-02-19 22:36:38 +01:00
|
|
|
rate1 += mb->token_costs[tx_size][type][ref][band][pt][
|
2012-08-11 00:34:31 +02:00
|
|
|
tokens[next][1].token];
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-08-11 00:34:31 +02:00
|
|
|
UPDATE_RD_COST();
|
2012-07-14 00:21:29 +02:00
|
|
|
/* And pick the best. */
|
|
|
|
best = rd_cost1 < rd_cost0;
|
2012-10-31 01:12:12 +01:00
|
|
|
base_bits = *(vp9_dct_value_cost_ptr + x);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
if (shortcut) {
|
2012-08-11 00:34:31 +02:00
|
|
|
dx -= (dequant_ptr[rc != 0] + sz) ^ sz;
|
2012-07-14 00:21:29 +02:00
|
|
|
d2 = dx * dx;
|
|
|
|
}
|
|
|
|
tokens[i][1].rate = base_bits + (best ? rate1 : rate0);
|
|
|
|
tokens[i][1].error = d2 + (best ? error1 : error0);
|
|
|
|
tokens[i][1].next = next;
|
|
|
|
tokens[i][1].token = best ? t1 : t0;
|
|
|
|
tokens[i][1].qc = x;
|
2012-12-03 23:53:45 +01:00
|
|
|
best_index[i][1] = best;
|
2012-07-14 00:21:29 +02:00
|
|
|
/* Finally, make this the new head of the trellis. */
|
|
|
|
next = i;
|
Add trellis quantization.
Replace the exponential search for optimal rounding during
quantization with a linear Viterbi trellis and enable it
by default when using --best.
Right now this operates on top of the output of the adaptive
zero-bin quantizer in vp8_regular_quantize_b() and gives a small
gain.
It can be tested as a replacement for that quantizer by
enabling the call to vp8_strict_quantize_b(), which uses
normal rounding and no zero bin offset.
Ultimately, the quantizer will have to become a function of lambda
in order to take advantage of activity masking, since there is
limited ability to change the quantization factor itself.
However, currently vp8_strict_quantize_b() plus the trellis
quantizer (which is lambda-dependent) loses to
vp8_regular_quantize_b() alone (which is not) on my test clip.
Patch Set 3:
Fix an issue related to the cost evaluation of successor
states when a coefficient is reduced to zero. With this
issue fixed, now the trellis search almost exactly matches
the exponential search.
Patch Set 2:
Overall, the goal of this patch set is to make "trellis"
search to produce encodings that match the exponential
search version. There are three main differences between
Patch Set 2 and 1:
a. Patch set 1 did not properly account for the scale of
2nd order error, so patch set 2 disable it all together
for 2nd blocks.
b. Patch set 1 was not consistent on when to enable the
the quantization optimization. Patch set 2 restore the
condition to be consistent.
c. Patch set 1 checks quantized level L-1, and L for any
input coefficient was quantized to L. Patch set 2 limits
the candidate coefficient to those that were rounded up
to L. It is worth noting here that a strategy to check
L and L+1 for coefficients that were truncated down to L
might work.
(a and b get trellis quant to basically match the exponential
search on all mid/low rate encodings on cif set, without
a, b, trellis quant can hurt the psnr by 0.2 to .3db at
200kbps for some cif clips)
(c gets trellis quant to match the exponential search
to match at Q0 encoding, without c, trellis quant can be
1.5 to 2db lower for encodings with fixed Q at 0 on most
derf cif clips)
Change-Id: Ib1a043b665d75fbf00cb0257b7c18e90eebab95e
2010-07-02 23:35:53 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
/* There's no choice to make for a zero coefficient, so we don't
|
|
|
|
* add a new trellis node, but we do need to update the costs.
|
|
|
|
*/
|
|
|
|
else {
|
2013-03-25 20:28:24 +01:00
|
|
|
band = get_coef_band(scan, tx_size, i + 1);
|
2012-07-14 00:21:29 +02:00
|
|
|
t0 = tokens[next][0].token;
|
|
|
|
t1 = tokens[next][1].token;
|
|
|
|
/* Update the cost of each path if we're past the EOB token. */
|
|
|
|
if (t0 != DCT_EOB_TOKEN) {
|
2013-02-19 22:36:38 +01:00
|
|
|
tokens[next][0].rate +=
|
|
|
|
mb->token_costs[tx_size][type][ref][band][0][t0];
|
2012-07-14 00:21:29 +02:00
|
|
|
tokens[next][0].token = ZERO_TOKEN;
|
|
|
|
}
|
|
|
|
if (t1 != DCT_EOB_TOKEN) {
|
2013-02-19 22:36:38 +01:00
|
|
|
tokens[next][1].rate +=
|
|
|
|
mb->token_costs[tx_size][type][ref][band][0][t1];
|
2012-07-14 00:21:29 +02:00
|
|
|
tokens[next][1].token = ZERO_TOKEN;
|
|
|
|
}
|
|
|
|
/* Don't update next, because we didn't add a new node. */
|
Add trellis quantization.
Replace the exponential search for optimal rounding during
quantization with a linear Viterbi trellis and enable it
by default when using --best.
Right now this operates on top of the output of the adaptive
zero-bin quantizer in vp8_regular_quantize_b() and gives a small
gain.
It can be tested as a replacement for that quantizer by
enabling the call to vp8_strict_quantize_b(), which uses
normal rounding and no zero bin offset.
Ultimately, the quantizer will have to become a function of lambda
in order to take advantage of activity masking, since there is
limited ability to change the quantization factor itself.
However, currently vp8_strict_quantize_b() plus the trellis
quantizer (which is lambda-dependent) loses to
vp8_regular_quantize_b() alone (which is not) on my test clip.
Patch Set 3:
Fix an issue related to the cost evaluation of successor
states when a coefficient is reduced to zero. With this
issue fixed, now the trellis search almost exactly matches
the exponential search.
Patch Set 2:
Overall, the goal of this patch set is to make "trellis"
search to produce encodings that match the exponential
search version. There are three main differences between
Patch Set 2 and 1:
a. Patch set 1 did not properly account for the scale of
2nd order error, so patch set 2 disable it all together
for 2nd blocks.
b. Patch set 1 was not consistent on when to enable the
the quantization optimization. Patch set 2 restore the
condition to be consistent.
c. Patch set 1 checks quantized level L-1, and L for any
input coefficient was quantized to L. Patch set 2 limits
the candidate coefficient to those that were rounded up
to L. It is worth noting here that a strategy to check
L and L+1 for coefficients that were truncated down to L
might work.
(a and b get trellis quant to basically match the exponential
search on all mid/low rate encodings on cif set, without
a, b, trellis quant can hurt the psnr by 0.2 to .3db at
200kbps for some cif clips)
(c gets trellis quant to match the exponential search
to match at Q0 encoding, without c, trellis quant can be
1.5 to 2db lower for encodings with fixed Q at 0 on most
derf cif clips)
Change-Id: Ib1a043b665d75fbf00cb0257b7c18e90eebab95e
2010-07-02 23:35:53 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Now pick the best path through the whole trellis. */
|
2013-03-25 20:28:24 +01:00
|
|
|
band = get_coef_band(scan, tx_size, i + 1);
|
2013-04-17 00:30:28 +02:00
|
|
|
pt = combine_entropy_contexts(*a, *l);
|
2012-07-14 00:21:29 +02:00
|
|
|
rate0 = tokens[next][0].rate;
|
|
|
|
rate1 = tokens[next][1].rate;
|
|
|
|
error0 = tokens[next][0].error;
|
|
|
|
error1 = tokens[next][1].error;
|
|
|
|
t0 = tokens[next][0].token;
|
|
|
|
t1 = tokens[next][1].token;
|
2013-02-19 22:36:38 +01:00
|
|
|
rate0 += mb->token_costs[tx_size][type][ref][band][pt][t0];
|
|
|
|
rate1 += mb->token_costs[tx_size][type][ref][band][pt][t1];
|
2012-08-11 00:34:31 +02:00
|
|
|
UPDATE_RD_COST();
|
2012-07-14 00:21:29 +02:00
|
|
|
best = rd_cost1 < rd_cost0;
|
|
|
|
final_eob = i0 - 1;
|
2013-03-28 18:42:23 +01:00
|
|
|
vpx_memset(qcoeff_ptr, 0, sizeof(*qcoeff_ptr) * (16 << (tx_size * 2)));
|
|
|
|
vpx_memset(dqcoeff_ptr, 0, sizeof(*dqcoeff_ptr) * (16 << (tx_size * 2)));
|
2012-07-14 00:21:29 +02:00
|
|
|
for (i = next; i < eob; i = next) {
|
|
|
|
x = tokens[i][best].qc;
|
2013-02-20 19:16:24 +01:00
|
|
|
if (x) {
|
2012-07-14 00:21:29 +02:00
|
|
|
final_eob = i;
|
2013-02-20 19:16:24 +01:00
|
|
|
}
|
2012-08-11 00:34:31 +02:00
|
|
|
rc = scan[i];
|
2012-07-14 00:21:29 +02:00
|
|
|
qcoeff_ptr[rc] = x;
|
2013-03-04 23:12:17 +01:00
|
|
|
dqcoeff_ptr[rc] = (x * dequant_ptr[rc != 0]) / mul;
|
2012-08-11 00:34:31 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
next = tokens[i][best].next;
|
2012-12-03 23:53:45 +01:00
|
|
|
best = best_index[i][best];
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
final_eob++;
|
|
|
|
|
2013-04-04 21:03:27 +02:00
|
|
|
xd->plane[pb_idx.plane].eobs[pb_idx.block] = final_eob;
|
2013-02-27 19:00:24 +01:00
|
|
|
*a = *l = (final_eob > 0);
|
2011-10-25 19:25:02 +02:00
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_optimize_sby_32x32(VP9_COMMON *const cm, MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize) - 3, bw = 1 << bwl;
|
|
|
|
const int bh = 1 << (b_height_log2(bsize) - 3);
|
2013-03-04 23:12:17 +01:00
|
|
|
ENTROPY_CONTEXT ta[2], tl[2];
|
|
|
|
int n;
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bw; n++) {
|
|
|
|
ENTROPY_CONTEXT *a =
|
|
|
|
(ENTROPY_CONTEXT *) (x->e_mbd.above_context + n * 2 + 0);
|
|
|
|
ENTROPY_CONTEXT *a1 =
|
|
|
|
(ENTROPY_CONTEXT *) (x->e_mbd.above_context + n * 2 + 1);
|
|
|
|
ta[n] = (a[0] + a[1] + a[2] + a[3] + a1[0] + a1[1] + a1[2] + a1[3]) != 0;
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bh; n++) {
|
|
|
|
ENTROPY_CONTEXT *l =
|
|
|
|
(ENTROPY_CONTEXT *) (x->e_mbd.left_context + n * 2);
|
|
|
|
ENTROPY_CONTEXT *l1 =
|
|
|
|
(ENTROPY_CONTEXT *) (x->e_mbd.left_context + n * 2 + 1);
|
|
|
|
tl[n] = (l[0] + l[1] + l[2] + l[3] + l1[0] + l1[1] + l1[2] + l1[3]) != 0;
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-04-24 23:48:17 +02:00
|
|
|
optimize_b(cm, x, n * 64, PLANE_TYPE_Y_WITH_DC, x->e_mbd.plane[0].dequant,
|
2013-04-10 06:28:27 +02:00
|
|
|
ta + x_idx, tl + y_idx, TX_32X32, 64 * bw * bh);
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_optimize_sby_16x16(VP9_COMMON *const cm, MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize) - 2, bw = 1 << bwl;
|
|
|
|
const int bh = 1 << (b_height_log2(bsize) - 2);
|
2013-03-04 23:12:17 +01:00
|
|
|
ENTROPY_CONTEXT ta[4], tl[4];
|
|
|
|
int n;
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bw; n++) {
|
|
|
|
ENTROPY_CONTEXT *a = (ENTROPY_CONTEXT *) (x->e_mbd.above_context + n);
|
|
|
|
ta[n] = (a[0] + a[1] + a[2] + a[3]) != 0;
|
|
|
|
}
|
|
|
|
for (n = 0; n < bh; n++) {
|
|
|
|
ENTROPY_CONTEXT *l = (ENTROPY_CONTEXT *) (x->e_mbd.left_context + n);
|
|
|
|
tl[n] = (l[0] + l[1] + l[2] + l[3]) != 0;
|
|
|
|
}
|
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-04-24 23:48:17 +02:00
|
|
|
optimize_b(cm, x, n * 16, PLANE_TYPE_Y_WITH_DC, x->e_mbd.plane[0].dequant,
|
2013-04-10 06:28:27 +02:00
|
|
|
ta + x_idx, tl + y_idx, TX_16X16, 16 * bw * bh);
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_optimize_sby_8x8(VP9_COMMON *const cm, MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize) - 1, bw = 1 << bwl;
|
|
|
|
const int bh = 1 << (b_height_log2(bsize) - 1);
|
2013-03-04 23:12:17 +01:00
|
|
|
ENTROPY_CONTEXT ta[8], tl[8];
|
|
|
|
int n;
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
for (n = 0; n < bw; n += 2) {
|
|
|
|
ENTROPY_CONTEXT *a =
|
|
|
|
(ENTROPY_CONTEXT *) (x->e_mbd.above_context + (n >> 1));
|
|
|
|
ta[n + 0] = (a[0] + a[1]) != 0;
|
|
|
|
ta[n + 1] = (a[2] + a[3]) != 0;
|
|
|
|
}
|
|
|
|
for (n = 0; n < bh; n += 2) {
|
|
|
|
ENTROPY_CONTEXT *l =
|
|
|
|
(ENTROPY_CONTEXT *) (x->e_mbd.left_context + (n >> 1));
|
|
|
|
tl[n + 0] = (l[0] + l[1]) != 0;
|
|
|
|
tl[n + 1] = (l[2] + l[3]) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-04-24 23:48:17 +02:00
|
|
|
optimize_b(cm, x, n * 4, PLANE_TYPE_Y_WITH_DC, x->e_mbd.plane[0].dequant,
|
2013-04-10 06:28:27 +02:00
|
|
|
ta + x_idx, tl + y_idx, TX_8X8, 4 * bw * bh);
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_optimize_sby_4x4(VP9_COMMON *const cm, MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
int bwl = b_width_log2(bsize), bw = 1 << bwl;
|
|
|
|
int bh = 1 << b_height_log2(bsize);
|
2013-03-04 23:12:17 +01:00
|
|
|
ENTROPY_CONTEXT ta[16], tl[16];
|
|
|
|
int n;
|
|
|
|
|
2013-04-24 18:18:16 +02:00
|
|
|
for (n = 0; n < bw; n += 4)
|
|
|
|
vpx_memcpy(&ta[n], x->e_mbd.above_context + (n >> 2),
|
2013-04-10 06:28:27 +02:00
|
|
|
sizeof(ENTROPY_CONTEXT) * 4);
|
2013-04-24 18:18:16 +02:00
|
|
|
for (n = 0; n < bh; n += 4)
|
|
|
|
vpx_memcpy(&tl[n], x->e_mbd.left_context + (n >> 2),
|
2013-04-10 06:28:27 +02:00
|
|
|
sizeof(ENTROPY_CONTEXT) * 4);
|
|
|
|
|
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> bwl;
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-04-24 23:48:17 +02:00
|
|
|
optimize_b(cm, x, n, PLANE_TYPE_Y_WITH_DC, x->e_mbd.plane[0].dequant,
|
2013-04-10 06:28:27 +02:00
|
|
|
ta + x_idx, tl + y_idx, TX_4X4, bh * bw);
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_optimize_sbuv_32x32(VP9_COMMON *const cm, MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
2013-03-04 23:12:17 +01:00
|
|
|
ENTROPY_CONTEXT *ta = (ENTROPY_CONTEXT *) x->e_mbd.above_context;
|
|
|
|
ENTROPY_CONTEXT *tl = (ENTROPY_CONTEXT *) x->e_mbd.left_context;
|
|
|
|
ENTROPY_CONTEXT *a, *l, *a1, *l1, *a2, *l2, *a3, *l3, a_ec, l_ec;
|
|
|
|
int b;
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
assert(bsize == BLOCK_SIZE_SB64X64);
|
2013-03-04 23:12:17 +01:00
|
|
|
for (b = 256; b < 384; b += 64) {
|
2013-04-24 23:48:17 +02:00
|
|
|
const int plane = 1 + (b >= 320);
|
2013-03-04 23:12:17 +01:00
|
|
|
a = ta + vp9_block2above_sb64[TX_32X32][b];
|
|
|
|
l = tl + vp9_block2left_sb64[TX_32X32][b];
|
|
|
|
a1 = a + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
|
|
|
|
l1 = l + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
|
|
|
|
a2 = a + 2 * sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
|
|
|
|
l2 = l + 2 * sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
|
|
|
|
a3 = a + 3 * sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
|
|
|
|
l3 = l + 3 * sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
|
|
|
|
a_ec = (a[0] + a[1] + a1[0] + a1[1] + a2[0] + a2[1] + a3[0] + a3[1]) != 0;
|
|
|
|
l_ec = (l[0] + l[1] + l1[0] + l1[1] + l2[0] + l2[1] + l3[0] + l3[1]) != 0;
|
2013-04-24 23:48:17 +02:00
|
|
|
optimize_b(cm, x, b, PLANE_TYPE_UV, x->e_mbd.plane[plane].dequant,
|
2013-04-04 21:03:27 +02:00
|
|
|
&a_ec, &l_ec, TX_32X32, 256);
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_optimize_sbuv_16x16(VP9_COMMON *const cm, MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize) - 2, bhl = b_height_log2(bsize) - 2;
|
2013-04-10 06:28:27 +02:00
|
|
|
const int bw = 1 << (bwl - 1);
|
|
|
|
const int bh = 1 << (bhl - 1);
|
|
|
|
int uvoff = 16 << (bwl + bhl);
|
|
|
|
ENTROPY_CONTEXT ta[2][2], tl[2][2];
|
|
|
|
int plane, n;
|
|
|
|
|
|
|
|
for (n = 0; n < bw; n++) {
|
|
|
|
ENTROPY_CONTEXT_PLANES *a = x->e_mbd.above_context + n * 2;
|
|
|
|
ENTROPY_CONTEXT_PLANES *a1 = x->e_mbd.above_context + n * 2 + 1;
|
|
|
|
ta[0][n] = (a->u[0] + a->u[1] + a1->u[0] + a1->u[1]) != 0;
|
|
|
|
ta[1][n] = (a->v[0] + a->v[1] + a1->v[0] + a1->v[1]) != 0;
|
|
|
|
}
|
|
|
|
for (n = 0; n < bh; n++) {
|
|
|
|
ENTROPY_CONTEXT_PLANES *l = (x->e_mbd.left_context + n * 2);
|
|
|
|
ENTROPY_CONTEXT_PLANES *l1 = (x->e_mbd.left_context + n * 2 + 1);
|
|
|
|
tl[0][n] = (l->u[0] + l->u[1] + l1->u[0] + l1->u[1]) != 0;
|
|
|
|
tl[1][n] = (l->v[0] + l->v[1] + l1->v[0] + l1->v[1]) != 0;
|
|
|
|
}
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
for (plane = 0; plane < 2; plane++) {
|
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> (bwl - 1);
|
|
|
|
optimize_b(cm, x, uvoff + n * 16, PLANE_TYPE_UV,
|
2013-04-24 23:48:17 +02:00
|
|
|
x->e_mbd.plane[plane + 1].dequant,
|
2013-04-10 06:28:27 +02:00
|
|
|
&ta[plane][x_idx], &tl[plane][y_idx],
|
|
|
|
TX_16X16, bh * bw * 64);
|
|
|
|
}
|
|
|
|
uvoff = (uvoff * 5) >> 2; // switch u -> v
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_optimize_sbuv_8x8(VP9_COMMON *const cm, MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize) - 1, bhl = b_height_log2(bsize) - 1;
|
2013-04-10 06:28:27 +02:00
|
|
|
const int bw = 1 << (bwl - 1);
|
|
|
|
const int bh = 1 << (bhl - 1);
|
|
|
|
int uvoff = 4 << (bwl + bhl);
|
|
|
|
ENTROPY_CONTEXT ta[2][4], tl[2][4];
|
|
|
|
int plane, n;
|
|
|
|
|
|
|
|
for (n = 0; n < bw; n++) {
|
|
|
|
ENTROPY_CONTEXT_PLANES *a = x->e_mbd.above_context + n;
|
|
|
|
ta[0][n] = (a->u[0] + a->u[1]) != 0;
|
|
|
|
ta[1][n] = (a->v[0] + a->v[1]) != 0;
|
|
|
|
}
|
|
|
|
for (n = 0; n < bh; n++) {
|
|
|
|
ENTROPY_CONTEXT_PLANES *l = x->e_mbd.left_context + n;
|
|
|
|
tl[0][n] = (l->u[0] + l->u[1]) != 0;
|
|
|
|
tl[1][n] = (l->v[0] + l->v[1]) != 0;
|
|
|
|
}
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
for (plane = 0; plane < 2; plane++) {
|
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> (bwl - 1);
|
|
|
|
optimize_b(cm, x, uvoff + n * 4, PLANE_TYPE_UV,
|
2013-04-24 23:48:17 +02:00
|
|
|
x->e_mbd.plane[plane + 1].dequant,
|
2013-04-10 06:28:27 +02:00
|
|
|
&ta[plane][x_idx], &tl[plane][y_idx],
|
|
|
|
TX_8X8, bh * bw * 16);
|
|
|
|
}
|
|
|
|
uvoff = (uvoff * 5) >> 2; // switch u -> v
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
void vp9_optimize_sbuv_4x4(VP9_COMMON *const cm, MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE_TYPE bsize) {
|
2013-04-24 18:18:16 +02:00
|
|
|
const int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
|
2013-04-10 06:28:27 +02:00
|
|
|
const int bw = 1 << (bwl - 1);
|
|
|
|
const int bh = 1 << (bhl - 1);
|
|
|
|
int uvoff = 1 << (bwl + bhl);
|
|
|
|
ENTROPY_CONTEXT ta[2][8], tl[2][8];
|
|
|
|
int plane, n;
|
|
|
|
|
|
|
|
for (n = 0; n < bw; n += 2) {
|
|
|
|
ENTROPY_CONTEXT_PLANES *a = x->e_mbd.above_context + (n >> 1);
|
|
|
|
ta[0][n + 0] = (a->u[0]) != 0;
|
|
|
|
ta[0][n + 1] = (a->u[1]) != 0;
|
|
|
|
ta[1][n + 0] = (a->v[0]) != 0;
|
|
|
|
ta[1][n + 1] = (a->v[1]) != 0;
|
|
|
|
}
|
|
|
|
for (n = 0; n < bh; n += 2) {
|
|
|
|
ENTROPY_CONTEXT_PLANES *l = x->e_mbd.left_context + (n >> 1);
|
|
|
|
tl[0][n + 0] = (l->u[0]) != 0;
|
|
|
|
tl[0][n + 1] = (l->u[1]) != 0;
|
|
|
|
tl[1][n + 0] = (l->v[0]) != 0;
|
|
|
|
tl[1][n + 1] = (l->v[1]) != 0;
|
|
|
|
}
|
2013-03-04 23:12:17 +01:00
|
|
|
|
2013-04-10 06:28:27 +02:00
|
|
|
for (plane = 0; plane < 2; plane++) {
|
|
|
|
for (n = 0; n < bw * bh; n++) {
|
|
|
|
const int x_idx = n & (bw - 1), y_idx = n >> (bwl - 1);
|
|
|
|
optimize_b(cm, x, uvoff + n, PLANE_TYPE_UV,
|
2013-04-24 23:48:17 +02:00
|
|
|
x->e_mbd.plane[plane + 1].dequant,
|
2013-04-10 06:28:27 +02:00
|
|
|
&ta[plane][x_idx], &tl[plane][y_idx],
|
|
|
|
TX_4X4, bh * bw * 4);
|
|
|
|
}
|
|
|
|
uvoff = (uvoff * 5) >> 2; // switch u -> v
|
2013-03-04 23:12:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-20 19:16:24 +01:00
|
|
|
void vp9_fidct_mb(VP9_COMMON *const cm, MACROBLOCK *x) {
|
2012-11-08 20:03:00 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2013-04-11 19:57:16 +02:00
|
|
|
const TX_SIZE tx_size = xd->mode_info_context->mbmi.txfm_size;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-13 17:15:51 +02:00
|
|
|
if (tx_size == TX_16X16) {
|
2013-04-11 19:57:16 +02:00
|
|
|
vp9_transform_sby_16x16(x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_transform_sbuv_8x8(x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_quantize_sby_16x16(x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_quantize_sbuv_8x8(x, BLOCK_SIZE_MB16X16);
|
|
|
|
if (x->optimize) {
|
|
|
|
vp9_optimize_sby_16x16(cm, x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_optimize_sbuv_8x8(cm, x, BLOCK_SIZE_MB16X16);
|
|
|
|
}
|
|
|
|
vp9_inverse_transform_sby_16x16(xd, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_inverse_transform_sbuv_8x8(xd, BLOCK_SIZE_MB16X16);
|
2012-10-13 17:15:51 +02:00
|
|
|
} else if (tx_size == TX_8X8) {
|
2013-04-11 19:57:16 +02:00
|
|
|
vp9_transform_sby_8x8(x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_quantize_sby_8x8(x, BLOCK_SIZE_MB16X16);
|
|
|
|
if (x->optimize)
|
|
|
|
vp9_optimize_sby_8x8(cm, x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_inverse_transform_sby_8x8(xd, BLOCK_SIZE_MB16X16);
|
2012-10-22 20:49:00 +02:00
|
|
|
if (xd->mode_info_context->mbmi.mode == SPLITMV) {
|
|
|
|
assert(xd->mode_info_context->mbmi.partitioning != PARTITIONING_4X4);
|
2013-04-11 19:57:16 +02:00
|
|
|
vp9_transform_sbuv_4x4(x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_quantize_sbuv_4x4(x, BLOCK_SIZE_MB16X16);
|
|
|
|
if (x->optimize)
|
|
|
|
vp9_optimize_sbuv_4x4(cm, x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_inverse_transform_sbuv_4x4(xd, BLOCK_SIZE_MB16X16);
|
2012-10-22 20:49:00 +02:00
|
|
|
} else {
|
2013-04-11 19:57:16 +02:00
|
|
|
vp9_transform_sbuv_8x8(x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_quantize_sbuv_8x8(x, BLOCK_SIZE_MB16X16);
|
2012-10-22 20:49:00 +02:00
|
|
|
if (x->optimize)
|
2013-04-11 19:57:16 +02:00
|
|
|
vp9_optimize_sbuv_8x8(cm, x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_inverse_transform_sbuv_8x8(xd, BLOCK_SIZE_MB16X16);
|
2012-10-22 20:49:00 +02:00
|
|
|
}
|
2012-10-13 17:15:51 +02:00
|
|
|
} else {
|
2013-04-11 19:57:16 +02:00
|
|
|
vp9_transform_sby_4x4(x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_transform_sbuv_4x4(x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_quantize_sby_4x4(x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_quantize_sbuv_4x4(x, BLOCK_SIZE_MB16X16);
|
|
|
|
if (x->optimize) {
|
|
|
|
vp9_optimize_sby_4x4(cm, x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_optimize_sbuv_4x4(cm, x, BLOCK_SIZE_MB16X16);
|
|
|
|
}
|
|
|
|
vp9_inverse_transform_sby_4x4(xd, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_inverse_transform_sbuv_4x4(xd, BLOCK_SIZE_MB16X16);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-11-08 20:03:00 +01:00
|
|
|
}
|
|
|
|
|
2013-02-20 19:16:24 +01:00
|
|
|
void vp9_encode_inter16x16(VP9_COMMON *const cm, MACROBLOCK *x,
|
|
|
|
int mb_row, int mb_col) {
|
2012-11-08 20:03:00 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-04-19 19:45:50 +02:00
|
|
|
vp9_build_inter_predictors_sb(xd, mb_row, mb_col, BLOCK_SIZE_MB16X16);
|
2013-04-23 17:26:10 +02:00
|
|
|
vp9_subtract_sb(x, BLOCK_SIZE_MB16X16);
|
2013-02-20 19:16:24 +01:00
|
|
|
vp9_fidct_mb(cm, x);
|
2013-04-19 21:12:00 +02:00
|
|
|
vp9_recon_sb(xd, BLOCK_SIZE_MB16X16);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2011-02-14 23:18:18 +01:00
|
|
|
/* this function is used by first pass only */
|
Spatial resamping of ZEROMV predictors
This patch allows coding frames using references of different
resolution, in ZEROMV mode. For compound prediction, either
reference may be scaled.
To test, I use the resize_test and enable WRITE_RECON_BUFFER
in vp9_onyxd_if.c. It's also useful to apply this patch to
test/i420_video_source.h:
--- a/test/i420_video_source.h
+++ b/test/i420_video_source.h
@@ -93,6 +93,7 @@ class I420VideoSource : public VideoSource {
virtual void FillFrame() {
// Read a frame from input_file.
+ if (frame_ != 3)
if (fread(img_->img_data, raw_sz_, 1, input_file_) == 0) {
limit_ = frame_;
}
This forces the frame that the resolution changes on to be coded
with no motion, only scaling, and improves the quality of the
result.
Change-Id: I1ee75d19a437ff801192f767fd02a36bcbd1d496
2013-02-25 05:55:14 +01:00
|
|
|
void vp9_encode_inter16x16y(MACROBLOCK *x, int mb_row, int mb_col) {
|
2012-10-13 17:15:51 +02:00
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-19 19:45:50 +02:00
|
|
|
vp9_build_inter_predictors_sby(xd, mb_row, mb_col, BLOCK_SIZE_MB16X16);
|
2013-04-23 17:26:10 +02:00
|
|
|
vp9_subtract_sby(x, BLOCK_SIZE_MB16X16);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-11 19:57:16 +02:00
|
|
|
vp9_transform_sby_4x4(x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_quantize_sby_4x4(x, BLOCK_SIZE_MB16X16);
|
|
|
|
vp9_inverse_transform_sby_4x4(xd, BLOCK_SIZE_MB16X16);
|
2012-02-29 02:11:12 +01:00
|
|
|
|
2013-04-19 21:12:00 +02:00
|
|
|
vp9_recon_sby(xd, BLOCK_SIZE_MB16X16);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|