generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
37c3144ed7
vpx/vp9/common/vp9_pred_common.c
Ronald S. Bultje 1a46b30ebe Grow MODE_INFO array to use an 8x8 basis. 
Change-Id: I087e08e7909a406b71715b8525c104208daa6889
2013-04-26 11:57:17 -07:00

369 lines
12 KiB
C
Raw Blame History

/*
* Copyright (c) 2012 The WebM project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <limits.h>
#include "vp9/common/vp9_common.h"
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_treecoder.h"
// TBD prediction functions for various bitstream signals
// Returns a context number for the given MB prediction signal
unsigned char vp9_get_pred_context(const VP9_COMMON *const cm,
const MACROBLOCKD *const xd,
PRED_ID pred_id) {
int pred_context;
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;
// 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) {
case PRED_SEG_ID:
pred_context = above_mi->mbmi.seg_id_predicted;
if (xd->left_available)
pred_context += left_mi->mbmi.seg_id_predicted;
break;
case PRED_REF:
pred_context = above_mi->mbmi.ref_predicted;
if (xd->left_available)
pred_context += left_mi->mbmi.ref_predicted;
break;
case PRED_COMP:
if (mi->mbmi.ref_frame == LAST_FRAME)
pred_context = 0;
else
pred_context = 1;
break;
case PRED_MBSKIP:
pred_context = above_mi->mbmi.mb_skip_coeff;
if (xd->left_available)
pred_context += left_mi->mbmi.mb_skip_coeff;
break;
case PRED_SWITCHABLE_INTERP: {
// left
const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
const int left_mv_pred = is_inter_mode(left_mi->mbmi.mode);
const int left_interp = left_in_image && left_mv_pred ?
vp9_switchable_interp_map[left_mi->mbmi.interp_filter] :
VP9_SWITCHABLE_FILTERS;
// above
const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
const int above_mv_pred = is_inter_mode(above_mi->mbmi.mode);
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;
break;
}
default:
pred_context = 0; // *** add error trap code.
break;
}
return pred_context;
}
// This function returns a context probability for coding a given
// prediction signal
vp9_prob vp9_get_pred_prob(const VP9_COMMON *const cm,
const MACROBLOCKD *const xd,
PRED_ID pred_id) {
const int pred_context = vp9_get_pred_context(cm, xd, pred_id);
switch (pred_id) {
case PRED_SEG_ID:
return cm->segment_pred_probs[pred_context];
case PRED_REF:
return cm->ref_pred_probs[pred_context];
case PRED_COMP:
// In keeping with convention elsewhre the probability returned is
// the probability of a "0" outcome which in this case means the
// probability of comp pred off.
return cm->prob_comppred[pred_context];
case PRED_MBSKIP:
return cm->mbskip_pred_probs[pred_context];
default:
return 128; // *** add error trap code.
}
}
// This function returns a context probability ptr for coding a given
// prediction signal
const vp9_prob *vp9_get_pred_probs(const VP9_COMMON *const cm,
const MACROBLOCKD *const xd,
PRED_ID pred_id) {
const int pred_context = vp9_get_pred_context(cm, xd, pred_id);
switch (pred_id) {
case PRED_SEG_ID:
return &cm->segment_pred_probs[pred_context];
case PRED_REF:
return &cm->ref_pred_probs[pred_context];
case PRED_COMP:
// In keeping with convention elsewhre the probability returned is
// the probability of a "0" outcome which in this case means the
// probability of comp pred off.
return &cm->prob_comppred[pred_context];
case PRED_MBSKIP:
return &cm->mbskip_pred_probs[pred_context];
case PRED_SWITCHABLE_INTERP:
return &cm->fc.switchable_interp_prob[pred_context][0];
default:
return NULL; // *** add error trap code.
}
}
// This function returns the status of the given prediction signal.
// I.e. is the predicted value for the given signal correct.
unsigned char vp9_get_pred_flag(const MACROBLOCKD *const xd,
PRED_ID pred_id) {
switch (pred_id) {
case PRED_SEG_ID:
return xd->mode_info_context->mbmi.seg_id_predicted;
case PRED_REF:
return xd->mode_info_context->mbmi.ref_predicted;
case PRED_MBSKIP:
return xd->mode_info_context->mbmi.mb_skip_coeff;
default:
return 0; // *** add error trap code.
}
}
// This function sets the status of the given prediction signal.
// I.e. is the predicted value for the given signal correct.
void vp9_set_pred_flag(MACROBLOCKD *const xd,
PRED_ID pred_id,
unsigned char pred_flag) {
const int mis = xd->mode_info_stride;
BLOCK_SIZE_TYPE bsize = xd->mode_info_context->mbmi.sb_type;
const int bh = 1 << mi_height_log2(bsize);
const int bw = 1 << mi_width_log2(bsize);
#define sub(a, b) (b) < 0 ? (a) + (b) : (a)
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));
#undef sub
int x, y;
switch (pred_id) {
case PRED_SEG_ID:
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;
}
}
break;
case PRED_REF:
for (y = 0; y < y_mis; y++) {
for (x = 0; x < x_mis; x++) {
xd->mode_info_context[y * mis + x].mbmi.ref_predicted = pred_flag;
}
}
break;
case PRED_MBSKIP:
for (y = 0; y < y_mis; y++) {
for (x = 0; x < x_mis; x++) {
xd->mode_info_context[y * mis + x].mbmi.mb_skip_coeff = pred_flag;
}
}
break;
default:
// *** add error trap code.
break;
}
}
// The following contain the guts of the prediction code used to
// peredict various bitstream signals.
// Macroblock segment id prediction function
int vp9_get_pred_mi_segid(VP9_COMMON *cm, BLOCK_SIZE_TYPE sb_type,
int mi_row, int mi_col) {
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);
segment_id = MIN(segment_id, cm->last_frame_seg_map[index]);
}
}
return segment_id;
}
MV_REFERENCE_FRAME vp9_get_pred_ref(const VP9_COMMON *const cm,
const MACROBLOCKD *const xd) {
MODE_INFO *m = xd->mode_info_context;
MV_REFERENCE_FRAME left;
MV_REFERENCE_FRAME above;
MV_REFERENCE_FRAME above_left;
MV_REFERENCE_FRAME pred_ref = LAST_FRAME;
int segment_id = xd->mode_info_context->mbmi.segment_id;
int i;
unsigned char frame_allowed[MAX_REF_FRAMES] = {1, 1, 1, 1};
unsigned char ref_score[MAX_REF_FRAMES];
unsigned char best_score = 0;
unsigned char left_in_image;
unsigned char above_in_image;
unsigned char above_left_in_image;
// Is segment coding ennabled
int seg_ref_active = vp9_segfeature_active(xd, segment_id, SEG_LVL_REF_FRAME);
// Special case treatment if segment coding is enabled.
// Dont allow prediction of a reference frame that the segment
// does not allow
if (seg_ref_active) {
for (i = 0; i < MAX_REF_FRAMES; i++) {
frame_allowed[i] =
vp9_check_segref(xd, segment_id, i);
// Score set to 0 if ref frame not allowed
ref_score[i] = cm->ref_scores[i] * frame_allowed[i];
}
} else
vpx_memcpy(ref_score, cm->ref_scores, sizeof(ref_score));
// Reference frames used by neighbours
left = (m - 1)->mbmi.ref_frame;
above = (m - cm->mode_info_stride)->mbmi.ref_frame;
above_left = (m - 1 - cm->mode_info_stride)->mbmi.ref_frame;
// Are neighbours in image
left_in_image = (m - 1)->mbmi.mb_in_image && xd->left_available;
above_in_image = (m - cm->mode_info_stride)->mbmi.mb_in_image;
above_left_in_image = (m - 1 - cm->mode_info_stride)->mbmi.mb_in_image &&
xd->left_available;
// Adjust scores for candidate reference frames based on neigbours
if (frame_allowed[left] && left_in_image) {
ref_score[left] += 16;
if (above_left_in_image && (left == above_left))
ref_score[left] += 4;
}
if (frame_allowed[above] && above_in_image) {
ref_score[above] += 16;
if (above_left_in_image && (above == above_left))
ref_score[above] += 4;
}
// Now choose the candidate with the highest score
for (i = 0; i < MAX_REF_FRAMES; i++) {
if (ref_score[i] > best_score) {
pred_ref = i;
best_score = ref_score[i];
}
}
return pred_ref;
}
// Functions to computes a set of modified reference frame probabilities
// to use when the prediction of the reference frame value fails
void vp9_calc_ref_probs(int *count, vp9_prob *probs) {
int tot_count = count[0] + count[1] + count[2] + count[3];
probs[0] = get_prob(count[0], tot_count);
tot_count -= count[0];
probs[1] = get_prob(count[1], tot_count);
tot_count -= count[1];
probs[2] = get_prob(count[2], tot_count);
}
// Computes a set of modified conditional probabilities for the reference frame
// Values willbe set to 0 for reference frame options that are not possible
// because wither they were predicted and prediction has failed or because
// they are not allowed for a given segment.
void vp9_compute_mod_refprobs(VP9_COMMON *const cm) {
int norm_cnt[MAX_REF_FRAMES];
const int intra_count = cm->prob_intra_coded;
const int inter_count = (255 - intra_count);
const int last_count = (inter_count * cm->prob_last_coded) / 255;
const int gfarf_count = inter_count - last_count;
const int gf_count = (gfarf_count * cm->prob_gf_coded) / 255;
const int arf_count = gfarf_count - gf_count;
// Work out modified reference frame probabilities to use where prediction
// of the reference frame fails
norm_cnt[0] = 0;
norm_cnt[1] = last_count;
norm_cnt[2] = gf_count;
norm_cnt[3] = arf_count;
vp9_calc_ref_probs(norm_cnt, cm->mod_refprobs[INTRA_FRAME]);
cm->mod_refprobs[INTRA_FRAME][0] = 0; // This branch implicit
norm_cnt[0] = intra_count;
norm_cnt[1] = 0;
norm_cnt[2] = gf_count;
norm_cnt[3] = arf_count;
vp9_calc_ref_probs(norm_cnt, cm->mod_refprobs[LAST_FRAME]);
cm->mod_refprobs[LAST_FRAME][1] = 0; // This branch implicit
norm_cnt[0] = intra_count;
norm_cnt[1] = last_count;
norm_cnt[2] = 0;
norm_cnt[3] = arf_count;
vp9_calc_ref_probs(norm_cnt, cm->mod_refprobs[GOLDEN_FRAME]);
cm->mod_refprobs[GOLDEN_FRAME][2] = 0; // This branch implicit
norm_cnt[0] = intra_count;
norm_cnt[1] = last_count;
norm_cnt[2] = gf_count;
norm_cnt[3] = 0;
vp9_calc_ref_probs(norm_cnt, cm->mod_refprobs[ALTREF_FRAME]);
cm->mod_refprobs[ALTREF_FRAME][2] = 0; // This branch implicit
// Score the reference frames based on overal frequency.
// These scores contribute to the prediction choices.
// Max score 17 min 1
cm->ref_scores[INTRA_FRAME] = 1 + (intra_count * 16 / 255);
cm->ref_scores[LAST_FRAME] = 1 + (last_count * 16 / 255);
cm->ref_scores[GOLDEN_FRAME] = 1 + (gf_count * 16 / 255);
cm->ref_scores[ALTREF_FRAME] = 1 + (arf_count * 16 / 255);
}
Reference in New Issue View Git Blame Copy Permalink