An error occurred while loading the file. Please try again.
-
James Zern authored
fixes a crash in assembly on 32-bit linux/windows Change-Id: I0c27e6c0ece9732b5eb2ee5b59ff42c3c8016c50
54c2854f
/* * Copyright (c) 2010 The WebM project authors. All Rights Reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */#include <assert.h>#include "./vp9_rtcd.h"#include "vpx_mem/vpx_mem.h"#include "vpx_scale/vpx_scale.h"#include "vp9/common/vp9_alloccommon.h"#include "vp9/common/vp9_common.h"#include "vp9/common/vp9_entropy.h"#include "vp9/common/vp9_entropymode.h"#include "vp9/common/vp9_extend.h"#include "vp9/common/vp9_idct.h"#include "vp9/common/vp9_pred_common.h"#include "vp9/common/vp9_quant_common.h"#include "vp9/common/vp9_reconintra.h"#include "vp9/common/vp9_reconinter.h"#include "vp9/common/vp9_seg_common.h"#include "vp9/common/vp9_tile_common.h"#include "vp9/decoder/vp9_dboolhuff.h"#include "vp9/decoder/vp9_decodframe.h"#include "vp9/decoder/vp9_detokenize.h"#include "vp9/decoder/vp9_decodemv.h"#include "vp9/decoder/vp9_dsubexp.h"#include "vp9/decoder/vp9_onyxd_int.h"#include "vp9/decoder/vp9_read_bit_buffer.h"#include "vp9/decoder/vp9_thread.h"#include "vp9/decoder/vp9_treereader.h"typedef struct TileWorkerData { VP9_COMMON *cm; vp9_reader bit_reader; DECLARE_ALIGNED(16, MACROBLOCKD, xd);} TileWorkerData;static int read_be32(const uint8_t *p) { return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];}static int is_compound_prediction_allowed(const VP9_COMMON *cm) { int i; for (i = 1; i < ALLOWED_REFS_PER_FRAME; ++i) if (cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1]) return 1; return 0;}static void setup_compound_prediction(VP9_COMMON *cm) { if (cm->ref_frame_sign_bias[LAST_FRAME] == cm->ref_frame_sign_bias[GOLDEN_FRAME]) { cm->comp_fixed_ref = ALTREF_FRAME; cm->comp_var_ref[0] = LAST_FRAME; cm->comp_var_ref[1] = GOLDEN_FRAME; } else if (cm->ref_frame_sign_bias[LAST_FRAME] == cm->ref_frame_sign_bias[ALTREF_FRAME]) { cm->comp_fixed_ref = GOLDEN_FRAME; cm->comp_var_ref[0] = LAST_FRAME; cm->comp_var_ref[1] = ALTREF_FRAME; } else {7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
cm->comp_fixed_ref = LAST_FRAME;
cm->comp_var_ref[0] = GOLDEN_FRAME;
cm->comp_var_ref[1] = ALTREF_FRAME;
}
}
// len == 0 is not allowed
static int read_is_valid(const uint8_t *start, size_t len, const uint8_t *end) {
return start + len > start && start + len <= end;
}
static int decode_unsigned_max(struct vp9_read_bit_buffer *rb, int max) {
const int data = vp9_rb_read_literal(rb, get_unsigned_bits(max));
return data > max ? max : data;
}
static TX_MODE read_tx_mode(vp9_reader *r) {
TX_MODE tx_mode = vp9_read_literal(r, 2);
if (tx_mode == ALLOW_32X32)
tx_mode += vp9_read_bit(r);
return tx_mode;
}
static void read_tx_probs(struct tx_probs *tx_probs, vp9_reader *r) {
int i, j;
for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
for (j = 0; j < TX_SIZES - 3; ++j)
vp9_diff_update_prob(r, &tx_probs->p8x8[i][j]);
for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
for (j = 0; j < TX_SIZES - 2; ++j)
vp9_diff_update_prob(r, &tx_probs->p16x16[i][j]);
for (i = 0; i < TX_SIZE_CONTEXTS; ++i)
for (j = 0; j < TX_SIZES - 1; ++j)
vp9_diff_update_prob(r, &tx_probs->p32x32[i][j]);
}
static void read_switchable_interp_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
int i, j;
for (j = 0; j < SWITCHABLE_FILTERS + 1; ++j)
for (i = 0; i < SWITCHABLE_FILTERS - 1; ++i)
vp9_diff_update_prob(r, &fc->switchable_interp_prob[j][i]);
}
static void read_inter_mode_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
int i, j;
for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
for (j = 0; j < INTER_MODES - 1; ++j)
vp9_diff_update_prob(r, &fc->inter_mode_probs[i][j]);
}
static INLINE COMPPREDMODE_TYPE read_comp_pred_mode(vp9_reader *r) {
COMPPREDMODE_TYPE mode = vp9_read_bit(r);
if (mode)
mode += vp9_read_bit(r);
return mode;
}
static void read_comp_pred(VP9_COMMON *cm, vp9_reader *r) {
int i;
const int compound_allowed = is_compound_prediction_allowed(cm);
cm->comp_pred_mode = compound_allowed ? read_comp_pred_mode(r)
: SINGLE_PREDICTION_ONLY;
if (compound_allowed)
setup_compound_prediction(cm);
if (cm->comp_pred_mode == HYBRID_PREDICTION)
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
for (i = 0; i < COMP_INTER_CONTEXTS; i++)
vp9_diff_update_prob(r, &cm->fc.comp_inter_prob[i]);
if (cm->comp_pred_mode != COMP_PREDICTION_ONLY)
for (i = 0; i < REF_CONTEXTS; i++) {
vp9_diff_update_prob(r, &cm->fc.single_ref_prob[i][0]);
vp9_diff_update_prob(r, &cm->fc.single_ref_prob[i][1]);
}
if (cm->comp_pred_mode != SINGLE_PREDICTION_ONLY)
for (i = 0; i < REF_CONTEXTS; i++)
vp9_diff_update_prob(r, &cm->fc.comp_ref_prob[i]);
}
static void update_mv(vp9_reader *r, vp9_prob *p) {
if (vp9_read(r, NMV_UPDATE_PROB))
*p = (vp9_read_literal(r, 7) << 1) | 1;
}
static void read_mv_probs(vp9_reader *r, nmv_context *mvc, int allow_hp) {
int i, j, k;
for (j = 0; j < MV_JOINTS - 1; ++j)
update_mv(r, &mvc->joints[j]);
for (i = 0; i < 2; ++i) {
nmv_component *const comp = &mvc->comps[i];
update_mv(r, &comp->sign);
for (j = 0; j < MV_CLASSES - 1; ++j)
update_mv(r, &comp->classes[j]);
for (j = 0; j < CLASS0_SIZE - 1; ++j)
update_mv(r, &comp->class0[j]);
for (j = 0; j < MV_OFFSET_BITS; ++j)
update_mv(r, &comp->bits[j]);
}
for (i = 0; i < 2; ++i) {
nmv_component *const comp = &mvc->comps[i];
for (j = 0; j < CLASS0_SIZE; ++j)
for (k = 0; k < 3; ++k)
update_mv(r, &comp->class0_fp[j][k]);
for (j = 0; j < 3; ++j)
update_mv(r, &comp->fp[j]);
}
if (allow_hp) {
for (i = 0; i < 2; ++i) {
update_mv(r, &mvc->comps[i].class0_hp);
update_mv(r, &mvc->comps[i].hp);
}
}
}
static void setup_plane_dequants(VP9_COMMON *cm, MACROBLOCKD *xd, int q_index) {
int i;
xd->plane[0].dequant = cm->y_dequant[q_index];
for (i = 1; i < MAX_MB_PLANE; i++)
xd->plane[i].dequant = cm->uv_dequant[q_index];
}
// Allocate storage for each tile column.
// TODO(jzern): when max_threads <= 1 the same storage could be used for each
// tile.
211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280
static void alloc_tile_storage(VP9D_COMP *pbi, int tile_cols) {
VP9_COMMON *const cm = &pbi->common;
const int aligned_mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
int i, tile_col;
CHECK_MEM_ERROR(cm, pbi->mi_streams,
vpx_realloc(pbi->mi_streams, tile_cols *
sizeof(*pbi->mi_streams)));
for (tile_col = 0; tile_col < tile_cols; ++tile_col) {
TileInfo tile;
vp9_tile_init(&tile, cm, 0, tile_col);
pbi->mi_streams[tile_col] =
&cm->mi[cm->mi_rows * tile.mi_col_start];
}
// 2 contexts per 'mi unit', so that we have one context per 4x4 txfm
// block where mi unit size is 8x8.
CHECK_MEM_ERROR(cm, pbi->above_context[0],
vpx_realloc(pbi->above_context[0],
sizeof(*pbi->above_context[0]) * MAX_MB_PLANE *
2 * aligned_mi_cols));
for (i = 1; i < MAX_MB_PLANE; ++i) {
pbi->above_context[i] = pbi->above_context[0] +
i * sizeof(*pbi->above_context[0]) *
2 * aligned_mi_cols;
}
// This is sized based on the entire frame. Each tile operates within its
// column bounds.
CHECK_MEM_ERROR(cm, pbi->above_seg_context,
vpx_realloc(pbi->above_seg_context,
sizeof(*pbi->above_seg_context) *
aligned_mi_cols));
}
static void decode_block(int plane, int block, BLOCK_SIZE plane_bsize,
TX_SIZE tx_size, void *arg) {
MACROBLOCKD* const xd = arg;
struct macroblockd_plane *const pd = &xd->plane[plane];
int16_t* const qcoeff = BLOCK_OFFSET(pd->qcoeff, block);
const int stride = pd->dst.stride;
const int eob = pd->eobs[block];
if (eob > 0) {
TX_TYPE tx_type;
const int raster_block = txfrm_block_to_raster_block(plane_bsize, tx_size,
block);
uint8_t* const dst = raster_block_offset_uint8(plane_bsize, raster_block,
pd->dst.buf, stride);
switch (tx_size) {
case TX_4X4:
tx_type = get_tx_type_4x4(pd->plane_type, xd, raster_block);
if (tx_type == DCT_DCT)
xd->itxm_add(qcoeff, dst, stride, eob);
else
vp9_iht4x4_add(tx_type, qcoeff, dst, stride, eob);
break;
case TX_8X8:
tx_type = get_tx_type_8x8(pd->plane_type, xd);
vp9_iht8x8_add(tx_type, qcoeff, dst, stride, eob);
break;
case TX_16X16:
tx_type = get_tx_type_16x16(pd->plane_type, xd);
vp9_iht16x16_add(tx_type, qcoeff, dst, stride, eob);
break;
case TX_32X32:
tx_type = DCT_DCT;
vp9_idct32x32_add(qcoeff, dst, stride, eob);
break;
default:
281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350
assert(!"Invalid transform size");
}
if (eob == 1) {
vpx_memset(qcoeff, 0, 2 * sizeof(qcoeff[0]));
} else {
if (tx_type == DCT_DCT && tx_size <= TX_16X16 && eob <= 10)
vpx_memset(qcoeff, 0, 4 * (4 << tx_size) * sizeof(qcoeff[0]));
else
vpx_memset(qcoeff, 0, (16 << (tx_size << 1)) * sizeof(qcoeff[0]));
}
}
}
static void decode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
TX_SIZE tx_size, void *arg) {
MACROBLOCKD* const xd = arg;
struct macroblockd_plane *const pd = &xd->plane[plane];
MODE_INFO *const mi = xd->mi_8x8[0];
const int raster_block = txfrm_block_to_raster_block(plane_bsize, tx_size,
block);
uint8_t* const dst = raster_block_offset_uint8(plane_bsize, raster_block,
pd->dst.buf, pd->dst.stride);
const MB_PREDICTION_MODE mode = (plane == 0)
? ((mi->mbmi.sb_type < BLOCK_8X8) ? mi->bmi[raster_block].as_mode
: mi->mbmi.mode)
: mi->mbmi.uv_mode;
if (xd->mb_to_right_edge < 0 || xd->mb_to_bottom_edge < 0)
extend_for_intra(xd, plane_bsize, plane, block, tx_size);
vp9_predict_intra_block(xd, raster_block >> tx_size,
b_width_log2(plane_bsize), tx_size, mode,
dst, pd->dst.stride, dst, pd->dst.stride);
if (!mi->mbmi.skip_coeff)
decode_block(plane, block, plane_bsize, tx_size, arg);
}
static int decode_tokens(VP9_COMMON *const cm, MACROBLOCKD *const xd,
BLOCK_SIZE bsize, vp9_reader *r) {
MB_MODE_INFO *const mbmi = &xd->mi_8x8[0]->mbmi;
if (mbmi->skip_coeff) {
reset_skip_context(xd, bsize);
return -1;
} else {
if (cm->seg.enabled)
setup_plane_dequants(cm, xd, vp9_get_qindex(&cm->seg, mbmi->segment_id,
cm->base_qindex));
// TODO(dkovalev) if (!vp9_reader_has_error(r))
return vp9_decode_tokens(cm, xd, &cm->seg, r, bsize);
}
}
static void set_offsets(VP9_COMMON *const cm, MACROBLOCKD *const xd,
const TileInfo *const tile,
BLOCK_SIZE bsize, int mi_row, int mi_col) {
const int bh = num_8x8_blocks_high_lookup[bsize];
const int bw = num_8x8_blocks_wide_lookup[bsize];
const int offset = mi_row * cm->mode_info_stride + mi_col;
xd->mode_info_stride = cm->mode_info_stride;
xd->mi_8x8 = cm->mi_grid_visible + offset;
xd->prev_mi_8x8 = cm->prev_mi_grid_visible + offset;
// we are using the mode info context stream here
xd->mi_8x8[0] = xd->mi_stream;
351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420
xd->mi_8x8[0]->mbmi.sb_type = bsize;
++xd->mi_stream;
// Special case: if prev_mi is NULL, the previous mode info context
// cannot be used.
xd->last_mi = cm->prev_mi ? xd->prev_mi_8x8[0] : NULL;
set_skip_context(xd, xd->above_context, xd->left_context, mi_row, mi_col);
// Distance of Mb to the various image edges. These are specified to 8th pel
// as they are always compared to values that are in 1/8th pel units
set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols);
setup_dst_planes(xd, get_frame_new_buffer(cm), mi_row, mi_col);
}
static void set_ref(VP9_COMMON *const cm, MACROBLOCKD *const xd,
int idx, int mi_row, int mi_col) {
MB_MODE_INFO *const mbmi = &xd->mi_8x8[0]->mbmi;
const int ref = mbmi->ref_frame[idx] - LAST_FRAME;
const YV12_BUFFER_CONFIG *cfg = get_frame_ref_buffer(cm, ref);
const struct scale_factors_common *sfc = &cm->active_ref_scale_comm[ref];
if (!vp9_is_valid_scale(sfc))
vpx_internal_error(&cm->error, VPX_CODEC_UNSUP_BITSTREAM,
"Invalid scale factors");
xd->scale_factor[idx].sfc = sfc;
setup_pre_planes(xd, idx, cfg, mi_row, mi_col, &xd->scale_factor[idx]);
xd->corrupted |= cfg->corrupted;
}
static void decode_modes_b(VP9_COMMON *const cm, MACROBLOCKD *const xd,
const TileInfo *const tile,
int mi_row, int mi_col,
vp9_reader *r, BLOCK_SIZE bsize, int index) {
const int less8x8 = bsize < BLOCK_8X8;
MB_MODE_INFO *mbmi;
int eobtotal;
if (less8x8)
if (index > 0)
return;
set_offsets(cm, xd, tile, bsize, mi_row, mi_col);
vp9_read_mode_info(cm, xd, tile, mi_row, mi_col, r);
if (less8x8)
bsize = BLOCK_8X8;
// Has to be called after set_offsets
mbmi = &xd->mi_8x8[0]->mbmi;
eobtotal = decode_tokens(cm, xd, bsize, r);
if (!is_inter_block(mbmi)) {
// Intra reconstruction
foreach_transformed_block(xd, bsize, decode_block_intra, xd);
} else {
// Inter reconstruction
const int decode_blocks = (eobtotal > 0);
if (!less8x8) {
assert(mbmi->sb_type == bsize);
if (eobtotal == 0)
mbmi->skip_coeff = 1; // skip loopfilter
}
set_ref(cm, xd, 0, mi_row, mi_col);
if (has_second_ref(mbmi))
set_ref(cm, xd, 1, mi_row, mi_col);