h264_cavlc.c 37 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030
  1. /*
  2. * H.26L/H.264/AVC/JVT/14496-10/... cavlc bitstream decoding
  3. * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
  4. *
  5. * This file is part of FFmpeg.
  6. *
  7. * FFmpeg is free software; you can redistribute it and/or
  8. * modify it under the terms of the GNU Lesser General Public
  9. * License as published by the Free Software Foundation; either
  10. * version 2.1 of the License, or (at your option) any later version.
  11. *
  12. * FFmpeg is distributed in the hope that it will be useful,
  13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15. * Lesser General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU Lesser General Public
  18. * License along with FFmpeg; if not, write to the Free Software
  19. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20. */
  21. /**
  22. * @file libavcodec/h264_cavlc.c
  23. * H.264 / AVC / MPEG4 part10 cavlc bitstream decoding.
  24. * @author Michael Niedermayer <michaelni@gmx.at>
  25. */
  26. #define CABAC 0
  27. #include "internal.h"
  28. #include "avcodec.h"
  29. #include "mpegvideo.h"
  30. #include "h264.h"
  31. #include "h264data.h" // FIXME FIXME FIXME
  32. #include "h264_mvpred.h"
  33. #include "golomb.h"
  34. //#undef NDEBUG
  35. #include <assert.h>
  36. static const uint8_t golomb_to_inter_cbp_gray[16]={
  37. 0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
  38. };
  39. static const uint8_t golomb_to_intra4x4_cbp_gray[16]={
  40. 15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
  41. };
  42. static const uint8_t chroma_dc_coeff_token_len[4*5]={
  43. 2, 0, 0, 0,
  44. 6, 1, 0, 0,
  45. 6, 6, 3, 0,
  46. 6, 7, 7, 6,
  47. 6, 8, 8, 7,
  48. };
  49. static const uint8_t chroma_dc_coeff_token_bits[4*5]={
  50. 1, 0, 0, 0,
  51. 7, 1, 0, 0,
  52. 4, 6, 1, 0,
  53. 3, 3, 2, 5,
  54. 2, 3, 2, 0,
  55. };
  56. static const uint8_t coeff_token_len[4][4*17]={
  57. {
  58. 1, 0, 0, 0,
  59. 6, 2, 0, 0, 8, 6, 3, 0, 9, 8, 7, 5, 10, 9, 8, 6,
  60. 11,10, 9, 7, 13,11,10, 8, 13,13,11, 9, 13,13,13,10,
  61. 14,14,13,11, 14,14,14,13, 15,15,14,14, 15,15,15,14,
  62. 16,15,15,15, 16,16,16,15, 16,16,16,16, 16,16,16,16,
  63. },
  64. {
  65. 2, 0, 0, 0,
  66. 6, 2, 0, 0, 6, 5, 3, 0, 7, 6, 6, 4, 8, 6, 6, 4,
  67. 8, 7, 7, 5, 9, 8, 8, 6, 11, 9, 9, 6, 11,11,11, 7,
  68. 12,11,11, 9, 12,12,12,11, 12,12,12,11, 13,13,13,12,
  69. 13,13,13,13, 13,14,13,13, 14,14,14,13, 14,14,14,14,
  70. },
  71. {
  72. 4, 0, 0, 0,
  73. 6, 4, 0, 0, 6, 5, 4, 0, 6, 5, 5, 4, 7, 5, 5, 4,
  74. 7, 5, 5, 4, 7, 6, 6, 4, 7, 6, 6, 4, 8, 7, 7, 5,
  75. 8, 8, 7, 6, 9, 8, 8, 7, 9, 9, 8, 8, 9, 9, 9, 8,
  76. 10, 9, 9, 9, 10,10,10,10, 10,10,10,10, 10,10,10,10,
  77. },
  78. {
  79. 6, 0, 0, 0,
  80. 6, 6, 0, 0, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6,
  81. 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
  82. 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
  83. 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
  84. }
  85. };
  86. static const uint8_t coeff_token_bits[4][4*17]={
  87. {
  88. 1, 0, 0, 0,
  89. 5, 1, 0, 0, 7, 4, 1, 0, 7, 6, 5, 3, 7, 6, 5, 3,
  90. 7, 6, 5, 4, 15, 6, 5, 4, 11,14, 5, 4, 8,10,13, 4,
  91. 15,14, 9, 4, 11,10,13,12, 15,14, 9,12, 11,10,13, 8,
  92. 15, 1, 9,12, 11,14,13, 8, 7,10, 9,12, 4, 6, 5, 8,
  93. },
  94. {
  95. 3, 0, 0, 0,
  96. 11, 2, 0, 0, 7, 7, 3, 0, 7,10, 9, 5, 7, 6, 5, 4,
  97. 4, 6, 5, 6, 7, 6, 5, 8, 15, 6, 5, 4, 11,14,13, 4,
  98. 15,10, 9, 4, 11,14,13,12, 8,10, 9, 8, 15,14,13,12,
  99. 11,10, 9,12, 7,11, 6, 8, 9, 8,10, 1, 7, 6, 5, 4,
  100. },
  101. {
  102. 15, 0, 0, 0,
  103. 15,14, 0, 0, 11,15,13, 0, 8,12,14,12, 15,10,11,11,
  104. 11, 8, 9,10, 9,14,13, 9, 8,10, 9, 8, 15,14,13,13,
  105. 11,14,10,12, 15,10,13,12, 11,14, 9,12, 8,10,13, 8,
  106. 13, 7, 9,12, 9,12,11,10, 5, 8, 7, 6, 1, 4, 3, 2,
  107. },
  108. {
  109. 3, 0, 0, 0,
  110. 0, 1, 0, 0, 4, 5, 6, 0, 8, 9,10,11, 12,13,14,15,
  111. 16,17,18,19, 20,21,22,23, 24,25,26,27, 28,29,30,31,
  112. 32,33,34,35, 36,37,38,39, 40,41,42,43, 44,45,46,47,
  113. 48,49,50,51, 52,53,54,55, 56,57,58,59, 60,61,62,63,
  114. }
  115. };
  116. static const uint8_t total_zeros_len[16][16]= {
  117. {1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
  118. {3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
  119. {4,3,3,3,4,4,3,3,4,5,5,6,5,6},
  120. {5,3,4,4,3,3,3,4,3,4,5,5,5},
  121. {4,4,4,3,3,3,3,3,4,5,4,5},
  122. {6,5,3,3,3,3,3,3,4,3,6},
  123. {6,5,3,3,3,2,3,4,3,6},
  124. {6,4,5,3,2,2,3,3,6},
  125. {6,6,4,2,2,3,2,5},
  126. {5,5,3,2,2,2,4},
  127. {4,4,3,3,1,3},
  128. {4,4,2,1,3},
  129. {3,3,1,2},
  130. {2,2,1},
  131. {1,1},
  132. };
  133. static const uint8_t total_zeros_bits[16][16]= {
  134. {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
  135. {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
  136. {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
  137. {3,7,5,4,6,5,4,3,3,2,2,1,0},
  138. {5,4,3,7,6,5,4,3,2,1,1,0},
  139. {1,1,7,6,5,4,3,2,1,1,0},
  140. {1,1,5,4,3,3,2,1,1,0},
  141. {1,1,1,3,3,2,2,1,0},
  142. {1,0,1,3,2,1,1,1},
  143. {1,0,1,3,2,1,1},
  144. {0,1,1,2,1,3},
  145. {0,1,1,1,1},
  146. {0,1,1,1},
  147. {0,1,1},
  148. {0,1},
  149. };
  150. static const uint8_t chroma_dc_total_zeros_len[3][4]= {
  151. { 1, 2, 3, 3,},
  152. { 1, 2, 2, 0,},
  153. { 1, 1, 0, 0,},
  154. };
  155. static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
  156. { 1, 1, 1, 0,},
  157. { 1, 1, 0, 0,},
  158. { 1, 0, 0, 0,},
  159. };
  160. static const uint8_t run_len[7][16]={
  161. {1,1},
  162. {1,2,2},
  163. {2,2,2,2},
  164. {2,2,2,3,3},
  165. {2,2,3,3,3,3},
  166. {2,3,3,3,3,3,3},
  167. {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
  168. };
  169. static const uint8_t run_bits[7][16]={
  170. {1,0},
  171. {1,1,0},
  172. {3,2,1,0},
  173. {3,2,1,1,0},
  174. {3,2,3,2,1,0},
  175. {3,0,1,3,2,5,4},
  176. {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
  177. };
  178. static VLC coeff_token_vlc[4];
  179. static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
  180. static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
  181. static VLC chroma_dc_coeff_token_vlc;
  182. static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
  183. static const int chroma_dc_coeff_token_vlc_table_size = 256;
  184. static VLC total_zeros_vlc[15];
  185. static VLC_TYPE total_zeros_vlc_tables[15][512][2];
  186. static const int total_zeros_vlc_tables_size = 512;
  187. static VLC chroma_dc_total_zeros_vlc[3];
  188. static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
  189. static const int chroma_dc_total_zeros_vlc_tables_size = 8;
  190. static VLC run_vlc[6];
  191. static VLC_TYPE run_vlc_tables[6][8][2];
  192. static const int run_vlc_tables_size = 8;
  193. static VLC run7_vlc;
  194. static VLC_TYPE run7_vlc_table[96][2];
  195. static const int run7_vlc_table_size = 96;
  196. #define LEVEL_TAB_BITS 8
  197. static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
  198. /**
  199. * gets the predicted number of non-zero coefficients.
  200. * @param n block index
  201. */
  202. static inline int pred_non_zero_count(H264Context *h, int n){
  203. const int index8= scan8[n];
  204. const int left= h->non_zero_count_cache[index8 - 1];
  205. const int top = h->non_zero_count_cache[index8 - 8];
  206. int i= left + top;
  207. if(i<64) i= (i+1)>>1;
  208. tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
  209. return i&31;
  210. }
  211. static av_cold void init_cavlc_level_tab(void){
  212. int suffix_length, mask;
  213. unsigned int i;
  214. for(suffix_length=0; suffix_length<7; suffix_length++){
  215. for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
  216. int prefix= LEVEL_TAB_BITS - av_log2(2*i);
  217. int level_code= (prefix<<suffix_length) + (i>>(LEVEL_TAB_BITS-prefix-1-suffix_length)) - (1<<suffix_length);
  218. mask= -(level_code&1);
  219. level_code= (((2+level_code)>>1) ^ mask) - mask;
  220. if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
  221. cavlc_level_tab[suffix_length][i][0]= level_code;
  222. cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
  223. }else if(prefix + 1 <= LEVEL_TAB_BITS){
  224. cavlc_level_tab[suffix_length][i][0]= prefix+100;
  225. cavlc_level_tab[suffix_length][i][1]= prefix + 1;
  226. }else{
  227. cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
  228. cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
  229. }
  230. }
  231. }
  232. }
  233. av_cold void ff_h264_decode_init_vlc(void){
  234. static int done = 0;
  235. if (!done) {
  236. int i;
  237. int offset;
  238. done = 1;
  239. chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
  240. chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
  241. init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
  242. &chroma_dc_coeff_token_len [0], 1, 1,
  243. &chroma_dc_coeff_token_bits[0], 1, 1,
  244. INIT_VLC_USE_NEW_STATIC);
  245. offset = 0;
  246. for(i=0; i<4; i++){
  247. coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
  248. coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
  249. init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
  250. &coeff_token_len [i][0], 1, 1,
  251. &coeff_token_bits[i][0], 1, 1,
  252. INIT_VLC_USE_NEW_STATIC);
  253. offset += coeff_token_vlc_tables_size[i];
  254. }
  255. /*
  256. * This is a one time safety check to make sure that
  257. * the packed static coeff_token_vlc table sizes
  258. * were initialized correctly.
  259. */
  260. assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
  261. for(i=0; i<3; i++){
  262. chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
  263. chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
  264. init_vlc(&chroma_dc_total_zeros_vlc[i],
  265. CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
  266. &chroma_dc_total_zeros_len [i][0], 1, 1,
  267. &chroma_dc_total_zeros_bits[i][0], 1, 1,
  268. INIT_VLC_USE_NEW_STATIC);
  269. }
  270. for(i=0; i<15; i++){
  271. total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
  272. total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
  273. init_vlc(&total_zeros_vlc[i],
  274. TOTAL_ZEROS_VLC_BITS, 16,
  275. &total_zeros_len [i][0], 1, 1,
  276. &total_zeros_bits[i][0], 1, 1,
  277. INIT_VLC_USE_NEW_STATIC);
  278. }
  279. for(i=0; i<6; i++){
  280. run_vlc[i].table = run_vlc_tables[i];
  281. run_vlc[i].table_allocated = run_vlc_tables_size;
  282. init_vlc(&run_vlc[i],
  283. RUN_VLC_BITS, 7,
  284. &run_len [i][0], 1, 1,
  285. &run_bits[i][0], 1, 1,
  286. INIT_VLC_USE_NEW_STATIC);
  287. }
  288. run7_vlc.table = run7_vlc_table,
  289. run7_vlc.table_allocated = run7_vlc_table_size;
  290. init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
  291. &run_len [6][0], 1, 1,
  292. &run_bits[6][0], 1, 1,
  293. INIT_VLC_USE_NEW_STATIC);
  294. init_cavlc_level_tab();
  295. }
  296. }
  297. /**
  298. *
  299. */
  300. static inline int get_level_prefix(GetBitContext *gb){
  301. unsigned int buf;
  302. int log;
  303. OPEN_READER(re, gb);
  304. UPDATE_CACHE(re, gb);
  305. buf=GET_CACHE(re, gb);
  306. log= 32 - av_log2(buf);
  307. #ifdef TRACE
  308. print_bin(buf>>(32-log), log);
  309. av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__);
  310. #endif
  311. LAST_SKIP_BITS(re, gb, log);
  312. CLOSE_READER(re, gb);
  313. return log-1;
  314. }
  315. /**
  316. * decodes a residual block.
  317. * @param n block index
  318. * @param scantable scantable
  319. * @param max_coeff number of coefficients in the block
  320. * @return <0 if an error occurred
  321. */
  322. static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
  323. MpegEncContext * const s = &h->s;
  324. static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};
  325. int level[16];
  326. int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
  327. //FIXME put trailing_onex into the context
  328. if(n == CHROMA_DC_BLOCK_INDEX){
  329. coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
  330. total_coeff= coeff_token>>2;
  331. }else{
  332. if(n == LUMA_DC_BLOCK_INDEX){
  333. total_coeff= pred_non_zero_count(h, 0);
  334. coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
  335. total_coeff= coeff_token>>2;
  336. }else{
  337. total_coeff= pred_non_zero_count(h, n);
  338. coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
  339. total_coeff= coeff_token>>2;
  340. h->non_zero_count_cache[ scan8[n] ]= total_coeff;
  341. }
  342. }
  343. //FIXME set last_non_zero?
  344. if(total_coeff==0)
  345. return 0;
  346. if(total_coeff > (unsigned)max_coeff) {
  347. av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", s->mb_x, s->mb_y, total_coeff);
  348. return -1;
  349. }
  350. trailing_ones= coeff_token&3;
  351. tprintf(h->s.avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
  352. assert(total_coeff<=16);
  353. i = show_bits(gb, 3);
  354. skip_bits(gb, trailing_ones);
  355. level[0] = 1-((i&4)>>1);
  356. level[1] = 1-((i&2) );
  357. level[2] = 1-((i&1)<<1);
  358. if(trailing_ones<total_coeff) {
  359. int mask, prefix;
  360. int suffix_length = total_coeff > 10 & trailing_ones < 3;
  361. int bitsi= show_bits(gb, LEVEL_TAB_BITS);
  362. int level_code= cavlc_level_tab[suffix_length][bitsi][0];
  363. skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
  364. if(level_code >= 100){
  365. prefix= level_code - 100;
  366. if(prefix == LEVEL_TAB_BITS)
  367. prefix += get_level_prefix(gb);
  368. //first coefficient has suffix_length equal to 0 or 1
  369. if(prefix<14){ //FIXME try to build a large unified VLC table for all this
  370. if(suffix_length)
  371. level_code= (prefix<<1) + get_bits1(gb); //part
  372. else
  373. level_code= prefix; //part
  374. }else if(prefix==14){
  375. if(suffix_length)
  376. level_code= (prefix<<1) + get_bits1(gb); //part
  377. else
  378. level_code= prefix + get_bits(gb, 4); //part
  379. }else{
  380. level_code= 30 + get_bits(gb, prefix-3); //part
  381. if(prefix>=16)
  382. level_code += (1<<(prefix-3))-4096;
  383. }
  384. if(trailing_ones < 3) level_code += 2;
  385. suffix_length = 2;
  386. mask= -(level_code&1);
  387. level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
  388. }else{
  389. level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
  390. suffix_length = 1 + (level_code + 3U > 6U);
  391. level[trailing_ones]= level_code;
  392. }
  393. //remaining coefficients have suffix_length > 0
  394. for(i=trailing_ones+1;i<total_coeff;i++) {
  395. static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
  396. int bitsi= show_bits(gb, LEVEL_TAB_BITS);
  397. level_code= cavlc_level_tab[suffix_length][bitsi][0];
  398. skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
  399. if(level_code >= 100){
  400. prefix= level_code - 100;
  401. if(prefix == LEVEL_TAB_BITS){
  402. prefix += get_level_prefix(gb);
  403. }
  404. if(prefix<15){
  405. level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
  406. }else{
  407. level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
  408. if(prefix>=16)
  409. level_code += (1<<(prefix-3))-4096;
  410. }
  411. mask= -(level_code&1);
  412. level_code= (((2+level_code)>>1) ^ mask) - mask;
  413. }
  414. level[i]= level_code;
  415. suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
  416. }
  417. }
  418. if(total_coeff == max_coeff)
  419. zeros_left=0;
  420. else{
  421. if(n == CHROMA_DC_BLOCK_INDEX)
  422. zeros_left= get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[ total_coeff ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
  423. else
  424. zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
  425. }
  426. coeff_num = zeros_left + total_coeff - 1;
  427. j = scantable[coeff_num];
  428. if(n > 24){
  429. block[j] = level[0];
  430. for(i=1;i<total_coeff;i++) {
  431. if(zeros_left <= 0)
  432. run_before = 0;
  433. else if(zeros_left < 7){
  434. run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1);
  435. }else{
  436. run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
  437. }
  438. zeros_left -= run_before;
  439. coeff_num -= 1 + run_before;
  440. j= scantable[ coeff_num ];
  441. block[j]= level[i];
  442. }
  443. }else{
  444. block[j] = (level[0] * qmul[j] + 32)>>6;
  445. for(i=1;i<total_coeff;i++) {
  446. if(zeros_left <= 0)
  447. run_before = 0;
  448. else if(zeros_left < 7){
  449. run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1);
  450. }else{
  451. run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
  452. }
  453. zeros_left -= run_before;
  454. coeff_num -= 1 + run_before;
  455. j= scantable[ coeff_num ];
  456. block[j]= (level[i] * qmul[j] + 32)>>6;
  457. }
  458. }
  459. if(zeros_left<0){
  460. av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
  461. return -1;
  462. }
  463. return 0;
  464. }
  465. int ff_h264_decode_mb_cavlc(H264Context *h){
  466. MpegEncContext * const s = &h->s;
  467. int mb_xy;
  468. int partition_count;
  469. unsigned int mb_type, cbp;
  470. int dct8x8_allowed= h->pps.transform_8x8_mode;
  471. mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
  472. tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
  473. cbp = 0; /* avoid warning. FIXME: find a solution without slowing
  474. down the code */
  475. if(h->slice_type_nos != FF_I_TYPE){
  476. if(s->mb_skip_run==-1)
  477. s->mb_skip_run= get_ue_golomb(&s->gb);
  478. if (s->mb_skip_run--) {
  479. if(FRAME_MBAFF && (s->mb_y&1) == 0){
  480. if(s->mb_skip_run==0)
  481. h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
  482. else
  483. predict_field_decoding_flag(h);
  484. }
  485. decode_mb_skip(h);
  486. return 0;
  487. }
  488. }
  489. if(FRAME_MBAFF){
  490. if( (s->mb_y&1) == 0 )
  491. h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
  492. }
  493. h->prev_mb_skipped= 0;
  494. mb_type= get_ue_golomb(&s->gb);
  495. if(h->slice_type_nos == FF_B_TYPE){
  496. if(mb_type < 23){
  497. partition_count= b_mb_type_info[mb_type].partition_count;
  498. mb_type= b_mb_type_info[mb_type].type;
  499. }else{
  500. mb_type -= 23;
  501. goto decode_intra_mb;
  502. }
  503. }else if(h->slice_type_nos == FF_P_TYPE){
  504. if(mb_type < 5){
  505. partition_count= p_mb_type_info[mb_type].partition_count;
  506. mb_type= p_mb_type_info[mb_type].type;
  507. }else{
  508. mb_type -= 5;
  509. goto decode_intra_mb;
  510. }
  511. }else{
  512. assert(h->slice_type_nos == FF_I_TYPE);
  513. if(h->slice_type == FF_SI_TYPE && mb_type)
  514. mb_type--;
  515. decode_intra_mb:
  516. if(mb_type > 25){
  517. av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
  518. return -1;
  519. }
  520. partition_count=0;
  521. cbp= i_mb_type_info[mb_type].cbp;
  522. h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
  523. mb_type= i_mb_type_info[mb_type].type;
  524. }
  525. if(MB_FIELD)
  526. mb_type |= MB_TYPE_INTERLACED;
  527. h->slice_table[ mb_xy ]= h->slice_num;
  528. if(IS_INTRA_PCM(mb_type)){
  529. unsigned int x;
  530. // We assume these blocks are very rare so we do not optimize it.
  531. align_get_bits(&s->gb);
  532. // The pixels are stored in the same order as levels in h->mb array.
  533. for(x=0; x < (CHROMA ? 384 : 256); x++){
  534. ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);
  535. }
  536. // In deblocking, the quantizer is 0
  537. s->current_picture.qscale_table[mb_xy]= 0;
  538. // All coeffs are present
  539. memset(h->non_zero_count[mb_xy], 16, 32);
  540. s->current_picture.mb_type[mb_xy]= mb_type;
  541. return 0;
  542. }
  543. if(MB_MBAFF){
  544. h->ref_count[0] <<= 1;
  545. h->ref_count[1] <<= 1;
  546. }
  547. fill_decode_caches(h, mb_type);
  548. //mb_pred
  549. if(IS_INTRA(mb_type)){
  550. int pred_mode;
  551. // init_top_left_availability(h);
  552. if(IS_INTRA4x4(mb_type)){
  553. int i;
  554. int di = 1;
  555. if(dct8x8_allowed && get_bits1(&s->gb)){
  556. mb_type |= MB_TYPE_8x8DCT;
  557. di = 4;
  558. }
  559. // fill_intra4x4_pred_table(h);
  560. for(i=0; i<16; i+=di){
  561. int mode= pred_intra_mode(h, i);
  562. if(!get_bits1(&s->gb)){
  563. const int rem_mode= get_bits(&s->gb, 3);
  564. mode = rem_mode + (rem_mode >= mode);
  565. }
  566. if(di==4)
  567. fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
  568. else
  569. h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
  570. }
  571. ff_h264_write_back_intra_pred_mode(h);
  572. if( ff_h264_check_intra4x4_pred_mode(h) < 0)
  573. return -1;
  574. }else{
  575. h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode);
  576. if(h->intra16x16_pred_mode < 0)
  577. return -1;
  578. }
  579. if(CHROMA){
  580. pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&s->gb));
  581. if(pred_mode < 0)
  582. return -1;
  583. h->chroma_pred_mode= pred_mode;
  584. }
  585. }else if(partition_count==4){
  586. int i, j, sub_partition_count[4], list, ref[2][4];
  587. if(h->slice_type_nos == FF_B_TYPE){
  588. for(i=0; i<4; i++){
  589. h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
  590. if(h->sub_mb_type[i] >=13){
  591. av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
  592. return -1;
  593. }
  594. sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  595. h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  596. }
  597. if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
  598. ff_h264_pred_direct_motion(h, &mb_type);
  599. h->ref_cache[0][scan8[4]] =
  600. h->ref_cache[1][scan8[4]] =
  601. h->ref_cache[0][scan8[12]] =
  602. h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
  603. }
  604. }else{
  605. assert(h->slice_type_nos == FF_P_TYPE); //FIXME SP correct ?
  606. for(i=0; i<4; i++){
  607. h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
  608. if(h->sub_mb_type[i] >=4){
  609. av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
  610. return -1;
  611. }
  612. sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
  613. h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
  614. }
  615. }
  616. for(list=0; list<h->list_count; list++){
  617. int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
  618. for(i=0; i<4; i++){
  619. if(IS_DIRECT(h->sub_mb_type[i])) continue;
  620. if(IS_DIR(h->sub_mb_type[i], 0, list)){
  621. unsigned int tmp;
  622. if(ref_count == 1){
  623. tmp= 0;
  624. }else if(ref_count == 2){
  625. tmp= get_bits1(&s->gb)^1;
  626. }else{
  627. tmp= get_ue_golomb_31(&s->gb);
  628. if(tmp>=ref_count){
  629. av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
  630. return -1;
  631. }
  632. }
  633. ref[list][i]= tmp;
  634. }else{
  635. //FIXME
  636. ref[list][i] = -1;
  637. }
  638. }
  639. }
  640. if(dct8x8_allowed)
  641. dct8x8_allowed = get_dct8x8_allowed(h);
  642. for(list=0; list<h->list_count; list++){
  643. for(i=0; i<4; i++){
  644. if(IS_DIRECT(h->sub_mb_type[i])) {
  645. h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
  646. continue;
  647. }
  648. h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
  649. h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
  650. if(IS_DIR(h->sub_mb_type[i], 0, list)){
  651. const int sub_mb_type= h->sub_mb_type[i];
  652. const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
  653. for(j=0; j<sub_partition_count[i]; j++){
  654. int mx, my;
  655. const int index= 4*i + block_width*j;
  656. int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
  657. pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
  658. mx += get_se_golomb(&s->gb);
  659. my += get_se_golomb(&s->gb);
  660. tprintf(s->avctx, "final mv:%d %d\n", mx, my);
  661. if(IS_SUB_8X8(sub_mb_type)){
  662. mv_cache[ 1 ][0]=
  663. mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
  664. mv_cache[ 1 ][1]=
  665. mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
  666. }else if(IS_SUB_8X4(sub_mb_type)){
  667. mv_cache[ 1 ][0]= mx;
  668. mv_cache[ 1 ][1]= my;
  669. }else if(IS_SUB_4X8(sub_mb_type)){
  670. mv_cache[ 8 ][0]= mx;
  671. mv_cache[ 8 ][1]= my;
  672. }
  673. mv_cache[ 0 ][0]= mx;
  674. mv_cache[ 0 ][1]= my;
  675. }
  676. }else{
  677. uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
  678. p[0] = p[1]=
  679. p[8] = p[9]= 0;
  680. }
  681. }
  682. }
  683. }else if(IS_DIRECT(mb_type)){
  684. ff_h264_pred_direct_motion(h, &mb_type);
  685. dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
  686. }else{
  687. int list, mx, my, i;
  688. //FIXME we should set ref_idx_l? to 0 if we use that later ...
  689. if(IS_16X16(mb_type)){
  690. for(list=0; list<h->list_count; list++){
  691. unsigned int val;
  692. if(IS_DIR(mb_type, 0, list)){
  693. if(h->ref_count[list]==1){
  694. val= 0;
  695. }else if(h->ref_count[list]==2){
  696. val= get_bits1(&s->gb)^1;
  697. }else{
  698. val= get_ue_golomb_31(&s->gb);
  699. if(val >= h->ref_count[list]){
  700. av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
  701. return -1;
  702. }
  703. }
  704. }else
  705. val= LIST_NOT_USED&0xFF;
  706. fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
  707. }
  708. for(list=0; list<h->list_count; list++){
  709. unsigned int val;
  710. if(IS_DIR(mb_type, 0, list)){
  711. pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
  712. mx += get_se_golomb(&s->gb);
  713. my += get_se_golomb(&s->gb);
  714. tprintf(s->avctx, "final mv:%d %d\n", mx, my);
  715. val= pack16to32(mx,my);
  716. }else
  717. val=0;
  718. fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, val, 4);
  719. }
  720. }
  721. else if(IS_16X8(mb_type)){
  722. for(list=0; list<h->list_count; list++){
  723. for(i=0; i<2; i++){
  724. unsigned int val;
  725. if(IS_DIR(mb_type, i, list)){
  726. if(h->ref_count[list] == 1){
  727. val= 0;
  728. }else if(h->ref_count[list] == 2){
  729. val= get_bits1(&s->gb)^1;
  730. }else{
  731. val= get_ue_golomb_31(&s->gb);
  732. if(val >= h->ref_count[list]){
  733. av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
  734. return -1;
  735. }
  736. }
  737. }else
  738. val= LIST_NOT_USED&0xFF;
  739. fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
  740. }
  741. }
  742. for(list=0; list<h->list_count; list++){
  743. for(i=0; i<2; i++){
  744. unsigned int val;
  745. if(IS_DIR(mb_type, i, list)){
  746. pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
  747. mx += get_se_golomb(&s->gb);
  748. my += get_se_golomb(&s->gb);
  749. tprintf(s->avctx, "final mv:%d %d\n", mx, my);
  750. val= pack16to32(mx,my);
  751. }else
  752. val=0;
  753. fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
  754. }
  755. }
  756. }else{
  757. assert(IS_8X16(mb_type));
  758. for(list=0; list<h->list_count; list++){
  759. for(i=0; i<2; i++){
  760. unsigned int val;
  761. if(IS_DIR(mb_type, i, list)){ //FIXME optimize
  762. if(h->ref_count[list]==1){
  763. val= 0;
  764. }else if(h->ref_count[list]==2){
  765. val= get_bits1(&s->gb)^1;
  766. }else{
  767. val= get_ue_golomb_31(&s->gb);
  768. if(val >= h->ref_count[list]){
  769. av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
  770. return -1;
  771. }
  772. }
  773. }else
  774. val= LIST_NOT_USED&0xFF;
  775. fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
  776. }
  777. }
  778. for(list=0; list<h->list_count; list++){
  779. for(i=0; i<2; i++){
  780. unsigned int val;
  781. if(IS_DIR(mb_type, i, list)){
  782. pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
  783. mx += get_se_golomb(&s->gb);
  784. my += get_se_golomb(&s->gb);
  785. tprintf(s->avctx, "final mv:%d %d\n", mx, my);
  786. val= pack16to32(mx,my);
  787. }else
  788. val=0;
  789. fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
  790. }
  791. }
  792. }
  793. }
  794. if(IS_INTER(mb_type))
  795. write_back_motion(h, mb_type);
  796. if(!IS_INTRA16x16(mb_type)){
  797. cbp= get_ue_golomb(&s->gb);
  798. if(cbp > 47){
  799. av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
  800. return -1;
  801. }
  802. if(CHROMA){
  803. if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
  804. else cbp= golomb_to_inter_cbp [cbp];
  805. }else{
  806. if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
  807. else cbp= golomb_to_inter_cbp_gray[cbp];
  808. }
  809. }
  810. if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
  811. mb_type |= MB_TYPE_8x8DCT*get_bits1(&s->gb);
  812. }
  813. h->cbp=
  814. h->cbp_table[mb_xy]= cbp;
  815. s->current_picture.mb_type[mb_xy]= mb_type;
  816. if(cbp || IS_INTRA16x16(mb_type)){
  817. int i8x8, i4x4, chroma_idx;
  818. int dquant;
  819. GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
  820. const uint8_t *scan, *scan8x8, *dc_scan;
  821. if(IS_INTERLACED(mb_type)){
  822. scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
  823. scan= s->qscale ? h->field_scan : h->field_scan_q0;
  824. dc_scan= luma_dc_field_scan;
  825. }else{
  826. scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
  827. scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
  828. dc_scan= luma_dc_zigzag_scan;
  829. }
  830. dquant= get_se_golomb(&s->gb);
  831. s->qscale += dquant;
  832. if(((unsigned)s->qscale) > 51){
  833. if(s->qscale<0) s->qscale+= 52;
  834. else s->qscale-= 52;
  835. if(((unsigned)s->qscale) > 51){
  836. av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
  837. return -1;
  838. }
  839. }
  840. h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
  841. h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
  842. if(IS_INTRA16x16(mb_type)){
  843. if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
  844. return -1; //FIXME continue if partitioned and other return -1 too
  845. }
  846. assert((cbp&15) == 0 || (cbp&15) == 15);
  847. if(cbp&15){
  848. for(i8x8=0; i8x8<4; i8x8++){
  849. for(i4x4=0; i4x4<4; i4x4++){
  850. const int index= i4x4 + 4*i8x8;
  851. if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){
  852. return -1;
  853. }
  854. }
  855. }
  856. }else{
  857. fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
  858. }
  859. }else{
  860. for(i8x8=0; i8x8<4; i8x8++){
  861. if(cbp & (1<<i8x8)){
  862. if(IS_8x8DCT(mb_type)){
  863. DCTELEM *buf = &h->mb[64*i8x8];
  864. uint8_t *nnz;
  865. for(i4x4=0; i4x4<4; i4x4++){
  866. if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,
  867. h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )
  868. return -1;
  869. }
  870. nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
  871. nnz[0] += nnz[1] + nnz[8] + nnz[9];
  872. }else{
  873. for(i4x4=0; i4x4<4; i4x4++){
  874. const int index= i4x4 + 4*i8x8;
  875. if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){
  876. return -1;
  877. }
  878. }
  879. }
  880. }else{
  881. uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
  882. nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
  883. }
  884. }
  885. }
  886. if(cbp&0x30){
  887. for(chroma_idx=0; chroma_idx<2; chroma_idx++)
  888. if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){
  889. return -1;
  890. }
  891. }
  892. if(cbp&0x20){
  893. for(chroma_idx=0; chroma_idx<2; chroma_idx++){
  894. const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
  895. for(i4x4=0; i4x4<4; i4x4++){
  896. const int index= 16 + 4*chroma_idx + i4x4;
  897. if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){
  898. return -1;
  899. }
  900. }
  901. }
  902. }else{
  903. uint8_t * const nnz= &h->non_zero_count_cache[0];
  904. nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  905. nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  906. }
  907. }else{
  908. uint8_t * const nnz= &h->non_zero_count_cache[0];
  909. fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
  910. nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
  911. nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
  912. }
  913. s->current_picture.qscale_table[mb_xy]= s->qscale;
  914. write_back_non_zero_count(h);
  915. if(MB_MBAFF){
  916. h->ref_count[0] >>= 1;
  917. h->ref_count[1] >>= 1;
  918. }
  919. return 0;
  920. }