#include "vp9/decoder/vp9_detokenize.h"
#include "vp9/decoder/vp9_decodemv.h"
#include "vp9/decoder/vp9_dsubexp.h"
+#include "vp9/decoder/vp9_dthread.h"
#include "vp9/decoder/vp9_onyxd_int.h"
#include "vp9/decoder/vp9_read_bit_buffer.h"
#include "vp9/decoder/vp9_reader.h"
#include "vp9/decoder/vp9_thread.h"
-typedef struct TileWorkerData {
- VP9_COMMON *cm;
- vp9_reader bit_reader;
- DECLARE_ALIGNED(16, MACROBLOCKD, xd);
- DECLARE_ALIGNED(16, int16_t, dqcoeff[MAX_MB_PLANE][64 * 64]);
-} TileWorkerData;
-
static int read_be32(const uint8_t *p) {
return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
}
dst, pd->dst.stride, dst, pd->dst.stride,
x, y, plane);
- if (!mi->mbmi.skip_coeff) {
+ if (!mi->mbmi.skip) {
const int eob = vp9_decode_block_tokens(cm, xd, plane, block,
plane_bsize, x, y, tx_size,
args->r);
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 *sf = &cm->active_ref_scale[ref];
-
- xd->ref_buf[idx] = cfg;
- if (!vp9_is_valid_scale(sf))
+ RefBuffer *ref_buffer = &cm->frame_refs[mbmi->ref_frame[idx] - LAST_FRAME];
+ xd->block_refs[idx] = ref_buffer;
+ if (!vp9_is_valid_scale(&ref_buffer->sf))
vpx_internal_error(&cm->error, VPX_CODEC_UNSUP_BITSTREAM,
"Invalid scale factors");
-
- xd->scale_factors[idx] = sf;
- setup_pre_planes(xd, idx, cfg, mi_row, mi_col, xd->scale_factors[idx]);
- xd->corrupted |= cfg->corrupted;
+ setup_pre_planes(xd, idx, ref_buffer->buf, mi_row, mi_col, &ref_buffer->sf);
+ xd->corrupted |= ref_buffer->buf->corrupted;
}
static void decode_modes_b(VP9_COMMON *const cm, MACROBLOCKD *const xd,
// Has to be called after set_offsets
mbmi = &xd->mi_8x8[0]->mbmi;
- if (mbmi->skip_coeff) {
+ if (mbmi->skip) {
reset_skip_context(xd, bsize);
} else {
if (cm->seg.enabled)
if (!is_inter_block(mbmi)) {
struct intra_args arg = { cm, xd, r };
- foreach_transformed_block(xd, bsize, predict_and_reconstruct_intra_block,
- &arg);
+ vp9_foreach_transformed_block(xd, bsize,
+ predict_and_reconstruct_intra_block, &arg);
} else {
// Setup
set_ref(cm, xd, 0, mi_row, mi_col);
if (has_second_ref(mbmi))
set_ref(cm, xd, 1, mi_row, mi_col);
- xd->subpix.filter_x = xd->subpix.filter_y =
- vp9_get_filter_kernel(mbmi->interp_filter);
+ xd->interp_kernel = vp9_get_interp_kernel(mbmi->interp_filter);
// Prediction
vp9_dec_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
// Reconstruction
- if (!mbmi->skip_coeff) {
+ if (!mbmi->skip) {
int eobtotal = 0;
struct inter_args arg = { cm, xd, r, &eobtotal };
- foreach_transformed_block(xd, bsize, reconstruct_inter_block, &arg);
+ vp9_foreach_transformed_block(xd, bsize, reconstruct_inter_block, &arg);
if (!less8x8 && eobtotal == 0)
- mbmi->skip_coeff = 1; // skip loopfilter
+ mbmi->skip = 1; // skip loopfilter
}
}
xd->itxm_add = xd->lossless ? vp9_iwht4x4_add : vp9_idct4x4_add;
}
-static INTERPOLATION_TYPE read_interp_filter_type(
- struct vp9_read_bit_buffer *rb) {
- const INTERPOLATION_TYPE literal_to_type[] = { EIGHTTAP_SMOOTH,
- EIGHTTAP,
- EIGHTTAP_SHARP,
- BILINEAR };
+static INTERP_FILTER read_interp_filter(struct vp9_read_bit_buffer *rb) {
+ const INTERP_FILTER literal_to_filter[] = { EIGHTTAP_SMOOTH,
+ EIGHTTAP,
+ EIGHTTAP_SHARP,
+ BILINEAR };
return vp9_rb_read_bit(rb) ? SWITCHABLE
- : literal_to_type[vp9_rb_read_literal(rb, 2)];
+ : literal_to_filter[vp9_rb_read_literal(rb, 2)];
}
static void read_frame_size(struct vp9_read_bit_buffer *rb,
vp9_update_frame_size(cm);
}
- if (cm->fb_list != NULL) {
- vpx_codec_frame_buffer_t *const ext_fb = &cm->fb_list[cm->new_fb_idx];
- if (vp9_realloc_frame_buffer(get_frame_new_buffer(cm),
- cm->width, cm->height,
- cm->subsampling_x, cm->subsampling_y,
- VP9BORDERINPIXELS, ext_fb,
- cm->realloc_fb_cb, cm->user_priv)) {
- vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
- "Failed to allocate external frame buffer");
- }
- } else {
- vp9_realloc_frame_buffer(get_frame_new_buffer(cm), cm->width, cm->height,
- cm->subsampling_x, cm->subsampling_y,
- VP9BORDERINPIXELS, NULL, NULL, NULL);
+ if (vp9_realloc_frame_buffer(
+ get_frame_new_buffer(cm), cm->width, cm->height,
+ cm->subsampling_x, cm->subsampling_y, VP9_DEC_BORDER_IN_PIXELS,
+ &cm->frame_bufs[cm->new_fb_idx].raw_frame_buffer, cm->get_fb_cb,
+ cm->cb_priv)) {
+ vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
+ "Failed to allocate frame buffer");
}
}
int found = 0, i;
for (i = 0; i < REFS_PER_FRAME; ++i) {
if (vp9_rb_read_bit(rb)) {
- YV12_BUFFER_CONFIG *const cfg = get_frame_ref_buffer(cm, i);
- width = cfg->y_crop_width;
- height = cfg->y_crop_height;
+ YV12_BUFFER_CONFIG *const buf = cm->frame_refs[i].buf;
+ width = buf->y_crop_width;
+ height = buf->y_crop_height;
found = 1;
break;
}
if (!found)
read_frame_size(rb, &width, &height);
- if (!width || !height)
+ if (width <= 0 || height <= 0)
vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
"Referenced frame with invalid size");
++pbi->num_tile_workers;
vp9_worker_init(worker);
- worker->hook = (VP9WorkerHook)tile_worker_hook;
CHECK_MEM_ERROR(cm, worker->data1,
vpx_memalign(32, sizeof(TileWorkerData)));
CHECK_MEM_ERROR(cm, worker->data2, vpx_malloc(sizeof(TileInfo)));
}
}
+ // Reset tile decoding hook
+ for (n = 0; n < pbi->num_tile_workers; ++n) {
+ pbi->tile_workers[n].hook = (VP9WorkerHook)tile_worker_hook;
+ }
+
// Note: this memset assumes above_context[0], [1] and [2]
// are allocated as part of the same buffer.
vpx_memset(pbi->above_context[0], 0,
cm->version = vp9_rb_read_bit(rb);
RESERVED;
- if (vp9_rb_read_bit(rb)) {
- // show an existing frame directly
- int frame_to_show = cm->ref_frame_map[vp9_rb_read_literal(rb, 3)];
- ref_cnt_fb(cm->fb_idx_ref_cnt, &cm->new_fb_idx, frame_to_show);
+ cm->show_existing_frame = vp9_rb_read_bit(rb);
+ if (cm->show_existing_frame) {
+ // Show an existing frame directly.
+ const int frame_to_show = cm->ref_frame_map[vp9_rb_read_literal(rb, 3)];
+ ref_cnt_fb(cm->frame_bufs, &cm->new_fb_idx, frame_to_show);
pbi->refresh_frame_flags = 0;
cm->lf.filter_level = 0;
+ cm->show_frame = 1;
return 0;
}
pbi->refresh_frame_flags = (1 << REF_FRAMES) - 1;
- for (i = 0; i < REFS_PER_FRAME; ++i)
- cm->active_ref_idx[i] = cm->new_fb_idx;
+ for (i = 0; i < REFS_PER_FRAME; ++i) {
+ cm->frame_refs[i].idx = cm->new_fb_idx;
+ cm->frame_refs[i].buf = get_frame_new_buffer(cm);
+ }
setup_frame_size(pbi, rb);
} else {
for (i = 0; i < REFS_PER_FRAME; ++i) {
const int ref = vp9_rb_read_literal(rb, REF_FRAMES_LOG2);
- cm->active_ref_idx[i] = cm->ref_frame_map[ref];
+ const int idx = cm->ref_frame_map[ref];
+ cm->frame_refs[i].idx = idx;
+ cm->frame_refs[i].buf = &cm->frame_bufs[idx].buf;
cm->ref_frame_sign_bias[LAST_FRAME + i] = vp9_rb_read_bit(rb);
}
setup_frame_size_with_refs(pbi, rb);
cm->allow_high_precision_mv = vp9_rb_read_bit(rb);
- cm->mcomp_filter_type = read_interp_filter_type(rb);
+ cm->interp_filter = read_interp_filter(rb);
for (i = 0; i < REFS_PER_FRAME; ++i) {
- vp9_setup_scale_factors(cm, i);
- if (vp9_is_scaled(&cm->active_ref_scale[i]))
- vp9_extend_frame_borders(&cm->yv12_fb[cm->active_ref_idx[i]],
+ RefBuffer *const ref_buf = &cm->frame_refs[i];
+ vp9_setup_scale_factors_for_frame(&ref_buf->sf,
+ ref_buf->buf->y_crop_width,
+ ref_buf->buf->y_crop_height,
+ cm->width, cm->height);
+ if (vp9_is_scaled(&ref_buf->sf))
+ vp9_extend_frame_borders(ref_buf->buf,
cm->subsampling_x, cm->subsampling_y);
}
}
read_tx_mode_probs(&fc->tx_probs, &r);
read_coef_probs(fc, cm->tx_mode, &r);
- for (k = 0; k < MBSKIP_CONTEXTS; ++k)
- vp9_diff_update_prob(&r, &fc->mbskip_probs[k]);
+ for (k = 0; k < SKIP_CONTEXTS; ++k)
+ vp9_diff_update_prob(&r, &fc->skip_probs[k]);
if (!frame_is_intra_only(cm)) {
nmv_context *const nmvc = &fc->nmvc;
read_inter_mode_probs(fc, &r);
- if (cm->mcomp_filter_type == SWITCHABLE)
+ if (cm->interp_filter == SWITCHABLE)
read_switchable_interp_probs(fc, &r);
for (i = 0; i < INTRA_INTER_CONTEXTS; i++)
assert(!memcmp(cm->counts.comp_ref, zero_counts.comp_ref,
sizeof(cm->counts.comp_ref)));
assert(!memcmp(&cm->counts.tx, &zero_counts.tx, sizeof(cm->counts.tx)));
- assert(!memcmp(cm->counts.mbskip, zero_counts.mbskip,
- sizeof(cm->counts.mbskip)));
+ assert(!memcmp(cm->counts.skip, zero_counts.skip, sizeof(cm->counts.skip)));
assert(!memcmp(&cm->counts.mv, &zero_counts.mv, sizeof(cm->counts.mv)));
}
#endif // NDEBUG
set_prev_mi(cm);
setup_plane_dequants(cm, xd, cm->base_qindex);
- setup_block_dptrs(xd, cm->subsampling_x, cm->subsampling_y);
+ vp9_setup_block_planes(xd, cm->subsampling_x, cm->subsampling_y);
cm->fc = cm->frame_contexts[cm->frame_context_idx];
vp9_zero(cm->counts);
*p_data_end = decode_tiles(pbi, data + first_partition_size);
}
- cm->last_width = cm->width;
- cm->last_height = cm->height;
-
new_fb->corrupted |= xd->corrupted;
if (!pbi->decoded_key_frame) {
projects / platform / framework / web / crosswalk.git / blobdiff