/media/libvpx/vp8/decoder/detokenize.c

http://github.com/zpao/v8monkey · C · 383 lines · 312 code · 60 blank · 11 comment · 22 complexity · 59a54f23646cc6a7ce60981ddbd8744c MD5 · raw file

  1. /*
  2. * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  3. *
  4. * Use of this source code is governed by a BSD-style license
  5. * that can be found in the LICENSE file in the root of the source
  6. * tree. An additional intellectual property rights grant can be found
  7. * in the file PATENTS. All contributing project authors may
  8. * be found in the AUTHORS file in the root of the source tree.
  9. */
  10. #include "vp8/common/type_aliases.h"
  11. #include "vp8/common/blockd.h"
  12. #include "onyxd_int.h"
  13. #include "vpx_mem/vpx_mem.h"
  14. #include "vpx_ports/mem.h"
  15. #include "detokenize.h"
  16. #define BOOL_DATA UINT8
  17. #define OCB_X PREV_COEF_CONTEXTS * ENTROPY_NODES
  18. DECLARE_ALIGNED(16, static const unsigned char, coef_bands_x[16]) =
  19. {
  20. 0 * OCB_X, 1 * OCB_X, 2 * OCB_X, 3 * OCB_X,
  21. 6 * OCB_X, 4 * OCB_X, 5 * OCB_X, 6 * OCB_X,
  22. 6 * OCB_X, 6 * OCB_X, 6 * OCB_X, 6 * OCB_X,
  23. 6 * OCB_X, 6 * OCB_X, 6 * OCB_X, 7 * OCB_X
  24. };
  25. #define EOB_CONTEXT_NODE 0
  26. #define ZERO_CONTEXT_NODE 1
  27. #define ONE_CONTEXT_NODE 2
  28. #define LOW_VAL_CONTEXT_NODE 3
  29. #define TWO_CONTEXT_NODE 4
  30. #define THREE_CONTEXT_NODE 5
  31. #define HIGH_LOW_CONTEXT_NODE 6
  32. #define CAT_ONE_CONTEXT_NODE 7
  33. #define CAT_THREEFOUR_CONTEXT_NODE 8
  34. #define CAT_THREE_CONTEXT_NODE 9
  35. #define CAT_FIVE_CONTEXT_NODE 10
  36. #define CAT1_MIN_VAL 5
  37. #define CAT2_MIN_VAL 7
  38. #define CAT3_MIN_VAL 11
  39. #define CAT4_MIN_VAL 19
  40. #define CAT5_MIN_VAL 35
  41. #define CAT6_MIN_VAL 67
  42. #define CAT1_PROB0 159
  43. #define CAT2_PROB0 145
  44. #define CAT2_PROB1 165
  45. #define CAT3_PROB0 140
  46. #define CAT3_PROB1 148
  47. #define CAT3_PROB2 173
  48. #define CAT4_PROB0 135
  49. #define CAT4_PROB1 140
  50. #define CAT4_PROB2 155
  51. #define CAT4_PROB3 176
  52. #define CAT5_PROB0 130
  53. #define CAT5_PROB1 134
  54. #define CAT5_PROB2 141
  55. #define CAT5_PROB3 157
  56. #define CAT5_PROB4 180
  57. static const unsigned char cat6_prob[12] =
  58. { 129, 130, 133, 140, 153, 177, 196, 230, 243, 254, 254, 0 };
  59. void vp8_reset_mb_tokens_context(MACROBLOCKD *x)
  60. {
  61. /* Clear entropy contexts for Y2 blocks */
  62. if (x->mode_info_context->mbmi.mode != B_PRED &&
  63. x->mode_info_context->mbmi.mode != SPLITMV)
  64. {
  65. vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
  66. vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
  67. }
  68. else
  69. {
  70. vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)-1);
  71. vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)-1);
  72. }
  73. }
  74. DECLARE_ALIGNED(16, extern const unsigned char, vp8_norm[256]);
  75. #define FILL \
  76. if(count < 0) \
  77. VP8DX_BOOL_DECODER_FILL(count, value, bufptr, bufend);
  78. #define NORMALIZE \
  79. /*if(range < 0x80)*/ \
  80. { \
  81. shift = vp8_norm[range]; \
  82. range <<= shift; \
  83. value <<= shift; \
  84. count -= shift; \
  85. }
  86. #define DECODE_AND_APPLYSIGN(value_to_sign) \
  87. split = (range + 1) >> 1; \
  88. bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
  89. FILL \
  90. if ( value < bigsplit ) \
  91. { \
  92. range = split; \
  93. v= value_to_sign; \
  94. } \
  95. else \
  96. { \
  97. range = range-split; \
  98. value = value-bigsplit; \
  99. v = -value_to_sign; \
  100. } \
  101. range +=range; \
  102. value +=value; \
  103. count--;
  104. #define DECODE_AND_BRANCH_IF_ZERO(probability,branch) \
  105. { \
  106. split = 1 + ((( probability*(range-1) ) )>> 8); \
  107. bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
  108. FILL \
  109. if ( value < bigsplit ) \
  110. { \
  111. range = split; \
  112. NORMALIZE \
  113. goto branch; \
  114. } \
  115. value -= bigsplit; \
  116. range = range - split; \
  117. NORMALIZE \
  118. }
  119. #define DECODE_AND_LOOP_IF_ZERO(probability,branch) \
  120. { \
  121. split = 1 + ((( probability*(range-1) ) ) >> 8); \
  122. bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
  123. FILL \
  124. if ( value < bigsplit ) \
  125. { \
  126. range = split; \
  127. NORMALIZE \
  128. Prob = coef_probs; \
  129. if(c<15) {\
  130. ++c; \
  131. Prob += coef_bands_x[c]; \
  132. goto branch; \
  133. } goto BLOCK_FINISHED; /*for malformed input */\
  134. } \
  135. value -= bigsplit; \
  136. range = range - split; \
  137. NORMALIZE \
  138. }
  139. #define DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val) \
  140. DECODE_AND_APPLYSIGN(val) \
  141. Prob = coef_probs + (ENTROPY_NODES*2); \
  142. if(c < 15){\
  143. qcoeff_ptr [ scan[c] ] = (INT16) v; \
  144. ++c; \
  145. goto DO_WHILE; }\
  146. qcoeff_ptr [ 15 ] = (INT16) v; \
  147. goto BLOCK_FINISHED;
  148. #define DECODE_EXTRABIT_AND_ADJUST_VAL(prob, bits_count)\
  149. split = 1 + (((range-1) * prob) >> 8); \
  150. bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8); \
  151. FILL \
  152. if(value >= bigsplit)\
  153. {\
  154. range = range-split;\
  155. value = value-bigsplit;\
  156. val += ((UINT16)1<<bits_count);\
  157. }\
  158. else\
  159. {\
  160. range = split;\
  161. }\
  162. NORMALIZE
  163. int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *x)
  164. {
  165. ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)x->above_context;
  166. ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)x->left_context;
  167. const FRAME_CONTEXT * const fc = &dx->common.fc;
  168. BOOL_DECODER *bc = x->current_bc;
  169. char *eobs = x->eobs;
  170. ENTROPY_CONTEXT *a;
  171. ENTROPY_CONTEXT *l;
  172. int i;
  173. int eobtotal = 0;
  174. register int count;
  175. const BOOL_DATA *bufptr;
  176. const BOOL_DATA *bufend;
  177. register unsigned int range;
  178. VP8_BD_VALUE value;
  179. const int *scan;
  180. register unsigned int shift;
  181. UINT32 split;
  182. VP8_BD_VALUE bigsplit;
  183. INT16 *qcoeff_ptr;
  184. const vp8_prob *coef_probs;
  185. int type;
  186. int stop;
  187. INT16 val, bits_count;
  188. INT16 c;
  189. INT16 v;
  190. const vp8_prob *Prob;
  191. type = 3;
  192. i = 0;
  193. stop = 16;
  194. scan = vp8_default_zig_zag1d;
  195. qcoeff_ptr = &x->qcoeff[0];
  196. if (x->mode_info_context->mbmi.mode != B_PRED &&
  197. x->mode_info_context->mbmi.mode != SPLITMV)
  198. {
  199. i = 24;
  200. stop = 24;
  201. type = 1;
  202. qcoeff_ptr += 24*16;
  203. eobtotal -= 16;
  204. }
  205. bufend = bc->user_buffer_end;
  206. bufptr = bc->user_buffer;
  207. value = bc->value;
  208. count = bc->count;
  209. range = bc->range;
  210. coef_probs = fc->coef_probs [type] [ 0 ] [0];
  211. BLOCK_LOOP:
  212. a = A + vp8_block2above[i];
  213. l = L + vp8_block2left[i];
  214. c = (INT16)(!type);
  215. /*Dest = ((A)!=0) + ((B)!=0);*/
  216. VP8_COMBINEENTROPYCONTEXTS(v, *a, *l);
  217. Prob = coef_probs;
  218. Prob += v * ENTROPY_NODES;
  219. DO_WHILE:
  220. Prob += coef_bands_x[c];
  221. DECODE_AND_BRANCH_IF_ZERO(Prob[EOB_CONTEXT_NODE], BLOCK_FINISHED);
  222. CHECK_0_:
  223. DECODE_AND_LOOP_IF_ZERO(Prob[ZERO_CONTEXT_NODE], CHECK_0_);
  224. DECODE_AND_BRANCH_IF_ZERO(Prob[ONE_CONTEXT_NODE], ONE_CONTEXT_NODE_0_);
  225. DECODE_AND_BRANCH_IF_ZERO(Prob[LOW_VAL_CONTEXT_NODE],
  226. LOW_VAL_CONTEXT_NODE_0_);
  227. DECODE_AND_BRANCH_IF_ZERO(Prob[HIGH_LOW_CONTEXT_NODE],
  228. HIGH_LOW_CONTEXT_NODE_0_);
  229. DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_THREEFOUR_CONTEXT_NODE],
  230. CAT_THREEFOUR_CONTEXT_NODE_0_);
  231. DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_FIVE_CONTEXT_NODE],
  232. CAT_FIVE_CONTEXT_NODE_0_);
  233. val = CAT6_MIN_VAL;
  234. bits_count = 10;
  235. do
  236. {
  237. DECODE_EXTRABIT_AND_ADJUST_VAL(cat6_prob[bits_count], bits_count);
  238. bits_count -- ;
  239. }
  240. while (bits_count >= 0);
  241. DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
  242. CAT_FIVE_CONTEXT_NODE_0_:
  243. val = CAT5_MIN_VAL;
  244. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT5_PROB4, 4);
  245. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT5_PROB3, 3);
  246. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT5_PROB2, 2);
  247. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT5_PROB1, 1);
  248. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT5_PROB0, 0);
  249. DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
  250. CAT_THREEFOUR_CONTEXT_NODE_0_:
  251. DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_THREE_CONTEXT_NODE],
  252. CAT_THREE_CONTEXT_NODE_0_);
  253. val = CAT4_MIN_VAL;
  254. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT4_PROB3, 3);
  255. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT4_PROB2, 2);
  256. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT4_PROB1, 1);
  257. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT4_PROB0, 0);
  258. DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
  259. CAT_THREE_CONTEXT_NODE_0_:
  260. val = CAT3_MIN_VAL;
  261. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT3_PROB2, 2);
  262. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT3_PROB1, 1);
  263. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT3_PROB0, 0);
  264. DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
  265. HIGH_LOW_CONTEXT_NODE_0_:
  266. DECODE_AND_BRANCH_IF_ZERO(Prob[CAT_ONE_CONTEXT_NODE],
  267. CAT_ONE_CONTEXT_NODE_0_);
  268. val = CAT2_MIN_VAL;
  269. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT2_PROB1, 1);
  270. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT2_PROB0, 0);
  271. DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
  272. CAT_ONE_CONTEXT_NODE_0_:
  273. val = CAT1_MIN_VAL;
  274. DECODE_EXTRABIT_AND_ADJUST_VAL(CAT1_PROB0, 0);
  275. DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
  276. LOW_VAL_CONTEXT_NODE_0_:
  277. DECODE_AND_BRANCH_IF_ZERO(Prob[TWO_CONTEXT_NODE], TWO_CONTEXT_NODE_0_);
  278. DECODE_AND_BRANCH_IF_ZERO(Prob[THREE_CONTEXT_NODE], THREE_CONTEXT_NODE_0_);
  279. DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(4);
  280. THREE_CONTEXT_NODE_0_:
  281. DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(3);
  282. TWO_CONTEXT_NODE_0_:
  283. DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(2);
  284. ONE_CONTEXT_NODE_0_:
  285. DECODE_AND_APPLYSIGN(1);
  286. Prob = coef_probs + ENTROPY_NODES;
  287. if (c < 15)
  288. {
  289. qcoeff_ptr [ scan[c] ] = (INT16) v;
  290. ++c;
  291. goto DO_WHILE;
  292. }
  293. qcoeff_ptr [ 15 ] = (INT16) v;
  294. BLOCK_FINISHED:
  295. *a = *l = ((eobs[i] = c) != !type); /* any nonzero data? */
  296. eobtotal += c;
  297. qcoeff_ptr += 16;
  298. i++;
  299. if (i < stop)
  300. goto BLOCK_LOOP;
  301. if (i == 25)
  302. {
  303. type = 0;
  304. i = 0;
  305. stop = 16;
  306. coef_probs = fc->coef_probs [type] [ 0 ] [0];
  307. qcoeff_ptr -= (24*16 + 16);
  308. goto BLOCK_LOOP;
  309. }
  310. if (i == 16)
  311. {
  312. type = 2;
  313. coef_probs = fc->coef_probs [type] [ 0 ] [0];
  314. stop = 24;
  315. goto BLOCK_LOOP;
  316. }
  317. FILL
  318. bc->user_buffer = bufptr;
  319. bc->value = value;
  320. bc->count = count;
  321. bc->range = range;
  322. return eobtotal;
  323. }