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