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