summaryrefslogtreecommitdiff
path: root/vp9
diff options
context:
space:
mode:
Diffstat (limited to 'vp9')
-rw-r--r--vp9/common/vp9_idct.c37
-rw-r--r--vp9/common/vp9_postproc.c1
-rw-r--r--vp9/common/vp9_rtcd_defs.pl27
-rw-r--r--vp9/common/vp9_textblit.c119
-rw-r--r--vp9/common/vp9_textblit.h27
-rw-r--r--vp9/decoder/vp9_decodeframe.c91
-rw-r--r--vp9/decoder/vp9_decodemv.c8
-rw-r--r--vp9/decoder/vp9_decodemv.h4
-rw-r--r--vp9/decoder/vp9_detokenize.c155
-rw-r--r--vp9/decoder/vp9_detokenize.h4
-rw-r--r--vp9/encoder/vp9_encodemv.c5
-rw-r--r--vp9/encoder/vp9_picklpf.c4
-rw-r--r--vp9/vp9_common.mk2
-rw-r--r--vp9/vp9_dx_iface.c11
14 files changed, 207 insertions, 288 deletions
diff --git a/vp9/common/vp9_idct.c b/vp9/common/vp9_idct.c
index ff7c1dd3f..dc2e03946 100644
--- a/vp9/common/vp9_idct.c
+++ b/vp9/common/vp9_idct.c
@@ -139,8 +139,6 @@ void vp9_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
// The calculation can be simplified if there are not many non-zero dct
// coefficients. Use eobs to decide what to do.
- // TODO(yunqingwang): "eobs = 1" case is also handled in vp9_short_idct8x8_c.
- // Combine that with code here.
if (eob == 1)
// DC only DCT coefficient
vpx_idct8x8_1_add(input, dest, stride);
@@ -204,6 +202,18 @@ void vp9_iht16x16_add(TX_TYPE tx_type, const tran_low_t *input, uint8_t *dest,
}
#if CONFIG_VP9_HIGHBITDEPTH
+
+// 12 signal input bits + 7 forward transform amplify bits + 1 bit
+// for contingency in rounding and quantizing
+#define VALID_IHT_MAGNITUDE_RANGE (1 << 20)
+
+static INLINE int detect_invalid_iht_input(const tran_low_t *input, int size) {
+ int i;
+ for (i = 0; i < size; ++i)
+ if (abs(input[i]) >= VALID_IHT_MAGNITUDE_RANGE) return 1;
+ return 0;
+}
+
void vp9_highbd_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int tx_type, int bd) {
const highbd_transform_2d IHT_4[] = {
@@ -219,6 +229,13 @@ void vp9_highbd_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
tran_low_t *outptr = out;
tran_low_t temp_in[4], temp_out[4];
+ if (detect_invalid_iht_input(input, 16)) {
+#if CONFIG_COEFFICIENT_RANGE_CHECKING
+ assert(0 && "invalid highbd iht input");
+#endif // CONFIG_COEFFICIENT_RANGE_CHECKING
+ return;
+ }
+
// Inverse transform row vectors.
for (i = 0; i < 4; ++i) {
IHT_4[tx_type].rows(input, outptr, bd);
@@ -253,6 +270,13 @@ void vp9_highbd_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
const highbd_transform_2d ht = HIGH_IHT_8[tx_type];
uint16_t *dest = CONVERT_TO_SHORTPTR(dest8);
+ if (detect_invalid_iht_input(input, 64)) {
+#if CONFIG_COEFFICIENT_RANGE_CHECKING
+ assert(0 && "invalid highbd iht input");
+#endif // CONFIG_COEFFICIENT_RANGE_CHECKING
+ return;
+ }
+
// Inverse transform row vectors.
for (i = 0; i < 8; ++i) {
ht.rows(input, outptr, bd);
@@ -287,6 +311,13 @@ void vp9_highbd_iht16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
const highbd_transform_2d ht = HIGH_IHT_16[tx_type];
uint16_t *dest = CONVERT_TO_SHORTPTR(dest8);
+ if (detect_invalid_iht_input(input, 256)) {
+#if CONFIG_COEFFICIENT_RANGE_CHECKING
+ assert(0 && "invalid highbd iht input");
+#endif // CONFIG_COEFFICIENT_RANGE_CHECKING
+ return;
+ }
+
// Rows
for (i = 0; i < 16; ++i) {
ht.rows(input, outptr, bd);
@@ -329,8 +360,6 @@ void vp9_highbd_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
// The calculation can be simplified if there are not many non-zero dct
// coefficients. Use eobs to decide what to do.
- // TODO(yunqingwang): "eobs = 1" case is also handled in vp9_short_idct8x8_c.
- // Combine that with code here.
// DC only DCT coefficient
if (eob == 1) {
vpx_highbd_idct8x8_1_add(input, dest, stride, bd);
diff --git a/vp9/common/vp9_postproc.c b/vp9/common/vp9_postproc.c
index b6ae10b1b..b105e5d45 100644
--- a/vp9/common/vp9_postproc.c
+++ b/vp9/common/vp9_postproc.c
@@ -26,7 +26,6 @@
#include "vp9/common/vp9_onyxc_int.h"
#include "vp9/common/vp9_postproc.h"
-#include "vp9/common/vp9_textblit.h"
#if CONFIG_VP9_POSTPROC
diff --git a/vp9/common/vp9_rtcd_defs.pl b/vp9/common/vp9_rtcd_defs.pl
index f315a3b85..37a867323 100644
--- a/vp9/common/vp9_rtcd_defs.pl
+++ b/vp9/common/vp9_rtcd_defs.pl
@@ -92,33 +92,6 @@ if (vpx_config("CONFIG_VP9_HIGHBITDEPTH") eq "yes") {
# High bitdepth functions
if (vpx_config("CONFIG_VP9_HIGHBITDEPTH") eq "yes") {
#
- # Sub Pixel Filters
- #
- add_proto qw/void vp9_highbd_convolve_copy/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
- specialize qw/vp9_highbd_convolve_copy/;
-
- add_proto qw/void vp9_highbd_convolve_avg/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
- specialize qw/vp9_highbd_convolve_avg/;
-
- add_proto qw/void vp9_highbd_convolve8/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
- specialize qw/vp9_highbd_convolve8/, "$sse2_x86_64";
-
- add_proto qw/void vp9_highbd_convolve8_horiz/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
- specialize qw/vp9_highbd_convolve8_horiz/, "$sse2_x86_64";
-
- add_proto qw/void vp9_highbd_convolve8_vert/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
- specialize qw/vp9_highbd_convolve8_vert/, "$sse2_x86_64";
-
- add_proto qw/void vp9_highbd_convolve8_avg/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
- specialize qw/vp9_highbd_convolve8_avg/, "$sse2_x86_64";
-
- add_proto qw/void vp9_highbd_convolve8_avg_horiz/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
- specialize qw/vp9_highbd_convolve8_avg_horiz/, "$sse2_x86_64";
-
- add_proto qw/void vp9_highbd_convolve8_avg_vert/, "const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps";
- specialize qw/vp9_highbd_convolve8_avg_vert/, "$sse2_x86_64";
-
- #
# post proc
#
if (vpx_config("CONFIG_VP9_POSTPROC") eq "yes") {
diff --git a/vp9/common/vp9_textblit.c b/vp9/common/vp9_textblit.c
deleted file mode 100644
index 9940137ca..000000000
--- a/vp9/common/vp9_textblit.c
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * 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 <stdlib.h>
-
-#include "vp9/common/vp9_textblit.h"
-
-static const int font[] = {
- 0x0, 0x5C00, 0x8020, 0xAFABEA, 0xD7EC0, 0x1111111, 0x1855740,
- 0x18000, 0x45C0, 0x74400, 0x51140, 0x23880, 0xC4000, 0x21080,
- 0x80000, 0x111110, 0xE9D72E, 0x87E40, 0x12AD732, 0xAAD62A, 0x4F94C4,
- 0x4D6B7, 0x456AA, 0x3E8423, 0xAAD6AA, 0xAAD6A2, 0x2800, 0x2A00,
- 0x8A880, 0x52940, 0x22A20, 0x15422, 0x6AD62E, 0x1E4A53E, 0xAAD6BF,
- 0x8C62E, 0xE8C63F, 0x118D6BF, 0x1094BF, 0xCAC62E, 0x1F2109F, 0x118FE31,
- 0xF8C628, 0x8A89F, 0x108421F, 0x1F1105F, 0x1F4105F, 0xE8C62E, 0x2294BF,
- 0x164C62E, 0x12694BF, 0x8AD6A2, 0x10FC21, 0x1F8421F, 0x744107, 0xF8220F,
- 0x1151151, 0x117041, 0x119D731, 0x47E0, 0x1041041, 0xFC400, 0x10440,
- 0x1084210, 0x820
-};
-
-static void plot(int x, int y, unsigned char *image, int pitch) {
- image[x + y * pitch] ^= 255;
-}
-
-void vp9_blit_text(const char *msg, unsigned char *address, const int pitch) {
- int letter_bitmap;
- unsigned char *output_pos = address;
- int colpos = 0;
-
- while (msg[colpos] != 0) {
- char letter = msg[colpos];
- int fontcol, fontrow;
-
- if (letter <= 'Z' && letter >= ' ')
- letter_bitmap = font[letter - ' '];
- else if (letter <= 'z' && letter >= 'a')
- letter_bitmap = font[letter - 'a' + 'A' - ' '];
- else
- letter_bitmap = font[0];
-
- for (fontcol = 6; fontcol >= 0; fontcol--)
- for (fontrow = 0; fontrow < 5; fontrow++)
- output_pos[fontrow * pitch + fontcol] =
- ((letter_bitmap >> (fontcol * 5)) & (1 << fontrow) ? 255 : 0);
-
- output_pos += 7;
- colpos++;
- }
-}
-
-/* Bresenham line algorithm */
-void vp9_blit_line(int x0, int x1, int y0, int y1, unsigned char *image,
- int pitch) {
- int steep = abs(y1 - y0) > abs(x1 - x0);
- int deltax, deltay;
- int error, ystep, y, x;
-
- if (steep) {
- int t;
- t = x0;
- x0 = y0;
- y0 = t;
-
- t = x1;
- x1 = y1;
- y1 = t;
- }
-
- if (x0 > x1) {
- int t;
- t = x0;
- x0 = x1;
- x1 = t;
-
- t = y0;
- y0 = y1;
- y1 = t;
- }
-
- deltax = x1 - x0;
- deltay = abs(y1 - y0);
- error = deltax / 2;
-
- y = y0;
-
- if (y0 < y1)
- ystep = 1;
- else
- ystep = -1;
-
- if (steep) {
- for (x = x0; x <= x1; x++) {
- plot(y, x, image, pitch);
-
- error = error - deltay;
- if (error < 0) {
- y = y + ystep;
- error = error + deltax;
- }
- }
- } else {
- for (x = x0; x <= x1; x++) {
- plot(x, y, image, pitch);
-
- error = error - deltay;
- if (error < 0) {
- y = y + ystep;
- error = error + deltax;
- }
- }
- }
-}
diff --git a/vp9/common/vp9_textblit.h b/vp9/common/vp9_textblit.h
deleted file mode 100644
index 158ec1b37..000000000
--- a/vp9/common/vp9_textblit.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * 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.
- */
-
-#ifndef VP9_COMMON_VP9_TEXTBLIT_H_
-#define VP9_COMMON_VP9_TEXTBLIT_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void vp9_blit_text(const char *msg, unsigned char *address, int pitch);
-
-void vp9_blit_line(int x0, int x1, int y0, int y1, unsigned char *image,
- int pitch);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif // VP9_COMMON_VP9_TEXTBLIT_H_
diff --git a/vp9/decoder/vp9_decodeframe.c b/vp9/decoder/vp9_decodeframe.c
index af2c900e6..fde0b7e31 100644
--- a/vp9/decoder/vp9_decodeframe.c
+++ b/vp9/decoder/vp9_decodeframe.c
@@ -318,11 +318,11 @@ static void inverse_transform_block_intra(MACROBLOCKD *xd, int plane,
}
}
-static void predict_and_reconstruct_intra_block(MACROBLOCKD *const xd,
- vpx_reader *r,
+static void predict_and_reconstruct_intra_block(TileWorkerData *twd,
MODE_INFO *const mi, int plane,
int row, int col,
TX_SIZE tx_size) {
+ MACROBLOCKD *const xd = &twd->xd;
struct macroblockd_plane *const pd = &xd->plane[plane];
PREDICTION_MODE mode = (plane == 0) ? mi->mode : mi->uv_mode;
uint8_t *dst;
@@ -340,7 +340,7 @@ static void predict_and_reconstruct_intra_block(MACROBLOCKD *const xd,
const scan_order *sc = (plane || xd->lossless)
? &vp9_default_scan_orders[tx_size]
: &vp9_scan_orders[tx_size][tx_type];
- const int eob = vp9_decode_block_tokens(xd, plane, sc, col, row, tx_size, r,
+ const int eob = vp9_decode_block_tokens(twd, plane, sc, col, row, tx_size,
mi->segment_id);
if (eob > 0) {
inverse_transform_block_intra(xd, plane, tx_type, tx_size, dst,
@@ -349,12 +349,13 @@ static void predict_and_reconstruct_intra_block(MACROBLOCKD *const xd,
}
}
-static int reconstruct_inter_block(MACROBLOCKD *const xd, vpx_reader *r,
- MODE_INFO *const mi, int plane, int row,
- int col, TX_SIZE tx_size) {
+static int reconstruct_inter_block(TileWorkerData *twd, MODE_INFO *const mi,
+ int plane, int row, int col,
+ TX_SIZE tx_size) {
+ MACROBLOCKD *const xd = &twd->xd;
struct macroblockd_plane *const pd = &xd->plane[plane];
const scan_order *sc = &vp9_default_scan_orders[tx_size];
- const int eob = vp9_decode_block_tokens(xd, plane, sc, col, row, tx_size, r,
+ const int eob = vp9_decode_block_tokens(twd, plane, sc, col, row, tx_size,
mi->segment_id);
if (eob > 0) {
@@ -761,15 +762,16 @@ static MODE_INFO *set_offsets(VP9_COMMON *const cm, MACROBLOCKD *const xd,
return xd->mi[0];
}
-static void decode_block(VP9Decoder *const pbi, MACROBLOCKD *const xd,
- int mi_row, int mi_col, vpx_reader *r,
- BLOCK_SIZE bsize, int bwl, int bhl) {
+static void decode_block(TileWorkerData *twd, VP9Decoder *const pbi, int mi_row,
+ int mi_col, BLOCK_SIZE bsize, int bwl, int bhl) {
VP9_COMMON *const cm = &pbi->common;
const int less8x8 = bsize < BLOCK_8X8;
const int bw = 1 << (bwl - 1);
const int bh = 1 << (bhl - 1);
const int x_mis = VPXMIN(bw, cm->mi_cols - mi_col);
const int y_mis = VPXMIN(bh, cm->mi_rows - mi_row);
+ vpx_reader *r = &twd->bit_reader;
+ MACROBLOCKD *const xd = &twd->xd;
MODE_INFO *mi = set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis,
y_mis, bwl, bhl);
@@ -782,7 +784,7 @@ static void decode_block(VP9Decoder *const pbi, MACROBLOCKD *const xd,
"Invalid block size.");
}
- vp9_read_mode_info(pbi, xd, mi_row, mi_col, r, x_mis, y_mis);
+ vp9_read_mode_info(twd, pbi, mi_row, mi_col, x_mis, y_mis);
if (mi->skip) {
dec_reset_skip_context(xd);
@@ -811,7 +813,7 @@ static void decode_block(VP9Decoder *const pbi, MACROBLOCKD *const xd,
for (row = 0; row < max_blocks_high; row += step)
for (col = 0; col < max_blocks_wide; col += step)
- predict_and_reconstruct_intra_block(xd, r, mi, plane, row, col,
+ predict_and_reconstruct_intra_block(twd, mi, plane, row, col,
tx_size);
}
} else {
@@ -845,7 +847,7 @@ static void decode_block(VP9Decoder *const pbi, MACROBLOCKD *const xd,
for (row = 0; row < max_blocks_high; row += step)
for (col = 0; col < max_blocks_wide; col += step)
eobtotal +=
- reconstruct_inter_block(xd, r, mi, plane, row, col, tx_size);
+ reconstruct_inter_block(twd, mi, plane, row, col, tx_size);
}
if (!less8x8 && eobtotal == 0) mi->skip = 1; // skip loopfilter
@@ -859,10 +861,11 @@ static void decode_block(VP9Decoder *const pbi, MACROBLOCKD *const xd,
}
}
-static INLINE int dec_partition_plane_context(const MACROBLOCKD *xd, int mi_row,
+static INLINE int dec_partition_plane_context(TileWorkerData *twd, int mi_row,
int mi_col, int bsl) {
- const PARTITION_CONTEXT *above_ctx = xd->above_seg_context + mi_col;
- const PARTITION_CONTEXT *left_ctx = xd->left_seg_context + (mi_row & MI_MASK);
+ const PARTITION_CONTEXT *above_ctx = twd->xd.above_seg_context + mi_col;
+ const PARTITION_CONTEXT *left_ctx =
+ twd->xd.left_seg_context + (mi_row & MI_MASK);
int above = (*above_ctx >> bsl) & 1, left = (*left_ctx >> bsl) & 1;
// assert(bsl >= 0);
@@ -870,11 +873,12 @@ static INLINE int dec_partition_plane_context(const MACROBLOCKD *xd, int mi_row,
return (left * 2 + above) + bsl * PARTITION_PLOFFSET;
}
-static INLINE void dec_update_partition_context(MACROBLOCKD *xd, int mi_row,
+static INLINE void dec_update_partition_context(TileWorkerData *twd, int mi_row,
int mi_col, BLOCK_SIZE subsize,
int bw) {
- PARTITION_CONTEXT *const above_ctx = xd->above_seg_context + mi_col;
- PARTITION_CONTEXT *const left_ctx = xd->left_seg_context + (mi_row & MI_MASK);
+ PARTITION_CONTEXT *const above_ctx = twd->xd.above_seg_context + mi_col;
+ PARTITION_CONTEXT *const left_ctx =
+ twd->xd.left_seg_context + (mi_row & MI_MASK);
// update the partition context at the end notes. set partition bits
// of block sizes larger than the current one to be one, and partition
@@ -883,13 +887,14 @@ static INLINE void dec_update_partition_context(MACROBLOCKD *xd, int mi_row,
memset(left_ctx, partition_context_lookup[subsize].left, bw);
}
-static PARTITION_TYPE read_partition(MACROBLOCKD *xd, int mi_row, int mi_col,
- vpx_reader *r, int has_rows, int has_cols,
+static PARTITION_TYPE read_partition(TileWorkerData *twd, int mi_row,
+ int mi_col, int has_rows, int has_cols,
int bsl) {
- const int ctx = dec_partition_plane_context(xd, mi_row, mi_col, bsl);
- const vpx_prob *const probs = get_partition_probs(xd, ctx);
- FRAME_COUNTS *counts = xd->counts;
+ const int ctx = dec_partition_plane_context(twd, mi_row, mi_col, bsl);
+ const vpx_prob *const probs = twd->xd.partition_probs[ctx];
+ FRAME_COUNTS *counts = twd->xd.counts;
PARTITION_TYPE p;
+ vpx_reader *r = &twd->bit_reader;
if (has_rows && has_cols)
p = (PARTITION_TYPE)vpx_read_tree(r, vp9_partition_tree, probs);
@@ -906,9 +911,9 @@ static PARTITION_TYPE read_partition(MACROBLOCKD *xd, int mi_row, int mi_col,
}
// TODO(slavarnway): eliminate bsize and subsize in future commits
-static void decode_partition(VP9Decoder *const pbi, MACROBLOCKD *const xd,
- int mi_row, int mi_col, vpx_reader *r,
- BLOCK_SIZE bsize, int n4x4_l2) {
+static void decode_partition(TileWorkerData *twd, VP9Decoder *const pbi,
+ int mi_row, int mi_col, BLOCK_SIZE bsize,
+ int n4x4_l2) {
VP9_COMMON *const cm = &pbi->common;
const int n8x8_l2 = n4x4_l2 - 1;
const int num_8x8_wh = 1 << n8x8_l2;
@@ -917,39 +922,39 @@ static void decode_partition(VP9Decoder *const pbi, MACROBLOCKD *const xd,
BLOCK_SIZE subsize;
const int has_rows = (mi_row + hbs) < cm->mi_rows;
const int has_cols = (mi_col + hbs) < cm->mi_cols;
+ MACROBLOCKD *const xd = &twd->xd;
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return;
- partition =
- read_partition(xd, mi_row, mi_col, r, has_rows, has_cols, n8x8_l2);
+ partition = read_partition(twd, mi_row, mi_col, has_rows, has_cols, n8x8_l2);
subsize = subsize_lookup[partition][bsize]; // get_subsize(bsize, partition);
if (!hbs) {
// calculate bmode block dimensions (log 2)
xd->bmode_blocks_wl = 1 >> !!(partition & PARTITION_VERT);
xd->bmode_blocks_hl = 1 >> !!(partition & PARTITION_HORZ);
- decode_block(pbi, xd, mi_row, mi_col, r, subsize, 1, 1);
+ decode_block(twd, pbi, mi_row, mi_col, subsize, 1, 1);
} else {
switch (partition) {
case PARTITION_NONE:
- decode_block(pbi, xd, mi_row, mi_col, r, subsize, n4x4_l2, n4x4_l2);
+ decode_block(twd, pbi, mi_row, mi_col, subsize, n4x4_l2, n4x4_l2);
break;
case PARTITION_HORZ:
- decode_block(pbi, xd, mi_row, mi_col, r, subsize, n4x4_l2, n8x8_l2);
+ decode_block(twd, pbi, mi_row, mi_col, subsize, n4x4_l2, n8x8_l2);
if (has_rows)
- decode_block(pbi, xd, mi_row + hbs, mi_col, r, subsize, n4x4_l2,
+ decode_block(twd, pbi, mi_row + hbs, mi_col, subsize, n4x4_l2,
n8x8_l2);
break;
case PARTITION_VERT:
- decode_block(pbi, xd, mi_row, mi_col, r, subsize, n8x8_l2, n4x4_l2);
+ decode_block(twd, pbi, mi_row, mi_col, subsize, n8x8_l2, n4x4_l2);
if (has_cols)
- decode_block(pbi, xd, mi_row, mi_col + hbs, r, subsize, n8x8_l2,
+ decode_block(twd, pbi, mi_row, mi_col + hbs, subsize, n8x8_l2,
n4x4_l2);
break;
case PARTITION_SPLIT:
- decode_partition(pbi, xd, mi_row, mi_col, r, subsize, n8x8_l2);
- decode_partition(pbi, xd, mi_row, mi_col + hbs, r, subsize, n8x8_l2);
- decode_partition(pbi, xd, mi_row + hbs, mi_col, r, subsize, n8x8_l2);
- decode_partition(pbi, xd, mi_row + hbs, mi_col + hbs, r, subsize,
+ decode_partition(twd, pbi, mi_row, mi_col, subsize, n8x8_l2);
+ decode_partition(twd, pbi, mi_row, mi_col + hbs, subsize, n8x8_l2);
+ decode_partition(twd, pbi, mi_row + hbs, mi_col, subsize, n8x8_l2);
+ decode_partition(twd, pbi, mi_row + hbs, mi_col + hbs, subsize,
n8x8_l2);
break;
default: assert(0 && "Invalid partition type");
@@ -959,7 +964,7 @@ static void decode_partition(VP9Decoder *const pbi, MACROBLOCKD *const xd,
// update partition context
if (bsize >= BLOCK_8X8 &&
(bsize == BLOCK_8X8 || partition != PARTITION_SPLIT))
- dec_update_partition_context(xd, mi_row, mi_col, subsize, num_8x8_wh);
+ dec_update_partition_context(twd, mi_row, mi_col, subsize, num_8x8_wh);
}
static void setup_token_decoder(const uint8_t *data, const uint8_t *data_end,
@@ -1442,8 +1447,7 @@ static const uint8_t *decode_tiles(VP9Decoder *pbi, const uint8_t *data,
vp9_zero(tile_data->xd.left_seg_context);
for (mi_col = tile.mi_col_start; mi_col < tile.mi_col_end;
mi_col += MI_BLOCK_SIZE) {
- decode_partition(pbi, &tile_data->xd, mi_row, mi_col,
- &tile_data->bit_reader, BLOCK_64X64, 4);
+ decode_partition(tile_data, pbi, mi_row, mi_col, BLOCK_64X64, 4);
}
pbi->mb.corrupted |= tile_data->xd.corrupted;
if (pbi->mb.corrupted)
@@ -1532,8 +1536,7 @@ static int tile_worker_hook(TileWorkerData *const tile_data,
vp9_zero(tile_data->xd.left_seg_context);
for (mi_col = tile->mi_col_start; mi_col < tile->mi_col_end;
mi_col += MI_BLOCK_SIZE) {
- decode_partition(pbi, &tile_data->xd, mi_row, mi_col,
- &tile_data->bit_reader, BLOCK_64X64, 4);
+ decode_partition(tile_data, pbi, mi_row, mi_col, BLOCK_64X64, 4);
}
}
diff --git a/vp9/decoder/vp9_decodemv.c b/vp9/decoder/vp9_decodemv.c
index 7358c9a39..4372ba037 100644
--- a/vp9/decoder/vp9_decodemv.c
+++ b/vp9/decoder/vp9_decodemv.c
@@ -241,7 +241,7 @@ static int read_mv_component(vpx_reader *r, const nmv_component *mvcomp,
// Integer part
if (class0) {
- d = vpx_read_tree(r, vp9_mv_class0_tree, mvcomp->class0);
+ d = vpx_read(r, mvcomp->class0[0]);
mag = 0;
} else {
int i;
@@ -826,8 +826,10 @@ static INLINE void copy_ref_frame_pair(MV_REFERENCE_FRAME *dst,
memcpy(dst, src, sizeof(*dst) * 2);
}
-void vp9_read_mode_info(VP9Decoder *const pbi, MACROBLOCKD *xd, int mi_row,
- int mi_col, vpx_reader *r, int x_mis, int y_mis) {
+void vp9_read_mode_info(TileWorkerData *twd, VP9Decoder *const pbi, int mi_row,
+ int mi_col, int x_mis, int y_mis) {
+ vpx_reader *r = &twd->bit_reader;
+ MACROBLOCKD *const xd = &twd->xd;
VP9_COMMON *const cm = &pbi->common;
MODE_INFO *const mi = xd->mi[0];
MV_REF *frame_mvs = cm->cur_frame->mvs + mi_row * cm->mi_cols + mi_col;
diff --git a/vp9/decoder/vp9_decodemv.h b/vp9/decoder/vp9_decodemv.h
index 4e11c2fc0..b460cb8fb 100644
--- a/vp9/decoder/vp9_decodemv.h
+++ b/vp9/decoder/vp9_decodemv.h
@@ -19,8 +19,8 @@
extern "C" {
#endif
-void vp9_read_mode_info(VP9Decoder *const pbi, MACROBLOCKD *xd, int mi_row,
- int mi_col, vpx_reader *r, int x_mis, int y_mis);
+void vp9_read_mode_info(TileWorkerData *twd, VP9Decoder *const pbi, int mi_row,
+ int mi_col, int x_mis, int y_mis);
#ifdef __cplusplus
} // extern "C"
diff --git a/vp9/decoder/vp9_detokenize.c b/vp9/decoder/vp9_detokenize.c
index cc01909ff..7048fb1ca 100644
--- a/vp9/decoder/vp9_detokenize.c
+++ b/vp9/decoder/vp9_detokenize.c
@@ -29,9 +29,45 @@
if (counts) ++coef_counts[band][ctx][token]; \
} while (0)
-static INLINE int read_coeff(const vpx_prob *probs, int n, vpx_reader *r) {
+static INLINE int read_bool(vpx_reader *r, int prob, BD_VALUE *value,
+ int *count, unsigned int *range) {
+ const unsigned int split = (*range * prob + (256 - prob)) >> CHAR_BIT;
+ const BD_VALUE bigsplit = (BD_VALUE)split << (BD_VALUE_SIZE - CHAR_BIT);
+
+ if (*count < 0) {
+ r->value = *value;
+ r->count = *count;
+ vpx_reader_fill(r);
+ *value = r->value;
+ *count = r->count;
+ }
+
+ if (*value >= bigsplit) {
+ *range = *range - split;
+ *value = *value - bigsplit;
+ {
+ const int shift = vpx_norm[*range];
+ *range <<= shift;
+ *value <<= shift;
+ *count -= shift;
+ }
+ return 1;
+ }
+ *range = split;
+ {
+ const int shift = vpx_norm[*range];
+ *range <<= shift;
+ *value <<= shift;
+ *count -= shift;
+ }
+ return 0;
+}
+
+static INLINE int read_coeff(vpx_reader *r, const vpx_prob *probs, int n,
+ BD_VALUE *value, int *count, unsigned int *range) {
int i, val = 0;
- for (i = 0; i < n; ++i) val = (val << 1) | vpx_read(r, probs[i]);
+ for (i = 0; i < n; ++i)
+ val = (val << 1) | read_bool(r, probs[i], value, count, range);
return val;
}
@@ -52,7 +88,7 @@ static int decode_coefs(const MACROBLOCKD *xd, PLANE_TYPE type,
uint8_t token_cache[32 * 32];
const uint8_t *band_translate = get_band_translate(tx_size);
const int dq_shift = (tx_size == TX_32X32);
- int v, token;
+ int v;
int16_t dqv = dq[0];
const uint8_t *const cat6_prob =
#if CONFIG_VP9_HIGHBITDEPTH
@@ -66,6 +102,11 @@ static int decode_coefs(const MACROBLOCKD *xd, PLANE_TYPE type,
(xd->bd == VPX_BITS_12) ? 18 : (xd->bd == VPX_BITS_10) ? 16 :
#endif // CONFIG_VP9_HIGHBITDEPTH
14;
+ // Keep value, range, and count as locals. The compiler produces better
+ // results with the locals than using r directly.
+ BD_VALUE value = r->value;
+ unsigned int range = r->range;
+ int count = r->count;
if (counts) {
coef_counts = counts->coef[tx_size][type][ref];
@@ -77,70 +118,98 @@ static int decode_coefs(const MACROBLOCKD *xd, PLANE_TYPE type,
band = *band_translate++;
prob = coef_probs[band][ctx];
if (counts) ++eob_branch_count[band][ctx];
- if (!vpx_read(r, prob[EOB_CONTEXT_NODE])) {
+ if (!read_bool(r, prob[EOB_CONTEXT_NODE], &value, &count, &range)) {
INCREMENT_COUNT(EOB_MODEL_TOKEN);
break;
}
- while (!vpx_read(r, prob[ZERO_CONTEXT_NODE])) {
+ while (!read_bool(r, prob[ZERO_CONTEXT_NODE], &value, &count, &range)) {
INCREMENT_COUNT(ZERO_TOKEN);
dqv = dq[1];
token_cache[scan[c]] = 0;
++c;
- if (c >= max_eob) return c; // zero tokens at the end (no eob token)
+ if (c >= max_eob) {
+ r->value = value;
+ r->range = range;
+ r->count = count;
+ return c; // zero tokens at the end (no eob token)
+ }
ctx = get_coef_context(nb, token_cache, c);
band = *band_translate++;
prob = coef_probs[band][ctx];
}
- if (!vpx_read(r, prob[ONE_CONTEXT_NODE])) {
- INCREMENT_COUNT(ONE_TOKEN);
- token = ONE_TOKEN;
- val = 1;
- } else {
+ if (read_bool(r, prob[ONE_CONTEXT_NODE], &value, &count, &range)) {
+ const vpx_prob *p = vp9_pareto8_full[prob[PIVOT_NODE] - 1];
INCREMENT_COUNT(TWO_TOKEN);
- token = vpx_read_tree(r, vp9_coef_con_tree,
- vp9_pareto8_full[prob[PIVOT_NODE] - 1]);
- switch (token) {
- case TWO_TOKEN:
- case THREE_TOKEN:
- case FOUR_TOKEN: val = token; break;
- case CATEGORY1_TOKEN:
- val = CAT1_MIN_VAL + read_coeff(vp9_cat1_prob, 1, r);
- break;
- case CATEGORY2_TOKEN:
- val = CAT2_MIN_VAL + read_coeff(vp9_cat2_prob, 2, r);
- break;
- case CATEGORY3_TOKEN:
- val = CAT3_MIN_VAL + read_coeff(vp9_cat3_prob, 3, r);
- break;
- case CATEGORY4_TOKEN:
- val = CAT4_MIN_VAL + read_coeff(vp9_cat4_prob, 4, r);
- break;
- case CATEGORY5_TOKEN:
- val = CAT5_MIN_VAL + read_coeff(vp9_cat5_prob, 5, r);
- break;
- case CATEGORY6_TOKEN:
- val = CAT6_MIN_VAL + read_coeff(cat6_prob, cat6_bits, r);
- break;
+ if (read_bool(r, p[0], &value, &count, &range)) {
+ if (read_bool(r, p[3], &value, &count, &range)) {
+ token_cache[scan[c]] = 5;
+ if (read_bool(r, p[5], &value, &count, &range)) {
+ if (read_bool(r, p[7], &value, &count, &range)) {
+ val = CAT6_MIN_VAL +
+ read_coeff(r, cat6_prob, cat6_bits, &value, &count, &range);
+ } else {
+ val = CAT5_MIN_VAL +
+ read_coeff(r, vp9_cat5_prob, 5, &value, &count, &range);
+ }
+ } else if (read_bool(r, p[6], &value, &count, &range)) {
+ val = CAT4_MIN_VAL +
+ read_coeff(r, vp9_cat4_prob, 4, &value, &count, &range);
+ } else {
+ val = CAT3_MIN_VAL +
+ read_coeff(r, vp9_cat3_prob, 3, &value, &count, &range);
+ }
+ } else {
+ token_cache[scan[c]] = 4;
+ if (read_bool(r, p[4], &value, &count, &range)) {
+ val = CAT2_MIN_VAL +
+ read_coeff(r, vp9_cat2_prob, 2, &value, &count, &range);
+ } else {
+ val = CAT1_MIN_VAL +
+ read_coeff(r, vp9_cat1_prob, 1, &value, &count, &range);
+ }
+ }
+ v = (val * dqv) >> dq_shift;
+ } else {
+ if (read_bool(r, p[1], &value, &count, &range)) {
+ token_cache[scan[c]] = 3;
+ v = ((3 + read_bool(r, p[2], &value, &count, &range)) * dqv) >>
+ dq_shift;
+ } else {
+ token_cache[scan[c]] = 2;
+ v = (2 * dqv) >> dq_shift;
+ }
}
+ } else {
+ INCREMENT_COUNT(ONE_TOKEN);
+ token_cache[scan[c]] = 1;
+ v = dqv >> dq_shift;
}
- v = (val * dqv) >> dq_shift;
#if CONFIG_COEFFICIENT_RANGE_CHECKING
#if CONFIG_VP9_HIGHBITDEPTH
- dqcoeff[scan[c]] = highbd_check_range((vpx_read_bit(r) ? -v : v), xd->bd);
+ dqcoeff[scan[c]] =
+ highbd_check_range(read_bool(r, 128, &value, &count, &range) ? -v : v),
+ xd->bd);
#else
- dqcoeff[scan[c]] = check_range(vpx_read_bit(r) ? -v : v);
+ dqcoeff[scan[c]] =
+ check_range(read_bool(r, 128, &value, &count, &range) ? -v : v);
#endif // CONFIG_VP9_HIGHBITDEPTH
#else
- dqcoeff[scan[c]] = vpx_read_bit(r) ? -v : v;
+ if (read_bool(r, 128, &value, &count, &range)) {
+ dqcoeff[scan[c]] = -v;
+ } else {
+ dqcoeff[scan[c]] = v;
+ }
#endif // CONFIG_COEFFICIENT_RANGE_CHECKING
- token_cache[scan[c]] = vp9_pt_energy_class[token];
++c;
ctx = get_coef_context(nb, token_cache, c);
dqv = dq[1];
}
+ r->value = value;
+ r->range = range;
+ r->count = count;
return c;
}
@@ -156,9 +225,11 @@ static void get_ctx_shift(MACROBLOCKD *xd, int *ctx_shift_a, int *ctx_shift_l,
}
}
-int vp9_decode_block_tokens(MACROBLOCKD *xd, int plane, const scan_order *sc,
- int x, int y, TX_SIZE tx_size, vpx_reader *r,
+int vp9_decode_block_tokens(TileWorkerData *twd, int plane,
+ const scan_order *sc, int x, int y, TX_SIZE tx_size,
int seg_id) {
+ vpx_reader *r = &twd->bit_reader;
+ MACROBLOCKD *xd = &twd->xd;
struct macroblockd_plane *const pd = &xd->plane[plane];
const int16_t *const dequant = pd->seg_dequant[seg_id];
int eob;
diff --git a/vp9/decoder/vp9_detokenize.h b/vp9/decoder/vp9_detokenize.h
index aa2afb16a..7b0d87601 100644
--- a/vp9/decoder/vp9_detokenize.h
+++ b/vp9/decoder/vp9_detokenize.h
@@ -19,8 +19,8 @@
extern "C" {
#endif
-int vp9_decode_block_tokens(MACROBLOCKD *xd, int plane, const scan_order *sc,
- int x, int y, TX_SIZE tx_size, vpx_reader *r,
+int vp9_decode_block_tokens(TileWorkerData *twd, int plane,
+ const scan_order *sc, int x, int y, TX_SIZE tx_size,
int seg_id);
#ifdef __cplusplus
diff --git a/vp9/encoder/vp9_encodemv.c b/vp9/encoder/vp9_encodemv.c
index 8e76f72fe..874a8e4b9 100644
--- a/vp9/encoder/vp9_encodemv.c
+++ b/vp9/encoder/vp9_encodemv.c
@@ -21,12 +21,10 @@
static struct vp9_token mv_joint_encodings[MV_JOINTS];
static struct vp9_token mv_class_encodings[MV_CLASSES];
static struct vp9_token mv_fp_encodings[MV_FP_SIZE];
-static struct vp9_token mv_class0_encodings[CLASS0_SIZE];
void vp9_entropy_mv_init(void) {
vp9_tokens_from_tree(mv_joint_encodings, vp9_mv_joint_tree);
vp9_tokens_from_tree(mv_class_encodings, vp9_mv_class_tree);
- vp9_tokens_from_tree(mv_class0_encodings, vp9_mv_class0_tree);
vp9_tokens_from_tree(mv_fp_encodings, vp9_mv_fp_tree);
}
@@ -51,8 +49,7 @@ static void encode_mv_component(vpx_writer *w, int comp,
// Integer bits
if (mv_class == MV_CLASS_0) {
- vp9_write_token(w, vp9_mv_class0_tree, mvcomp->class0,
- &mv_class0_encodings[d]);
+ vpx_write(w, d, mvcomp->class0[0]);
} else {
int i;
const int n = mv_class + CLASS0_BITS - 1; // number of bits
diff --git a/vp9/encoder/vp9_picklpf.c b/vp9/encoder/vp9_picklpf.c
index 1583cc8ab..6fc7cd1e3 100644
--- a/vp9/encoder/vp9_picklpf.c
+++ b/vp9/encoder/vp9_picklpf.c
@@ -180,6 +180,10 @@ void vp9_pick_filter_level(const YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi,
}
#else
int filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 1015158, 18);
+ if (cpi->oxcf.pass == 0 && cpi->oxcf.rc_mode == VPX_CBR &&
+ cpi->oxcf.content != VP9E_CONTENT_SCREEN && cm->frame_type != KEY_FRAME)
+ filt_guess = 5 * filt_guess >> 3;
+
#endif // CONFIG_VP9_HIGHBITDEPTH
if (cm->frame_type == KEY_FRAME) filt_guess -= 4;
lf->filter_level = clamp(filt_guess, min_filter_level, max_filter_level);
diff --git a/vp9/vp9_common.mk b/vp9/vp9_common.mk
index 2fd42960e..5bfc0d359 100644
--- a/vp9/vp9_common.mk
+++ b/vp9/vp9_common.mk
@@ -45,7 +45,6 @@ VP9_COMMON_SRCS-yes += common/vp9_scale.h
VP9_COMMON_SRCS-yes += common/vp9_scale.c
VP9_COMMON_SRCS-yes += common/vp9_seg_common.h
VP9_COMMON_SRCS-yes += common/vp9_seg_common.c
-VP9_COMMON_SRCS-yes += common/vp9_textblit.h
VP9_COMMON_SRCS-yes += common/vp9_tile_common.h
VP9_COMMON_SRCS-yes += common/vp9_tile_common.c
VP9_COMMON_SRCS-yes += common/vp9_loopfilter.c
@@ -55,7 +54,6 @@ VP9_COMMON_SRCS-yes += common/vp9_mvref_common.h
VP9_COMMON_SRCS-yes += common/vp9_quant_common.c
VP9_COMMON_SRCS-yes += common/vp9_reconinter.c
VP9_COMMON_SRCS-yes += common/vp9_reconintra.c
-VP9_COMMON_SRCS-$(CONFIG_POSTPROC_VISUALIZER) += common/vp9_textblit.c
VP9_COMMON_SRCS-yes += common/vp9_common_data.c
VP9_COMMON_SRCS-yes += common/vp9_common_data.h
VP9_COMMON_SRCS-yes += common/vp9_scan.c
diff --git a/vp9/vp9_dx_iface.c b/vp9/vp9_dx_iface.c
index 04b1dca29..3b5dc3dda 100644
--- a/vp9/vp9_dx_iface.c
+++ b/vp9/vp9_dx_iface.c
@@ -829,13 +829,6 @@ static vpx_codec_err_t ctrl_set_postproc(vpx_codec_alg_priv_t *ctx,
#endif
}
-static vpx_codec_err_t ctrl_set_dbg_options(vpx_codec_alg_priv_t *ctx,
- va_list args) {
- (void)ctx;
- (void)args;
- return VPX_CODEC_INCAPABLE;
-}
-
static vpx_codec_err_t ctrl_get_last_ref_updates(vpx_codec_alg_priv_t *ctx,
va_list args) {
int *const update_info = va_arg(args, int *);
@@ -1014,10 +1007,6 @@ static vpx_codec_ctrl_fn_map_t decoder_ctrl_maps[] = {
// Setters
{ VP8_SET_REFERENCE, ctrl_set_reference },
{ VP8_SET_POSTPROC, ctrl_set_postproc },
- { VP8_SET_DBG_COLOR_REF_FRAME, ctrl_set_dbg_options },
- { VP8_SET_DBG_COLOR_MB_MODES, ctrl_set_dbg_options },
- { VP8_SET_DBG_COLOR_B_MODES, ctrl_set_dbg_options },
- { VP8_SET_DBG_DISPLAY_MV, ctrl_set_dbg_options },
{ VP9_INVERT_TILE_DECODE_ORDER, ctrl_set_invert_tile_order },
{ VPXD_SET_DECRYPTOR, ctrl_set_decryptor },
{ VP9_SET_BYTE_ALIGNMENT, ctrl_set_byte_alignment },
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-11 07:26:35 +0000