2012-08-21 01:43:34 +04:00
|
|
|
|
2012-01-28 14:07:08 +04:00
|
|
|
/*
|
2012-01-31 16:45:30 +04:00
|
|
|
* Copyright (c) 2012 The WebM project authors. All Rights Reserved.
|
2012-01-28 14:07:08 +04:00
|
|
|
*
|
|
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
|
|
|
|
* in the file PATENTS. All contributing project authors may
|
|
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
|
|
|
*/
|
|
|
|
|
|
2013-04-20 01:25:32 +04:00
|
|
|
#include <limits.h>
|
|
|
|
|
|
2013-01-06 06:20:25 +04:00
|
|
|
#include "vp9/common/vp9_common.h"
|
2012-11-28 01:59:17 +04:00
|
|
|
#include "vp9/common/vp9_pred_common.h"
|
|
|
|
|
#include "vp9/common/vp9_seg_common.h"
|
Consistently use get_prob(), clip_prob() and newly added clip_pixel().
Add a function clip_pixel() to clip a pixel value to the [0,255] range
of allowed values, and use this where-ever appropriate (e.g. prediction,
reconstruction). Likewise, consistently use the recently added function
clip_prob(), which calculates a binary probability in the [1,255] range.
If possible, try to use get_prob() or its sister get_binary_prob() to
calculate binary probabilities, for consistency.
Since in some places, this means that binary probability calculations
are changed (we use {255,256}*count0/(total) in a range of places,
and all of these are now changed to use 256*count0+(total>>1)/total),
this changes the encoding result, so this patch warrants some extensive
testing.
Change-Id: Ibeeff8d886496839b8e0c0ace9ccc552351f7628
2012-12-11 00:09:07 +04:00
|
|
|
#include "vp9/common/vp9_treecoder.h"
|
2012-01-28 14:07:08 +04:00
|
|
|
|
|
|
|
|
// TBD prediction functions for various bitstream signals
|
|
|
|
|
|
|
|
|
|
// Returns a context number for the given MB prediction signal
|
2012-10-31 04:53:32 +04:00
|
|
|
unsigned char vp9_get_pred_context(const VP9_COMMON *const cm,
|
2012-10-29 17:44:18 +04:00
|
|
|
const MACROBLOCKD *const xd,
|
|
|
|
|
PRED_ID pred_id) {
|
2012-07-14 02:21:29 +04:00
|
|
|
int pred_context;
|
2013-04-24 03:18:09 +04:00
|
|
|
const MODE_INFO *const mi = xd->mode_info_context;
|
|
|
|
|
const MODE_INFO *const above_mi = mi - cm->mode_info_stride;
|
|
|
|
|
const MODE_INFO *const left_mi = mi - 1;
|
2013-06-07 00:44:34 +04:00
|
|
|
const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
|
|
|
|
|
const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
|
2012-07-14 02:21:29 +04:00
|
|
|
// Note:
|
|
|
|
|
// The mode info data structure has a one element border above and to the
|
|
|
|
|
// left of the entries correpsonding to real macroblocks.
|
|
|
|
|
// The prediction flags in these dummy entries are initialised to 0.
|
|
|
|
|
switch (pred_id) {
|
2012-01-28 14:07:08 +04:00
|
|
|
case PRED_SEG_ID:
|
2013-04-24 03:18:09 +04:00
|
|
|
pred_context = above_mi->mbmi.seg_id_predicted;
|
[WIP] Add column-based tiling.
This patch adds column-based tiling. The idea is to make each tile
independently decodable (after reading the common frame header) and
also independendly encodable (minus within-frame cost adjustments in
the RD loop) to speed-up hardware & software en/decoders if they used
multi-threading. Column-based tiling has the added advantage (over
other tiling methods) that it minimizes realtime use-case latency,
since all threads can start encoding data as soon as the first SB-row
worth of data is available to the encoder.
There is some test code that does random tile ordering in the decoder,
to confirm that each tile is indeed independently decodable from other
tiles in the same frame. At tile edges, all contexts assume default
values (i.e. 0, 0 motion vector, no coefficients, DC intra4x4 mode),
and motion vector search and ordering do not cross tiles in the same
frame.
t log
Tile independence is not maintained between frames ATM, i.e. tile 0 of
frame 1 is free to use motion vectors that point into any tile of frame
0. We support 1 (i.e. no tiling), 2 or 4 column-tiles.
The loopfilter crosses tile boundaries. I discussed this briefly with Aki
and he says that's OK. An in-loop loopfilter would need to do some sync
between tile threads, but that shouldn't be a big issue.
Resuls: with tiling disabled, we go up slightly because of improved edge
use in the intra4x4 prediction. With 2 tiles, we lose about ~1% on derf,
~0.35% on HD and ~0.55% on STD/HD. With 4 tiles, we lose another ~1.5%
on derf ~0.77% on HD and ~0.85% on STD/HD. Most of this loss is
concentrated in the low-bitrate end of clips, and most of it is because
of the loss of edges at tile boundaries and the resulting loss of intra
predictors.
TODO:
- more tiles (perhaps allow row-based tiling also, and max. 8 tiles)?
- maybe optionally (for EC purposes), motion vectors themselves
should not cross tile edges, or we should emulate such borders as
if they were off-frame, to limit error propagation to within one
tile only. This doesn't have to be the default behaviour but could
be an optional bitstream flag.
Change-Id: I5951c3a0742a767b20bc9fb5af685d9892c2c96f
2013-02-01 21:35:28 +04:00
|
|
|
if (xd->left_available)
|
2013-04-24 03:18:09 +04:00
|
|
|
pred_context += left_mi->mbmi.seg_id_predicted;
|
2012-07-14 02:21:29 +04:00
|
|
|
break;
|
2012-01-28 14:07:08 +04:00
|
|
|
|
2012-03-19 22:02:04 +04:00
|
|
|
case PRED_MBSKIP:
|
2013-04-24 03:18:09 +04:00
|
|
|
pred_context = above_mi->mbmi.mb_skip_coeff;
|
[WIP] Add column-based tiling.
This patch adds column-based tiling. The idea is to make each tile
independently decodable (after reading the common frame header) and
also independendly encodable (minus within-frame cost adjustments in
the RD loop) to speed-up hardware & software en/decoders if they used
multi-threading. Column-based tiling has the added advantage (over
other tiling methods) that it minimizes realtime use-case latency,
since all threads can start encoding data as soon as the first SB-row
worth of data is available to the encoder.
There is some test code that does random tile ordering in the decoder,
to confirm that each tile is indeed independently decodable from other
tiles in the same frame. At tile edges, all contexts assume default
values (i.e. 0, 0 motion vector, no coefficients, DC intra4x4 mode),
and motion vector search and ordering do not cross tiles in the same
frame.
t log
Tile independence is not maintained between frames ATM, i.e. tile 0 of
frame 1 is free to use motion vectors that point into any tile of frame
0. We support 1 (i.e. no tiling), 2 or 4 column-tiles.
The loopfilter crosses tile boundaries. I discussed this briefly with Aki
and he says that's OK. An in-loop loopfilter would need to do some sync
between tile threads, but that shouldn't be a big issue.
Resuls: with tiling disabled, we go up slightly because of improved edge
use in the intra4x4 prediction. With 2 tiles, we lose about ~1% on derf,
~0.35% on HD and ~0.55% on STD/HD. With 4 tiles, we lose another ~1.5%
on derf ~0.77% on HD and ~0.85% on STD/HD. Most of this loss is
concentrated in the low-bitrate end of clips, and most of it is because
of the loss of edges at tile boundaries and the resulting loss of intra
predictors.
TODO:
- more tiles (perhaps allow row-based tiling also, and max. 8 tiles)?
- maybe optionally (for EC purposes), motion vectors themselves
should not cross tile edges, or we should emulate such borders as
if they were off-frame, to limit error propagation to within one
tile only. This doesn't have to be the default behaviour but could
be an optional bitstream flag.
Change-Id: I5951c3a0742a767b20bc9fb5af685d9892c2c96f
2013-02-01 21:35:28 +04:00
|
|
|
if (xd->left_available)
|
2013-04-24 03:18:09 +04:00
|
|
|
pred_context += left_mi->mbmi.mb_skip_coeff;
|
2012-07-14 02:21:29 +04:00
|
|
|
break;
|
2012-03-19 22:02:04 +04:00
|
|
|
|
2013-04-24 03:18:09 +04:00
|
|
|
case PRED_SWITCHABLE_INTERP: {
|
|
|
|
|
// left
|
2013-04-24 23:14:58 +04:00
|
|
|
const int left_mv_pred = is_inter_mode(left_mi->mbmi.mode);
|
2013-04-24 03:18:09 +04:00
|
|
|
const int left_interp = left_in_image && left_mv_pred ?
|
|
|
|
|
vp9_switchable_interp_map[left_mi->mbmi.interp_filter] :
|
|
|
|
|
VP9_SWITCHABLE_FILTERS;
|
|
|
|
|
|
|
|
|
|
// above
|
2013-04-24 23:14:58 +04:00
|
|
|
const int above_mv_pred = is_inter_mode(above_mi->mbmi.mode);
|
2013-04-24 03:18:09 +04:00
|
|
|
const int above_interp = above_in_image && above_mv_pred ?
|
|
|
|
|
vp9_switchable_interp_map[above_mi->mbmi.interp_filter] :
|
|
|
|
|
VP9_SWITCHABLE_FILTERS;
|
|
|
|
|
|
|
|
|
|
assert(left_interp != -1);
|
|
|
|
|
assert(above_interp != -1);
|
|
|
|
|
|
|
|
|
|
if (left_interp == above_interp)
|
|
|
|
|
pred_context = left_interp;
|
|
|
|
|
else if (left_interp == VP9_SWITCHABLE_FILTERS &&
|
|
|
|
|
above_interp != VP9_SWITCHABLE_FILTERS)
|
|
|
|
|
pred_context = above_interp;
|
|
|
|
|
else if (left_interp != VP9_SWITCHABLE_FILTERS &&
|
|
|
|
|
above_interp == VP9_SWITCHABLE_FILTERS)
|
|
|
|
|
pred_context = left_interp;
|
|
|
|
|
else
|
|
|
|
|
pred_context = VP9_SWITCHABLE_FILTERS;
|
|
|
|
|
|
2012-07-19 00:43:01 +04:00
|
|
|
break;
|
2013-04-24 03:18:09 +04:00
|
|
|
}
|
2012-07-19 00:43:01 +04:00
|
|
|
|
2013-06-07 00:44:34 +04:00
|
|
|
case PRED_INTRA_INTER: {
|
|
|
|
|
if (above_in_image && left_in_image) { // both edges available
|
|
|
|
|
if (left_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
|
|
|
|
|
above_mi->mbmi.ref_frame[0] == INTRA_FRAME) { // intra/intra (3)
|
|
|
|
|
pred_context = 3;
|
|
|
|
|
} else { // intra/inter (1) or inter/inter (0)
|
|
|
|
|
pred_context = left_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
|
|
|
|
|
above_mi->mbmi.ref_frame[0] == INTRA_FRAME;
|
|
|
|
|
}
|
|
|
|
|
} else if (above_in_image || left_in_image) { // one edge available
|
|
|
|
|
const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
|
|
|
|
|
|
|
|
|
|
// inter: 0, intra: 2
|
|
|
|
|
pred_context = 2 * (edge->mbmi.ref_frame[0] == INTRA_FRAME);
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 0;
|
|
|
|
|
}
|
|
|
|
|
assert(pred_context >= 0 && pred_context < INTRA_INTER_CONTEXTS);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case PRED_COMP_INTER_INTER: {
|
|
|
|
|
if (above_in_image && left_in_image) { // both edges available
|
|
|
|
|
if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME &&
|
|
|
|
|
left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {
|
|
|
|
|
// neither edge uses comp pred (0/1)
|
|
|
|
|
pred_context = ((above_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref) ^
|
|
|
|
|
(left_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref));
|
|
|
|
|
} else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {
|
|
|
|
|
// one of two edges uses comp pred (2/3)
|
|
|
|
|
pred_context = 2 +
|
|
|
|
|
(above_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref ||
|
|
|
|
|
above_mi->mbmi.ref_frame[0] == INTRA_FRAME);
|
|
|
|
|
} else if (left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {
|
|
|
|
|
// one of two edges uses comp pred (2/3)
|
|
|
|
|
pred_context = 2 +
|
|
|
|
|
(left_mi->mbmi.ref_frame[0] == cm->comp_fixed_ref ||
|
|
|
|
|
left_mi->mbmi.ref_frame[0] == INTRA_FRAME);
|
|
|
|
|
} else { // both edges use comp pred (4)
|
|
|
|
|
pred_context = 4;
|
|
|
|
|
}
|
|
|
|
|
} else if (above_in_image || left_in_image) { // one edge available
|
|
|
|
|
const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
|
|
|
|
|
|
|
|
|
|
if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {
|
|
|
|
|
// edge does not use comp pred (0/1)
|
|
|
|
|
pred_context = edge->mbmi.ref_frame[0] == cm->comp_fixed_ref;
|
|
|
|
|
} else { // edge uses comp pred (3)
|
|
|
|
|
pred_context = 3;
|
|
|
|
|
}
|
|
|
|
|
} else { // no edges available (1)
|
|
|
|
|
pred_context = 1;
|
|
|
|
|
}
|
|
|
|
|
assert(pred_context >= 0 && pred_context < COMP_INTER_CONTEXTS);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case PRED_COMP_REF_P: {
|
|
|
|
|
const int fix_ref_idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
|
|
|
|
|
const int var_ref_idx = !fix_ref_idx;
|
|
|
|
|
|
|
|
|
|
if (above_in_image && left_in_image) { // both edges available
|
|
|
|
|
if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
|
|
|
|
|
left_mi->mbmi.ref_frame[0] == INTRA_FRAME) { // intra/intra (2)
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
} else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
|
|
|
|
|
left_mi->mbmi.ref_frame[0] == INTRA_FRAME) { // intra/inter
|
|
|
|
|
const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == INTRA_FRAME ?
|
|
|
|
|
left_mi : above_mi;
|
|
|
|
|
|
|
|
|
|
if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) { // single pred (1/3)
|
|
|
|
|
pred_context = 1 +
|
|
|
|
|
2 * edge->mbmi.ref_frame[0] != cm->comp_var_ref[1];
|
|
|
|
|
} else { // comp pred (1/3)
|
|
|
|
|
pred_context = 1 +
|
|
|
|
|
2 * edge->mbmi.ref_frame[var_ref_idx] != cm->comp_var_ref[1];
|
|
|
|
|
}
|
|
|
|
|
} else { // inter/inter
|
|
|
|
|
int l_sg = left_mi->mbmi.ref_frame[1] <= INTRA_FRAME;
|
|
|
|
|
int a_sg = above_mi->mbmi.ref_frame[1] <= INTRA_FRAME;
|
|
|
|
|
MV_REFERENCE_FRAME vrfa = a_sg ? above_mi->mbmi.ref_frame[0] :
|
|
|
|
|
above_mi->mbmi.ref_frame[var_ref_idx];
|
|
|
|
|
MV_REFERENCE_FRAME vrfl = l_sg ? left_mi->mbmi.ref_frame[0] :
|
|
|
|
|
left_mi->mbmi.ref_frame[var_ref_idx];
|
|
|
|
|
|
|
|
|
|
if (vrfa == vrfl && cm->comp_var_ref[1] == vrfa) {
|
|
|
|
|
pred_context = 0;
|
|
|
|
|
} else if (l_sg && a_sg) { // single/single
|
|
|
|
|
if ((vrfa == cm->comp_fixed_ref && vrfl == cm->comp_var_ref[0]) ||
|
|
|
|
|
(vrfl == cm->comp_fixed_ref && vrfa == cm->comp_var_ref[0])) {
|
|
|
|
|
pred_context = 4;
|
|
|
|
|
} else if (vrfa == vrfl) {
|
|
|
|
|
pred_context = 3;
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 1;
|
|
|
|
|
}
|
|
|
|
|
} else if (l_sg || a_sg) { // single/comp
|
|
|
|
|
MV_REFERENCE_FRAME vrfc = l_sg ? vrfa : vrfl;
|
|
|
|
|
MV_REFERENCE_FRAME rfs = a_sg ? vrfa : vrfl;
|
|
|
|
|
|
|
|
|
|
if (vrfc == cm->comp_var_ref[1] && rfs != cm->comp_var_ref[1]) {
|
|
|
|
|
pred_context = 1;
|
|
|
|
|
} else if (rfs == cm->comp_var_ref[1] &&
|
|
|
|
|
vrfc != cm->comp_var_ref[1]) {
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 4;
|
|
|
|
|
}
|
|
|
|
|
} else if (vrfa == vrfl) { // comp/comp
|
|
|
|
|
pred_context = 4;
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else if (above_in_image || left_in_image) { // one edge available
|
|
|
|
|
const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
|
|
|
|
|
|
|
|
|
|
if (edge->mbmi.ref_frame[0] == INTRA_FRAME) {
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
} else if (edge->mbmi.ref_frame[1] > INTRA_FRAME) {
|
|
|
|
|
pred_context =
|
|
|
|
|
4 * edge->mbmi.ref_frame[var_ref_idx] != cm->comp_var_ref[1];
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 3 * edge->mbmi.ref_frame[0] != cm->comp_var_ref[1];
|
|
|
|
|
}
|
|
|
|
|
} else { // no edges available (2)
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
}
|
|
|
|
|
assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case PRED_SINGLE_REF_P1: {
|
|
|
|
|
if (above_in_image && left_in_image) { // both edges available
|
|
|
|
|
if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
|
|
|
|
|
left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
} else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
|
|
|
|
|
left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {
|
|
|
|
|
const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == INTRA_FRAME ?
|
|
|
|
|
left_mi : above_mi;
|
|
|
|
|
|
|
|
|
|
if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {
|
|
|
|
|
pred_context = 4 * (edge->mbmi.ref_frame[0] == LAST_FRAME);
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 1 + (edge->mbmi.ref_frame[0] == LAST_FRAME ||
|
|
|
|
|
edge->mbmi.ref_frame[1] == LAST_FRAME);
|
|
|
|
|
}
|
|
|
|
|
} else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME &&
|
|
|
|
|
left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {
|
|
|
|
|
pred_context = 2 * (above_mi->mbmi.ref_frame[0] == LAST_FRAME) +
|
|
|
|
|
2 * (left_mi->mbmi.ref_frame[0] == LAST_FRAME);
|
|
|
|
|
} else if (above_mi->mbmi.ref_frame[1] > INTRA_FRAME &&
|
|
|
|
|
left_mi->mbmi.ref_frame[1] > INTRA_FRAME) {
|
|
|
|
|
pred_context = 1 + (above_mi->mbmi.ref_frame[0] == LAST_FRAME ||
|
|
|
|
|
above_mi->mbmi.ref_frame[1] == LAST_FRAME ||
|
|
|
|
|
left_mi->mbmi.ref_frame[0] == LAST_FRAME ||
|
|
|
|
|
left_mi->mbmi.ref_frame[1] == LAST_FRAME);
|
|
|
|
|
} else {
|
|
|
|
|
MV_REFERENCE_FRAME rfs = above_mi->mbmi.ref_frame[1] <= INTRA_FRAME ?
|
|
|
|
|
above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
|
|
|
|
|
MV_REFERENCE_FRAME crf1 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
|
|
|
|
|
above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
|
|
|
|
|
MV_REFERENCE_FRAME crf2 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
|
|
|
|
|
above_mi->mbmi.ref_frame[1] : left_mi->mbmi.ref_frame[1];
|
|
|
|
|
|
|
|
|
|
if (rfs == LAST_FRAME) {
|
|
|
|
|
pred_context = 3 + (crf1 == LAST_FRAME || crf2 == LAST_FRAME);
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = crf1 == LAST_FRAME || crf2 == LAST_FRAME;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else if (above_in_image || left_in_image) { // one edge available
|
|
|
|
|
const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
|
|
|
|
|
|
|
|
|
|
if (edge->mbmi.ref_frame[0] == INTRA_FRAME) {
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
} else if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {
|
|
|
|
|
pred_context = 4 * (edge->mbmi.ref_frame[0] == LAST_FRAME);
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 1 + (edge->mbmi.ref_frame[0] == LAST_FRAME ||
|
|
|
|
|
edge->mbmi.ref_frame[1] == LAST_FRAME);
|
|
|
|
|
}
|
|
|
|
|
} else { // no edges available (2)
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
}
|
|
|
|
|
assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case PRED_SINGLE_REF_P2: {
|
|
|
|
|
if (above_in_image && left_in_image) { // both edges available
|
|
|
|
|
if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME &&
|
|
|
|
|
left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
} else if (above_mi->mbmi.ref_frame[0] == INTRA_FRAME ||
|
|
|
|
|
left_mi->mbmi.ref_frame[0] == INTRA_FRAME) {
|
|
|
|
|
const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == INTRA_FRAME ?
|
|
|
|
|
left_mi : above_mi;
|
|
|
|
|
|
|
|
|
|
if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {
|
|
|
|
|
if (edge->mbmi.ref_frame[0] == LAST_FRAME) {
|
|
|
|
|
pred_context = 3;
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 4 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 1 + 2 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME ||
|
|
|
|
|
edge->mbmi.ref_frame[1] == GOLDEN_FRAME);
|
|
|
|
|
}
|
|
|
|
|
} else if (above_mi->mbmi.ref_frame[1] <= INTRA_FRAME &&
|
|
|
|
|
left_mi->mbmi.ref_frame[1] <= INTRA_FRAME) {
|
|
|
|
|
if (above_mi->mbmi.ref_frame[0] == LAST_FRAME &&
|
|
|
|
|
left_mi->mbmi.ref_frame[0] == LAST_FRAME) {
|
|
|
|
|
pred_context = 3;
|
|
|
|
|
} else if (above_mi->mbmi.ref_frame[0] == LAST_FRAME ||
|
|
|
|
|
left_mi->mbmi.ref_frame[0] == LAST_FRAME) {
|
|
|
|
|
const MODE_INFO *edge = above_mi->mbmi.ref_frame[0] == LAST_FRAME ?
|
|
|
|
|
left_mi : above_mi;
|
|
|
|
|
|
|
|
|
|
pred_context = 4 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME);
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 2 * (above_mi->mbmi.ref_frame[0] == GOLDEN_FRAME) +
|
|
|
|
|
2 * (left_mi->mbmi.ref_frame[0] == GOLDEN_FRAME);
|
|
|
|
|
}
|
|
|
|
|
} else if (above_mi->mbmi.ref_frame[1] > INTRA_FRAME &&
|
|
|
|
|
left_mi->mbmi.ref_frame[1] > INTRA_FRAME) {
|
|
|
|
|
if (above_mi->mbmi.ref_frame[0] == left_mi->mbmi.ref_frame[0] &&
|
|
|
|
|
above_mi->mbmi.ref_frame[1] == left_mi->mbmi.ref_frame[1]) {
|
|
|
|
|
pred_context = 3 * (above_mi->mbmi.ref_frame[0] == GOLDEN_FRAME ||
|
|
|
|
|
above_mi->mbmi.ref_frame[1] == GOLDEN_FRAME ||
|
|
|
|
|
left_mi->mbmi.ref_frame[0] == GOLDEN_FRAME ||
|
|
|
|
|
left_mi->mbmi.ref_frame[1] == GOLDEN_FRAME);
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
MV_REFERENCE_FRAME rfs = above_mi->mbmi.ref_frame[1] <= INTRA_FRAME ?
|
|
|
|
|
above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
|
|
|
|
|
MV_REFERENCE_FRAME crf1 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
|
|
|
|
|
above_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[0];
|
|
|
|
|
MV_REFERENCE_FRAME crf2 = above_mi->mbmi.ref_frame[1] > INTRA_FRAME ?
|
|
|
|
|
above_mi->mbmi.ref_frame[1] : left_mi->mbmi.ref_frame[1];
|
|
|
|
|
|
|
|
|
|
if (rfs == GOLDEN_FRAME) {
|
|
|
|
|
pred_context = 3 + (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
|
|
|
|
|
} else if (rfs == ALTREF_FRAME) {
|
|
|
|
|
pred_context = crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME;
|
|
|
|
|
} else {
|
|
|
|
|
pred_context =
|
|
|
|
|
1 + 2 * (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else if (above_in_image || left_in_image) { // one edge available
|
|
|
|
|
const MODE_INFO *edge = above_in_image ? above_mi : left_mi;
|
|
|
|
|
|
|
|
|
|
if (edge->mbmi.ref_frame[0] == INTRA_FRAME ||
|
|
|
|
|
(edge->mbmi.ref_frame[0] == LAST_FRAME &&
|
|
|
|
|
edge->mbmi.ref_frame[1] <= INTRA_FRAME)) {
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
} else if (edge->mbmi.ref_frame[1] <= INTRA_FRAME) {
|
|
|
|
|
pred_context = 4 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME);
|
|
|
|
|
} else {
|
|
|
|
|
pred_context = 3 * (edge->mbmi.ref_frame[0] == GOLDEN_FRAME ||
|
|
|
|
|
edge->mbmi.ref_frame[1] == GOLDEN_FRAME);
|
|
|
|
|
}
|
|
|
|
|
} else { // no edges available (2)
|
|
|
|
|
pred_context = 2;
|
|
|
|
|
}
|
|
|
|
|
assert(pred_context >= 0 && pred_context < REF_CONTEXTS);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-06 22:14:04 +04:00
|
|
|
case PRED_TX_SIZE: {
|
2013-06-08 11:09:44 +04:00
|
|
|
int above_context, left_context;
|
2013-06-06 22:14:04 +04:00
|
|
|
int max_tx_size;
|
|
|
|
|
if (mi->mbmi.sb_type < BLOCK_SIZE_SB8X8)
|
|
|
|
|
max_tx_size = TX_4X4;
|
|
|
|
|
else if (mi->mbmi.sb_type < BLOCK_SIZE_MB16X16)
|
|
|
|
|
max_tx_size = TX_8X8;
|
|
|
|
|
else if (mi->mbmi.sb_type < BLOCK_SIZE_SB32X32)
|
|
|
|
|
max_tx_size = TX_16X16;
|
|
|
|
|
else
|
|
|
|
|
max_tx_size = TX_32X32;
|
2013-06-08 11:09:44 +04:00
|
|
|
above_context = left_context = max_tx_size;
|
2013-06-08 18:14:58 +04:00
|
|
|
if (above_in_image) {
|
2013-06-06 22:14:04 +04:00
|
|
|
above_context = (above_mi->mbmi.mb_skip_coeff ?
|
|
|
|
|
max_tx_size : above_mi->mbmi.txfm_size);
|
|
|
|
|
}
|
2013-06-08 18:14:58 +04:00
|
|
|
if (left_in_image) {
|
2013-06-06 22:14:04 +04:00
|
|
|
left_context = (left_mi->mbmi.mb_skip_coeff ?
|
|
|
|
|
max_tx_size : left_mi->mbmi.txfm_size);
|
|
|
|
|
}
|
2013-06-08 18:14:58 +04:00
|
|
|
if (!left_in_image) {
|
2013-06-06 22:14:04 +04:00
|
|
|
left_context = above_context;
|
|
|
|
|
}
|
2013-06-08 18:14:58 +04:00
|
|
|
if (!above_in_image) {
|
2013-06-06 22:14:04 +04:00
|
|
|
above_context = left_context;
|
|
|
|
|
}
|
2013-06-08 11:09:44 +04:00
|
|
|
pred_context = (above_context + left_context > max_tx_size);
|
2013-06-06 22:14:04 +04:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-28 14:07:08 +04:00
|
|
|
default:
|
2013-06-07 00:44:34 +04:00
|
|
|
assert(0);
|
2013-03-06 02:12:16 +04:00
|
|
|
pred_context = 0; // *** add error trap code.
|
2012-07-14 02:21:29 +04:00
|
|
|
break;
|
|
|
|
|
}
|
2012-01-28 14:07:08 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
return pred_context;
|
2012-01-28 14:07:08 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// This function returns a context probability for coding a given
|
|
|
|
|
// prediction signal
|
2012-11-01 01:40:53 +04:00
|
|
|
vp9_prob vp9_get_pred_prob(const VP9_COMMON *const cm,
|
2012-10-29 17:44:18 +04:00
|
|
|
const MACROBLOCKD *const xd,
|
|
|
|
|
PRED_ID pred_id) {
|
2013-03-06 02:12:16 +04:00
|
|
|
const int pred_context = vp9_get_pred_context(cm, xd, pred_id);
|
2012-07-14 02:21:29 +04:00
|
|
|
|
|
|
|
|
switch (pred_id) {
|
2012-01-28 14:07:08 +04:00
|
|
|
case PRED_SEG_ID:
|
2013-03-06 02:12:16 +04:00
|
|
|
return cm->segment_pred_probs[pred_context];
|
2012-03-19 22:02:04 +04:00
|
|
|
case PRED_MBSKIP:
|
2013-06-08 00:24:14 +04:00
|
|
|
return cm->fc.mbskip_probs[pred_context];
|
2013-06-07 00:44:34 +04:00
|
|
|
case PRED_INTRA_INTER:
|
|
|
|
|
return cm->fc.intra_inter_prob[pred_context];
|
|
|
|
|
case PRED_COMP_INTER_INTER:
|
|
|
|
|
return cm->fc.comp_inter_prob[pred_context];
|
|
|
|
|
case PRED_COMP_REF_P:
|
|
|
|
|
return cm->fc.comp_ref_prob[pred_context];
|
|
|
|
|
case PRED_SINGLE_REF_P1:
|
|
|
|
|
return cm->fc.single_ref_prob[pred_context][0];
|
|
|
|
|
case PRED_SINGLE_REF_P2:
|
|
|
|
|
return cm->fc.single_ref_prob[pred_context][1];
|
2012-01-28 14:07:08 +04:00
|
|
|
default:
|
2013-06-07 00:44:34 +04:00
|
|
|
assert(0);
|
2013-03-06 02:12:16 +04:00
|
|
|
return 128; // *** add error trap code.
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2012-01-28 14:07:08 +04:00
|
|
|
}
|
|
|
|
|
|
2012-07-19 00:43:01 +04:00
|
|
|
// This function returns a context probability ptr for coding a given
|
|
|
|
|
// prediction signal
|
2012-11-01 01:40:53 +04:00
|
|
|
const vp9_prob *vp9_get_pred_probs(const VP9_COMMON *const cm,
|
2012-10-29 17:44:18 +04:00
|
|
|
const MACROBLOCKD *const xd,
|
|
|
|
|
PRED_ID pred_id) {
|
2013-06-06 22:14:04 +04:00
|
|
|
const MODE_INFO *const mi = xd->mode_info_context;
|
2013-03-06 02:12:16 +04:00
|
|
|
const int pred_context = vp9_get_pred_context(cm, xd, pred_id);
|
2012-07-19 00:43:01 +04:00
|
|
|
|
|
|
|
|
switch (pred_id) {
|
|
|
|
|
case PRED_SWITCHABLE_INTERP:
|
2013-03-06 02:12:16 +04:00
|
|
|
return &cm->fc.switchable_interp_prob[pred_context][0];
|
2013-06-06 22:14:04 +04:00
|
|
|
|
|
|
|
|
case PRED_TX_SIZE:
|
|
|
|
|
if (mi->mbmi.sb_type < BLOCK_SIZE_MB16X16)
|
|
|
|
|
return cm->fc.tx_probs_8x8p[pred_context];
|
|
|
|
|
else if (mi->mbmi.sb_type < BLOCK_SIZE_SB32X32)
|
|
|
|
|
return cm->fc.tx_probs_16x16p[pred_context];
|
|
|
|
|
else
|
|
|
|
|
return cm->fc.tx_probs_32x32p[pred_context];
|
|
|
|
|
|
2012-07-19 00:43:01 +04:00
|
|
|
default:
|
2013-06-07 00:44:34 +04:00
|
|
|
assert(0);
|
2013-03-06 02:12:16 +04:00
|
|
|
return NULL; // *** add error trap code.
|
2012-07-19 00:43:01 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-28 14:07:08 +04:00
|
|
|
// This function returns the status of the given prediction signal.
|
|
|
|
|
// I.e. is the predicted value for the given signal correct.
|
2012-10-29 17:44:18 +04:00
|
|
|
unsigned char vp9_get_pred_flag(const MACROBLOCKD *const xd,
|
|
|
|
|
PRED_ID pred_id) {
|
2012-07-14 02:21:29 +04:00
|
|
|
switch (pred_id) {
|
2012-01-28 14:07:08 +04:00
|
|
|
case PRED_SEG_ID:
|
2013-03-06 02:12:16 +04:00
|
|
|
return xd->mode_info_context->mbmi.seg_id_predicted;
|
2012-03-19 22:02:04 +04:00
|
|
|
case PRED_MBSKIP:
|
2013-03-06 02:12:16 +04:00
|
|
|
return xd->mode_info_context->mbmi.mb_skip_coeff;
|
2012-01-28 14:07:08 +04:00
|
|
|
default:
|
2013-06-07 00:44:34 +04:00
|
|
|
assert(0);
|
2013-03-06 02:12:16 +04:00
|
|
|
return 0; // *** add error trap code.
|
2012-07-14 02:21:29 +04:00
|
|
|
}
|
2012-01-28 14:07:08 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// This function sets the status of the given prediction signal.
|
|
|
|
|
// I.e. is the predicted value for the given signal correct.
|
2012-10-29 17:44:18 +04:00
|
|
|
void vp9_set_pred_flag(MACROBLOCKD *const xd,
|
|
|
|
|
PRED_ID pred_id,
|
|
|
|
|
unsigned char pred_flag) {
|
2012-10-30 04:58:18 +04:00
|
|
|
const int mis = xd->mode_info_stride;
|
2013-04-11 03:50:01 +04:00
|
|
|
BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
|
2013-04-26 22:57:17 +04:00
|
|
|
const int bh = 1 << mi_height_log2(bsize);
|
|
|
|
|
const int bw = 1 << mi_width_log2(bsize);
|
2013-04-11 03:50:01 +04:00
|
|
|
#define sub(a, b) (b) < 0 ? (a) + (b) : (a)
|
2013-04-26 22:57:17 +04:00
|
|
|
const int x_mis = sub(bw, xd->mb_to_right_edge >> (3 + LOG2_MI_SIZE));
|
|
|
|
|
const int y_mis = sub(bh, xd->mb_to_bottom_edge >> (3 + LOG2_MI_SIZE));
|
2013-04-11 03:50:01 +04:00
|
|
|
#undef sub
|
|
|
|
|
int x, y;
|
2012-10-30 04:58:18 +04:00
|
|
|
|
2012-07-14 02:21:29 +04:00
|
|
|
switch (pred_id) {
|
2012-01-28 14:07:08 +04:00
|
|
|
case PRED_SEG_ID:
|
2013-04-26 22:57:17 +04:00
|
|
|
for (y = 0; y < y_mis; y++) {
|
|
|
|
|
for (x = 0; x < x_mis; x++) {
|
|
|
|
|
xd->mode_info_context[y * mis + x].mbmi.seg_id_predicted = pred_flag;
|
2012-10-30 04:58:18 +04:00
|
|
|
}
|
2012-08-21 01:43:34 +04:00
|
|
|
}
|
2012-07-14 02:21:29 +04:00
|
|
|
break;
|
2012-01-28 14:07:08 +04:00
|
|
|
|
2012-03-19 22:02:04 +04:00
|
|
|
case PRED_MBSKIP:
|
2013-04-26 22:57:17 +04:00
|
|
|
for (y = 0; y < y_mis; y++) {
|
|
|
|
|
for (x = 0; x < x_mis; x++) {
|
2013-04-11 03:50:01 +04:00
|
|
|
xd->mode_info_context[y * mis + x].mbmi.mb_skip_coeff = pred_flag;
|
2012-10-30 04:58:18 +04:00
|
|
|
}
|
|
|
|
|
}
|
2012-07-14 02:21:29 +04:00
|
|
|
break;
|
2012-03-19 22:02:04 +04:00
|
|
|
|
2012-01-28 14:07:08 +04:00
|
|
|
default:
|
2013-06-07 00:44:34 +04:00
|
|
|
assert(0);
|
2013-03-06 02:12:16 +04:00
|
|
|
// *** add error trap code.
|
2012-07-14 02:21:29 +04:00
|
|
|
break;
|
|
|
|
|
}
|
2012-01-28 14:07:08 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// The following contain the guts of the prediction code used to
|
|
|
|
|
// peredict various bitstream signals.
|
|
|
|
|
|
|
|
|
|
// Macroblock segment id prediction function
|
2013-04-26 22:57:17 +04:00
|
|
|
int vp9_get_pred_mi_segid(VP9_COMMON *cm, BLOCK_SIZE_TYPE sb_type,
|
2013-06-21 02:52:47 +04:00
|
|
|
uint8_t *segment_ids, int mi_row, int mi_col) {
|
2013-04-26 22:57:17 +04:00
|
|
|
const int mi_index = mi_row * cm->mi_cols + mi_col;
|
|
|
|
|
const int bw = 1 << mi_width_log2(sb_type);
|
|
|
|
|
const int bh = 1 << mi_height_log2(sb_type);
|
|
|
|
|
const int ymis = MIN(cm->mi_rows - mi_row, bh);
|
|
|
|
|
const int xmis = MIN(cm->mi_cols - mi_col, bw);
|
|
|
|
|
int segment_id = INT_MAX;
|
|
|
|
|
int x, y;
|
|
|
|
|
|
|
|
|
|
for (y = 0; y < ymis; y++) {
|
|
|
|
|
for (x = 0; x < xmis; x++) {
|
|
|
|
|
const int index = mi_index + (y * cm->mi_cols + x);
|
2013-06-21 02:52:47 +04:00
|
|
|
segment_id = MIN(segment_id, segment_ids[index]);
|
2012-10-30 04:58:18 +04:00
|
|
|
}
|
|
|
|
|
}
|
2013-04-26 22:57:17 +04:00
|
|
|
return segment_id;
|
2012-01-28 14:07:08 +04:00
|
|
|
}
|
