429dc676b1
A large number of functions were defined with external linkage, even
though they were only used from within one file. This patch changes
their linkage to static and removes the vp8_ prefix from their names,
which should make it more obvious to the reader that the function is
contained within the current translation unit. Functions that were
not referenced were removed.
These symbols were identified by:
$ nm -A libvpx.a | sort -k3 | uniq -c -f2 | grep ' [A-Z] ' \
| sort | grep '^ *1 '
Change-Id: I59609f58ab65312012c047036ae1e0634f795779
372 lines
11 KiB
C
372 lines
11 KiB
C
/*
|
|
* 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 "vp8/common/type_aliases.h"
|
|
#include "vp8/common/blockd.h"
|
|
#include "onyxd_int.h"
|
|
#include "vpx_mem/vpx_mem.h"
|
|
#include "vpx_ports/mem.h"
|
|
#include "detokenize.h"
|
|
|
|
#define BOOL_DATA UINT8
|
|
|
|
#define OCB_X PREV_COEF_CONTEXTS * ENTROPY_NODES
|
|
DECLARE_ALIGNED(16, static const unsigned char, coef_bands_x[16]) =
|
|
{
|
|
0 * OCB_X, 1 * OCB_X, 2 * OCB_X, 3 * OCB_X,
|
|
6 * OCB_X, 4 * OCB_X, 5 * OCB_X, 6 * OCB_X,
|
|
6 * OCB_X, 6 * OCB_X, 6 * OCB_X, 6 * OCB_X,
|
|
6 * OCB_X, 6 * OCB_X, 6 * OCB_X, 7 * OCB_X
|
|
};
|
|
#define EOB_CONTEXT_NODE 0
|
|
#define ZERO_CONTEXT_NODE 1
|
|
#define ONE_CONTEXT_NODE 2
|
|
#define LOW_VAL_CONTEXT_NODE 3
|
|
#define TWO_CONTEXT_NODE 4
|
|
#define THREE_CONTEXT_NODE 5
|
|
#define HIGH_LOW_CONTEXT_NODE 6
|
|
#define CAT_ONE_CONTEXT_NODE 7
|
|
#define CAT_THREEFOUR_CONTEXT_NODE 8
|
|
#define CAT_THREE_CONTEXT_NODE 9
|
|
#define CAT_FIVE_CONTEXT_NODE 10
|
|
|
|
/*
|
|
//the definition is put in "onyxd_int.h"
|
|
typedef struct
|
|
{
|
|
INT16 min_val;
|
|
INT16 Length;
|
|
UINT8 Probs[12];
|
|
} TOKENEXTRABITS;
|
|
*/
|
|
|
|
DECLARE_ALIGNED(16, static const TOKENEXTRABITS, vp8d_token_extra_bits2[MAX_ENTROPY_TOKENS]) =
|
|
{
|
|
{ 0, -1, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, /* ZERO_TOKEN */
|
|
{ 1, 0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, /* ONE_TOKEN */
|
|
{ 2, 0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, /* TWO_TOKEN */
|
|
{ 3, 0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, /* THREE_TOKEN */
|
|
{ 4, 0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, /* FOUR_TOKEN */
|
|
{ 5, 0, { 159, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, /* DCT_VAL_CATEGORY1 */
|
|
{ 7, 1, { 145, 165, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, /* DCT_VAL_CATEGORY2 */
|
|
{ 11, 2, { 140, 148, 173, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, /* DCT_VAL_CATEGORY3 */
|
|
{ 19, 3, { 135, 140, 155, 176, 0, 0, 0, 0, 0, 0, 0, 0 } }, /* DCT_VAL_CATEGORY4 */
|
|
{ 35, 4, { 130, 134, 141, 157, 180, 0, 0, 0, 0, 0, 0, 0 } }, /* DCT_VAL_CATEGORY5 */
|
|
{ 67, 10, { 129, 130, 133, 140, 153, 177, 196, 230, 243, 254, 254, 0 } }, /* DCT_VAL_CATEGORY6 */
|
|
{ 0, -1, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, /* EOB TOKEN */
|
|
};
|
|
|
|
|
|
void vp8_reset_mb_tokens_context(MACROBLOCKD *x)
|
|
{
|
|
/* Clear entropy contexts for Y2 blocks */
|
|
if (x->mode_info_context->mbmi.mode != B_PRED && x->mode_info_context->mbmi.mode != SPLITMV)
|
|
{
|
|
vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
|
|
vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
|
|
}
|
|
else
|
|
{
|
|
vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)-1);
|
|
vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)-1);
|
|
}
|
|
}
|
|
|
|
DECLARE_ALIGNED(16, extern const unsigned char, vp8dx_bitreader_norm[256]);
|
|
#define FILL \
|
|
if(count < 0) \
|
|
VP8DX_BOOL_DECODER_FILL(count, value, bufptr, bufend);
|
|
|
|
#define NORMALIZE \
|
|
/*if(range < 0x80)*/ \
|
|
{ \
|
|
shift = vp8dx_bitreader_norm[range]; \
|
|
range <<= shift; \
|
|
value <<= shift; \
|
|
count -= shift; \
|
|
}
|
|
|
|
#define DECODE_AND_APPLYSIGN(value_to_sign) \
|
|
split = (range + 1) >> 1; \
|
|
bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
|
|
FILL \
|
|
if ( value < bigsplit ) \
|
|
{ \
|
|
range = split; \
|
|
v= value_to_sign; \
|
|
} \
|
|
else \
|
|
{ \
|
|
range = range-split; \
|
|
value = value-bigsplit; \
|
|
v = -value_to_sign; \
|
|
} \
|
|
range +=range; \
|
|
value +=value; \
|
|
count--;
|
|
|
|
#define DECODE_AND_BRANCH_IF_ZERO(probability,branch) \
|
|
{ \
|
|
split = 1 + ((( probability*(range-1) ) )>> 8); \
|
|
bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
|
|
FILL \
|
|
if ( value < bigsplit ) \
|
|
{ \
|
|
range = split; \
|
|
NORMALIZE \
|
|
goto branch; \
|
|
} \
|
|
value -= bigsplit; \
|
|
range = range - split; \
|
|
NORMALIZE \
|
|
}
|
|
|
|
#define DECODE_AND_LOOP_IF_ZERO(probability,branch) \
|
|
{ \
|
|
split = 1 + ((( probability*(range-1) ) ) >> 8); \
|
|
bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
|
|
FILL \
|
|
if ( value < bigsplit ) \
|
|
{ \
|
|
range = split; \
|
|
NORMALIZE \
|
|
Prob = coef_probs; \
|
|
if(c<15) {\
|
|
++c; \
|
|
Prob += coef_bands_x[c]; \
|
|
goto branch; \
|
|
} goto BLOCK_FINISHED; /*for malformed input */\
|
|
} \
|
|
value -= bigsplit; \
|
|
range = range - split; \
|
|
NORMALIZE \
|
|
}
|
|
|
|
#define DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val) \
|
|
DECODE_AND_APPLYSIGN(val) \
|
|
Prob = coef_probs + (ENTROPY_NODES*2); \
|
|
if(c < 15){\
|
|
qcoeff_ptr [ scan[c] ] = (INT16) v; \
|
|
++c; \
|
|
goto DO_WHILE; }\
|
|
qcoeff_ptr [ scan[15] ] = (INT16) v; \
|
|
goto BLOCK_FINISHED;
|
|
|
|
|
|
#define DECODE_EXTRABIT_AND_ADJUST_VAL(t,bits_count)\
|
|
split = 1 + (((range-1) * vp8d_token_extra_bits2[t].Probs[bits_count]) >> 8); \
|
|
bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
|
|
FILL \
|
|
if(value >= bigsplit)\
|
|
{\
|
|
range = range-split;\
|
|
value = value-bigsplit;\
|
|
val += ((UINT16)1<<bits_count);\
|
|
}\
|
|
else\
|
|
{\
|
|
range = split;\
|
|
}\
|
|
NORMALIZE
|
|
|
|
int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *x)
|
|
{
|
|
ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)x->above_context;
|
|
ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)x->left_context;
|
|
const VP8_COMMON *const oc = & dx->common;
|
|
|
|
BOOL_DECODER *bc = x->current_bc;
|
|
|
|
char *eobs = x->eobs;
|
|
|
|
ENTROPY_CONTEXT *a;
|
|
ENTROPY_CONTEXT *l;
|
|
int i;
|
|
|
|
int eobtotal = 0;
|
|
|
|
register int count;
|
|
|
|
const BOOL_DATA *bufptr;
|
|
const BOOL_DATA *bufend;
|
|
register unsigned int range;
|
|
VP8_BD_VALUE value;
|
|
const int *scan;
|
|
register unsigned int shift;
|
|
UINT32 split;
|
|
VP8_BD_VALUE bigsplit;
|
|
INT16 *qcoeff_ptr;
|
|
|
|
const vp8_prob *coef_probs;
|
|
int type;
|
|
int stop;
|
|
INT16 val, bits_count;
|
|
INT16 c;
|
|
INT16 v;
|
|
const vp8_prob *Prob;
|
|
|
|
type = 3;
|
|
i = 0;
|
|
stop = 16;
|
|
|
|
scan = vp8_default_zig_zag1d;
|
|
qcoeff_ptr = &x->qcoeff[0];
|
|
|
|
if (x->mode_info_context->mbmi.mode != B_PRED && x->mode_info_context->mbmi.mode != SPLITMV)
|
|
{
|
|
i = 24;
|
|
stop = 24;
|
|
type = 1;
|
|
qcoeff_ptr += 24*16;
|
|
eobtotal -= 16;
|
|
}
|
|
|
|
bufend = bc->user_buffer_end;
|
|
bufptr = bc->user_buffer;
|
|
value = bc->value;
|
|
count = bc->count;
|
|
range = bc->range;
|
|
|
|
|
|
coef_probs = oc->fc.coef_probs [type] [ 0 ] [0];
|
|
|
|
BLOCK_LOOP:
|
|
a = A + vp8_block2above[i];
|
|
l = L + vp8_block2left[i];
|
|
|
|
c = (INT16)(!type);
|
|
|
|
/*Dest = ((A)!=0) + ((B)!=0);*/
|
|
VP8_COMBINEENTROPYCONTEXTS(v, *a, *l);
|
|
Prob = coef_probs;
|
|
Prob += v * ENTROPY_NODES;
|
|
|
|
DO_WHILE:
|
|
Prob += coef_bands_x[c];
|
|
DECODE_AND_BRANCH_IF_ZERO(Prob[EOB_CONTEXT_NODE], BLOCK_FINISHED);
|
|
|
|
CHECK_0_:
|
|
DECODE_AND_LOOP_IF_ZERO(Prob[ZERO_CONTEXT_NODE], CHECK_0_);
|
|
DECODE_AND_BRANCH_IF_ZERO(Prob[ONE_CONTEXT_NODE], ONE_CONTEXT_NODE_0_);
|
|
DECODE_AND_BRANCH_IF_ZERO(Prob[LOW_VAL_CONTEXT_NODE], LOW_VAL_CONTEXT_NODE_0_);
|
|
DECODE_AND_BRANCH_IF_ZERO(Prob[HIGH_LOW_CONTEXT_NODE], HIGH_LOW_CONTEXT_NODE_0_);
|
|
DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_THREEFOUR_CONTEXT_NODE], CAT_THREEFOUR_CONTEXT_NODE_0_);
|
|
DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_FIVE_CONTEXT_NODE], CAT_FIVE_CONTEXT_NODE_0_);
|
|
val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY6].min_val;
|
|
bits_count = vp8d_token_extra_bits2[DCT_VAL_CATEGORY6].Length;
|
|
|
|
do
|
|
{
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY6, bits_count);
|
|
bits_count -- ;
|
|
}
|
|
while (bits_count >= 0);
|
|
|
|
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
|
|
|
|
CAT_FIVE_CONTEXT_NODE_0_:
|
|
val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY5].min_val;
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 4);
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 3);
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 2);
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 1);
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 0);
|
|
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
|
|
|
|
CAT_THREEFOUR_CONTEXT_NODE_0_:
|
|
DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_THREE_CONTEXT_NODE], CAT_THREE_CONTEXT_NODE_0_);
|
|
val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY4].min_val;
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 3);
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 2);
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 1);
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 0);
|
|
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
|
|
|
|
CAT_THREE_CONTEXT_NODE_0_:
|
|
val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY3].min_val;
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 2);
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 1);
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 0);
|
|
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
|
|
|
|
HIGH_LOW_CONTEXT_NODE_0_:
|
|
DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_ONE_CONTEXT_NODE], CAT_ONE_CONTEXT_NODE_0_);
|
|
|
|
val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY2].min_val;
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY2, 1);
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY2, 0);
|
|
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
|
|
|
|
CAT_ONE_CONTEXT_NODE_0_:
|
|
val = vp8d_token_extra_bits2[DCT_VAL_CATEGORY1].min_val;
|
|
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY1, 0);
|
|
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
|
|
|
|
LOW_VAL_CONTEXT_NODE_0_:
|
|
DECODE_AND_BRANCH_IF_ZERO(Prob[TWO_CONTEXT_NODE], TWO_CONTEXT_NODE_0_);
|
|
DECODE_AND_BRANCH_IF_ZERO(Prob[THREE_CONTEXT_NODE], THREE_CONTEXT_NODE_0_);
|
|
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(4);
|
|
|
|
THREE_CONTEXT_NODE_0_:
|
|
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(3);
|
|
|
|
TWO_CONTEXT_NODE_0_:
|
|
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(2);
|
|
|
|
ONE_CONTEXT_NODE_0_:
|
|
DECODE_AND_APPLYSIGN(1);
|
|
Prob = coef_probs + ENTROPY_NODES;
|
|
|
|
if (c < 15)
|
|
{
|
|
qcoeff_ptr [ scan[c] ] = (INT16) v;
|
|
++c;
|
|
goto DO_WHILE;
|
|
}
|
|
|
|
qcoeff_ptr [ scan[15] ] = (INT16) v;
|
|
BLOCK_FINISHED:
|
|
*a = *l = ((eobs[i] = c) != !type); /* any nonzero data? */
|
|
eobtotal += c;
|
|
qcoeff_ptr += 16;
|
|
|
|
i++;
|
|
|
|
if (i < stop)
|
|
goto BLOCK_LOOP;
|
|
|
|
if (i == 25)
|
|
{
|
|
type = 0;
|
|
i = 0;
|
|
stop = 16;
|
|
coef_probs = oc->fc.coef_probs [type] [ 0 ] [0];
|
|
qcoeff_ptr -= (24*16 + 16);
|
|
goto BLOCK_LOOP;
|
|
}
|
|
|
|
if (i == 16)
|
|
{
|
|
type = 2;
|
|
coef_probs = oc->fc.coef_probs [type] [ 0 ] [0];
|
|
stop = 24;
|
|
goto BLOCK_LOOP;
|
|
}
|
|
|
|
FILL
|
|
bc->user_buffer = bufptr;
|
|
bc->value = value;
|
|
bc->count = count;
|
|
bc->range = range;
|
|
return eobtotal;
|
|
|
|
}
|