LCOV - code coverage report
Current view: top level - libavcodec - h264_cavlc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 469 504 93.1 %
Date: 2017-12-15 18:13:28 Functions: 7 7 100.0 %

          Line data    Source code
       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 / MPEG-4 part10 cavlc bitstream decoding.
      25             :  * @author Michael Niedermayer <michaelni@gmx.at>
      26             :  */
      27             : 
      28             : #define CABAC(h) 0
      29             : #define UNCHECKED_BITSTREAM_READER 1
      30             : 
      31             : #include "internal.h"
      32             : #include "avcodec.h"
      33             : #include "h264dec.h"
      34             : #include "h264_mvpred.h"
      35             : #include "h264data.h"
      36             : #include "golomb.h"
      37             : #include "mpegutils.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+1];
     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+1];
     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+1];
     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+1];
     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    41946479 : static inline int pred_non_zero_count(const H264Context *h, H264SliceContext *sl, int n)
     288             : {
     289    41946479 :     const int index8= scan8[n];
     290    41946479 :     const int left = sl->non_zero_count_cache[index8 - 1];
     291    41946479 :     const int top  = sl->non_zero_count_cache[index8 - 8];
     292    41946479 :     int i= left + top;
     293             : 
     294    41946479 :     if(i<64) i= (i+1)>>1;
     295             : 
     296             :     ff_tlog(h->avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
     297             : 
     298    41946479 :     return i&31;
     299             : }
     300             : 
     301         267 : static av_cold void init_cavlc_level_tab(void){
     302             :     int suffix_length;
     303             :     unsigned int i;
     304             : 
     305        2136 :     for(suffix_length=0; suffix_length<7; suffix_length++){
     306      480333 :         for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
     307      478464 :             int prefix= LEVEL_TAB_BITS - av_log2(2*i);
     308             : 
     309      478464 :             if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
     310     1333665 :                 int level_code = (prefix << suffix_length) +
     311      889110 :                     (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
     312      444555 :                 int mask = -(level_code&1);
     313      444555 :                 level_code = (((2 + level_code) >> 1) ^ mask) - mask;
     314      444555 :                 cavlc_level_tab[suffix_length][i][0]= level_code;
     315      444555 :                 cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
     316       33909 :             }else if(prefix + 1 <= LEVEL_TAB_BITS){
     317       32040 :                 cavlc_level_tab[suffix_length][i][0]= prefix+100;
     318       32040 :                 cavlc_level_tab[suffix_length][i][1]= prefix + 1;
     319             :             }else{
     320        1869 :                 cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
     321        1869 :                 cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
     322             :             }
     323             :         }
     324             :     }
     325         267 : }
     326             : 
     327         267 : av_cold void ff_h264_decode_init_vlc(void){
     328             :     static int done = 0;
     329             : 
     330         267 :     if (!done) {
     331             :         int i;
     332             :         int offset;
     333         267 :         done = 1;
     334             : 
     335         267 :         chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
     336         267 :         chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
     337         267 :         init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
     338             :                  &chroma_dc_coeff_token_len [0], 1, 1,
     339             :                  &chroma_dc_coeff_token_bits[0], 1, 1,
     340             :                  INIT_VLC_USE_NEW_STATIC);
     341             : 
     342         267 :         chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
     343         267 :         chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
     344         267 :         init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
     345             :                  &chroma422_dc_coeff_token_len [0], 1, 1,
     346             :                  &chroma422_dc_coeff_token_bits[0], 1, 1,
     347             :                  INIT_VLC_USE_NEW_STATIC);
     348             : 
     349         267 :         offset = 0;
     350        1335 :         for(i=0; i<4; i++){
     351        1068 :             coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
     352        1068 :             coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
     353        1068 :             init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
     354             :                      &coeff_token_len [i][0], 1, 1,
     355             :                      &coeff_token_bits[i][0], 1, 1,
     356             :                      INIT_VLC_USE_NEW_STATIC);
     357        1068 :             offset += coeff_token_vlc_tables_size[i];
     358             :         }
     359             :         /*
     360             :          * This is a one time safety check to make sure that
     361             :          * the packed static coeff_token_vlc table sizes
     362             :          * were initialized correctly.
     363             :          */
     364         267 :         av_assert0(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
     365             : 
     366        1068 :         for(i=0; i<3; i++){
     367         801 :             chroma_dc_total_zeros_vlc[i+1].table = chroma_dc_total_zeros_vlc_tables[i];
     368         801 :             chroma_dc_total_zeros_vlc[i+1].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
     369         801 :             init_vlc(&chroma_dc_total_zeros_vlc[i+1],
     370             :                      CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
     371             :                      &chroma_dc_total_zeros_len [i][0], 1, 1,
     372             :                      &chroma_dc_total_zeros_bits[i][0], 1, 1,
     373             :                      INIT_VLC_USE_NEW_STATIC);
     374             :         }
     375             : 
     376        2136 :         for(i=0; i<7; i++){
     377        1869 :             chroma422_dc_total_zeros_vlc[i+1].table = chroma422_dc_total_zeros_vlc_tables[i];
     378        1869 :             chroma422_dc_total_zeros_vlc[i+1].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
     379        1869 :             init_vlc(&chroma422_dc_total_zeros_vlc[i+1],
     380             :                      CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
     381             :                      &chroma422_dc_total_zeros_len [i][0], 1, 1,
     382             :                      &chroma422_dc_total_zeros_bits[i][0], 1, 1,
     383             :                      INIT_VLC_USE_NEW_STATIC);
     384             :         }
     385             : 
     386        4272 :         for(i=0; i<15; i++){
     387        4005 :             total_zeros_vlc[i+1].table = total_zeros_vlc_tables[i];
     388        4005 :             total_zeros_vlc[i+1].table_allocated = total_zeros_vlc_tables_size;
     389        4005 :             init_vlc(&total_zeros_vlc[i+1],
     390             :                      TOTAL_ZEROS_VLC_BITS, 16,
     391             :                      &total_zeros_len [i][0], 1, 1,
     392             :                      &total_zeros_bits[i][0], 1, 1,
     393             :                      INIT_VLC_USE_NEW_STATIC);
     394             :         }
     395             : 
     396        1869 :         for(i=0; i<6; i++){
     397        1602 :             run_vlc[i+1].table = run_vlc_tables[i];
     398        1602 :             run_vlc[i+1].table_allocated = run_vlc_tables_size;
     399        1602 :             init_vlc(&run_vlc[i+1],
     400             :                      RUN_VLC_BITS, 7,
     401             :                      &run_len [i][0], 1, 1,
     402             :                      &run_bits[i][0], 1, 1,
     403             :                      INIT_VLC_USE_NEW_STATIC);
     404             :         }
     405         267 :         run7_vlc.table = run7_vlc_table,
     406         267 :         run7_vlc.table_allocated = run7_vlc_table_size;
     407         267 :         init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
     408             :                  &run_len [6][0], 1, 1,
     409             :                  &run_bits[6][0], 1, 1,
     410             :                  INIT_VLC_USE_NEW_STATIC);
     411             : 
     412         267 :         init_cavlc_level_tab();
     413             :     }
     414         267 : }
     415             : 
     416      682985 : static inline int get_level_prefix(GetBitContext *gb){
     417             :     unsigned int buf;
     418             :     int log;
     419             : 
     420      682985 :     OPEN_READER(re, gb);
     421      682985 :     UPDATE_CACHE(re, gb);
     422      682985 :     buf=GET_CACHE(re, gb);
     423             : 
     424      682985 :     log= 32 - av_log2(buf);
     425             : 
     426      682985 :     LAST_SKIP_BITS(re, gb, log);
     427      682985 :     CLOSE_READER(re, gb);
     428             : 
     429      682985 :     return log-1;
     430             : }
     431             : 
     432             : /**
     433             :  * Decode a residual block.
     434             :  * @param n block index
     435             :  * @param scantable scantable
     436             :  * @param max_coeff number of coefficients in the block
     437             :  * @return <0 if an error occurred
     438             :  */
     439    45081169 : static int decode_residual(const H264Context *h, H264SliceContext *sl,
     440             :                            GetBitContext *gb, int16_t *block, int n,
     441             :                            const uint8_t *scantable, const uint32_t *qmul,
     442             :                            int max_coeff)
     443             : {
     444             :     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};
     445             :     int level[16];
     446             :     int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
     447             : 
     448             :     //FIXME put trailing_onex into the context
     449             : 
     450    45081169 :     if(max_coeff <= 8){
     451     3134690 :         if (max_coeff == 4)
     452     2555632 :             coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
     453             :         else
     454      579058 :             coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
     455     3134690 :         total_coeff= coeff_token>>2;
     456             :     }else{
     457    41946479 :         if(n >= LUMA_DC_BLOCK_INDEX){
     458      208283 :             total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
     459      208283 :             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
     460      208283 :             total_coeff= coeff_token>>2;
     461             :         }else{
     462    41738196 :             total_coeff= pred_non_zero_count(h, sl, n);
     463    41738196 :             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
     464    41738196 :             total_coeff= coeff_token>>2;
     465             :         }
     466             :     }
     467    45081169 :     sl->non_zero_count_cache[scan8[n]] = total_coeff;
     468             : 
     469             :     //FIXME set last_non_zero?
     470             : 
     471    45081169 :     if(total_coeff==0)
     472    15663934 :         return 0;
     473    29417235 :     if(total_coeff > (unsigned)max_coeff) {
     474           0 :         av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
     475           0 :         return -1;
     476             :     }
     477             : 
     478    29417235 :     trailing_ones= coeff_token&3;
     479             :     ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
     480             :     av_assert2(total_coeff<=16);
     481             : 
     482    29417235 :     i = show_bits(gb, 3);
     483    29417235 :     skip_bits(gb, trailing_ones);
     484    29417235 :     level[0] = 1-((i&4)>>1);
     485    29417235 :     level[1] = 1-((i&2)   );
     486    29417235 :     level[2] = 1-((i&1)<<1);
     487             : 
     488    29417235 :     if(trailing_ones<total_coeff) {
     489             :         int mask, prefix;
     490    13389175 :         int suffix_length = total_coeff > 10 & trailing_ones < 3;
     491    13389175 :         int bitsi= show_bits(gb, LEVEL_TAB_BITS);
     492    13389175 :         int level_code= cavlc_level_tab[suffix_length][bitsi][0];
     493             : 
     494    13389175 :         skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
     495    13389175 :         if(level_code >= 100){
     496      305351 :             prefix= level_code - 100;
     497      305351 :             if(prefix == LEVEL_TAB_BITS)
     498      301616 :                 prefix += get_level_prefix(gb);
     499             : 
     500             :             //first coefficient has suffix_length equal to 0 or 1
     501      305351 :             if(prefix<14){ //FIXME try to build a large unified VLC table for all this
     502      184406 :                 if(suffix_length)
     503       12209 :                     level_code= (prefix<<1) + get_bits1(gb); //part
     504             :                 else
     505      172197 :                     level_code= prefix; //part
     506      120945 :             }else if(prefix==14){
     507       55305 :                 if(suffix_length)
     508         536 :                     level_code= (prefix<<1) + get_bits1(gb); //part
     509             :                 else
     510       54769 :                     level_code= prefix + get_bits(gb, 4); //part
     511             :             }else{
     512       65640 :                 level_code= 30;
     513       65640 :                 if(prefix>=16){
     514          24 :                     if(prefix > 25+3){
     515           0 :                         av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
     516           0 :                         return -1;
     517             :                     }
     518          24 :                     level_code += (1<<(prefix-3))-4096;
     519             :                 }
     520       65640 :                 level_code += get_bits(gb, prefix-3); //part
     521             :             }
     522             : 
     523      305351 :             if(trailing_ones < 3) level_code += 2;
     524             : 
     525      305351 :             suffix_length = 2;
     526      305351 :             mask= -(level_code&1);
     527      305351 :             level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
     528             :         }else{
     529    13083824 :             level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
     530             : 
     531    13083824 :             suffix_length = 1 + (level_code + 3U > 6U);
     532    13083824 :             level[trailing_ones]= level_code;
     533             :         }
     534             : 
     535             :         //remaining coefficients have suffix_length > 0
     536    51566640 :         for(i=trailing_ones+1;i<total_coeff;i++) {
     537             :             static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
     538    38177465 :             int bitsi= show_bits(gb, LEVEL_TAB_BITS);
     539    38177465 :             level_code= cavlc_level_tab[suffix_length][bitsi][0];
     540             : 
     541    38177465 :             skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
     542    38177465 :             if(level_code >= 100){
     543      765424 :                 prefix= level_code - 100;
     544      765424 :                 if(prefix == LEVEL_TAB_BITS){
     545      381369 :                     prefix += get_level_prefix(gb);
     546             :                 }
     547      765424 :                 if(prefix<15){
     548      702244 :                     level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
     549             :                 }else{
     550       63180 :                     level_code = 15<<suffix_length;
     551       63180 :                     if (prefix>=16) {
     552           4 :                         if(prefix > 25+3){
     553           0 :                             av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
     554           0 :                             return AVERROR_INVALIDDATA;
     555             :                         }
     556           4 :                         level_code += (1<<(prefix-3))-4096;
     557             :                     }
     558       63180 :                     level_code += get_bits(gb, prefix-3);
     559             :                 }
     560      765424 :                 mask= -(level_code&1);
     561      765424 :                 level_code= (((2+level_code)>>1) ^ mask) - mask;
     562             :             }
     563    38177465 :             level[i]= level_code;
     564    38177465 :             suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
     565             :         }
     566             :     }
     567             : 
     568    29417235 :     if(total_coeff == max_coeff)
     569      291823 :         zeros_left=0;
     570             :     else{
     571    29125412 :         if (max_coeff <= 8) {
     572     1867221 :             if (max_coeff == 4)
     573     1409839 :                 zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff].table,
     574             :                                       CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
     575             :             else
     576      457382 :                 zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff].table,
     577             :                                       CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
     578             :         } else {
     579    27258191 :             zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
     580             :         }
     581             :     }
     582             : 
     583             : #define STORE_BLOCK(type) \
     584             :     scantable += zeros_left + total_coeff - 1; \
     585             :     if(n >= LUMA_DC_BLOCK_INDEX){ \
     586             :         ((type*)block)[*scantable] = level[0]; \
     587             :         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
     588             :             if(zeros_left < 7) \
     589             :                 run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
     590             :             else \
     591             :                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
     592             :             zeros_left -= run_before; \
     593             :             scantable -= 1 + run_before; \
     594             :             ((type*)block)[*scantable]= level[i]; \
     595             :         } \
     596             :         for(;i<total_coeff;i++) { \
     597             :             scantable--; \
     598             :             ((type*)block)[*scantable]= level[i]; \
     599             :         } \
     600             :     }else{ \
     601             :         ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
     602             :         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
     603             :             if(zeros_left < 7) \
     604             :                 run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
     605             :             else \
     606             :                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
     607             :             zeros_left -= run_before; \
     608             :             scantable -= 1 + run_before; \
     609             :             ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
     610             :         } \
     611             :         for(;i<total_coeff;i++) { \
     612             :             scantable--; \
     613             :             ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
     614             :         } \
     615             :     }
     616             : 
     617    29417235 :     if (h->pixel_shift) {
     618    10462176 :         STORE_BLOCK(int32_t)
     619             :     } else {
     620    18955059 :         STORE_BLOCK(int16_t)
     621             :     }
     622             : 
     623    29417235 :     if(zeros_left<0){
     624           0 :         av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
     625           0 :         return -1;
     626             :     }
     627             : 
     628    29417235 :     return 0;
     629             : }
     630             : 
     631             : static av_always_inline
     632     2803906 : int decode_luma_residual(const H264Context *h, H264SliceContext *sl,
     633             :                          GetBitContext *gb, const uint8_t *scan,
     634             :                          const uint8_t *scan8x8, int pixel_shift,
     635             :                          int mb_type, int cbp, int p)
     636             : {
     637             :     int i4x4, i8x8;
     638     2803906 :     int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
     639     2803906 :     if(IS_INTRA16x16(mb_type)){
     640      208283 :         AV_ZERO128(sl->mb_luma_dc[p]+0);
     641      208283 :         AV_ZERO128(sl->mb_luma_dc[p]+8);
     642      208283 :         AV_ZERO128(sl->mb_luma_dc[p]+16);
     643      208283 :         AV_ZERO128(sl->mb_luma_dc[p]+24);
     644      208283 :         if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
     645           0 :             return -1; //FIXME continue if partitioned and other return -1 too
     646             :         }
     647             : 
     648             :         av_assert2((cbp&15) == 0 || (cbp&15) == 15);
     649             : 
     650      208283 :         if(cbp&15){
     651      473005 :             for(i8x8=0; i8x8<4; i8x8++){
     652     1892020 :                 for(i4x4=0; i4x4<4; i4x4++){
     653     1513616 :                     const int index= i4x4 + 4*i8x8 + p*16;
     654     1513616 :                     if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
     655     1513616 :                         index, scan + 1, h->ps.pps->dequant4_coeff[p][qscale], 15) < 0 ){
     656           0 :                         return -1;
     657             :                     }
     658             :                 }
     659             :             }
     660       94601 :             return 0xf;
     661             :         }else{
     662      113682 :             fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
     663      113682 :             return 0;
     664             :         }
     665             :     }else{
     666     2595623 :         int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
     667             :         /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
     668     2595623 :         int new_cbp = 0;
     669    12978115 :         for(i8x8=0; i8x8<4; i8x8++){
     670    10382492 :             if(cbp & (1<<i8x8)){
     671     7656385 :                 if(IS_8x8DCT(mb_type)){
     672     2320357 :                     int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
     673             :                     uint8_t *nnz;
     674    11601785 :                     for(i4x4=0; i4x4<4; i4x4++){
     675     9281428 :                         const int index= i4x4 + 4*i8x8 + p*16;
     676     9281428 :                         if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
     677     9281428 :                                             h->ps.pps->dequant8_coeff[cqm][qscale], 16) < 0 )
     678           0 :                             return -1;
     679             :                     }
     680     2320357 :                     nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
     681     2320357 :                     nnz[0] += nnz[1] + nnz[8] + nnz[9];
     682     2320357 :                     new_cbp |= !!nnz[0] << i8x8;
     683             :                 }else{
     684    26680140 :                     for(i4x4=0; i4x4<4; i4x4++){
     685    21344112 :                         const int index= i4x4 + 4*i8x8 + p*16;
     686    21344112 :                         if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
     687    21344112 :                                             scan, h->ps.pps->dequant4_coeff[cqm][qscale], 16) < 0 ){
     688           0 :                             return -1;
     689             :                         }
     690    21344112 :                         new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
     691             :                     }
     692             :                 }
     693             :             }else{
     694     2726107 :                 uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
     695     2726107 :                 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
     696             :             }
     697             :         }
     698     2595623 :         return new_cbp;
     699             :     }
     700             : }
     701             : 
     702     4343889 : int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
     703             : {
     704             :     int mb_xy;
     705             :     int partition_count;
     706             :     unsigned int mb_type, cbp;
     707     4343889 :     int dct8x8_allowed = h->ps.pps->transform_8x8_mode;
     708     4343889 :     const int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
     709     4343889 :     const int pixel_shift = h->pixel_shift;
     710             : 
     711     4343889 :     mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
     712             : 
     713             :     ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->poc.frame_num, sl->mb_x, sl->mb_y);
     714     4343889 :     cbp = 0; /* avoid warning. FIXME: find a solution without slowing
     715             :                 down the code */
     716     4343889 :     if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
     717     3337385 :         if (sl->mb_skip_run == -1)
     718     2484790 :             sl->mb_skip_run = get_ue_golomb_long(&sl->gb);
     719             : 
     720     3337385 :         if (sl->mb_skip_run--) {
     721      855703 :             if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
     722        5515 :                 if (sl->mb_skip_run == 0)
     723        2894 :                     sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
     724             :             }
     725      855703 :             decode_mb_skip(h, sl);
     726      855703 :             return 0;
     727             :         }
     728             :     }
     729     3488186 :     if (FRAME_MBAFF(h)) {
     730      497835 :         if ((sl->mb_y & 1) == 0)
     731      248957 :             sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
     732             :     }
     733             : 
     734     3488186 :     sl->prev_mb_skipped = 0;
     735             : 
     736     3488186 :     mb_type= get_ue_golomb(&sl->gb);
     737     3488186 :     if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
     738      877411 :         if(mb_type < 23){
     739      736512 :             partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
     740      736512 :             mb_type         = ff_h264_b_mb_type_info[mb_type].type;
     741             :         }else{
     742      140899 :             mb_type -= 23;
     743      140899 :             goto decode_intra_mb;
     744             :         }
     745     2610775 :     } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
     746     1604271 :         if(mb_type < 5){
     747     1367031 :             partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
     748     1367031 :             mb_type         = ff_h264_p_mb_type_info[mb_type].type;
     749             :         }else{
     750      237240 :             mb_type -= 5;
     751      237240 :             goto decode_intra_mb;
     752             :         }
     753             :     }else{
     754             :        av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_I);
     755     1006504 :         if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
     756           0 :             mb_type--;
     757     2391147 : decode_intra_mb:
     758     1384643 :         if(mb_type > 25){
     759           3 :             av_log(h->avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_picture_type_char(sl->slice_type), sl->mb_x, sl->mb_y);
     760           3 :             return -1;
     761             :         }
     762     1384640 :         partition_count=0;
     763     1384640 :         cbp                      = ff_h264_i_mb_type_info[mb_type].cbp;
     764     1384640 :         sl->intra16x16_pred_mode = ff_h264_i_mb_type_info[mb_type].pred_mode;
     765     1384640 :         mb_type                  = ff_h264_i_mb_type_info[mb_type].type;
     766             :     }
     767             : 
     768     3488183 :     if (MB_FIELD(sl))
     769      981362 :         mb_type |= MB_TYPE_INTERLACED;
     770             : 
     771     3488183 :     h->slice_table[mb_xy] = sl->slice_num;
     772             : 
     773     3488183 :     if(IS_INTRA_PCM(mb_type)){
     774       34892 :         const int mb_size = ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] *
     775       17446 :                             h->ps.sps->bit_depth_luma;
     776             : 
     777             :         // We assume these blocks are very rare so we do not optimize it.
     778       17446 :         sl->intra_pcm_ptr = align_get_bits(&sl->gb);
     779       17446 :         if (get_bits_left(&sl->gb) < mb_size) {
     780           0 :             av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
     781           0 :             return AVERROR_INVALIDDATA;
     782             :         }
     783       17446 :         skip_bits_long(&sl->gb, mb_size);
     784             : 
     785             :         // In deblocking, the quantizer is 0
     786       17446 :         h->cur_pic.qscale_table[mb_xy] = 0;
     787             :         // All coeffs are present
     788       17446 :         memset(h->non_zero_count[mb_xy], 16, 48);
     789             : 
     790       17446 :         h->cur_pic.mb_type[mb_xy] = mb_type;
     791       17446 :         return 0;
     792             :     }
     793             : 
     794     3470737 :     fill_decode_neighbors(h, sl, mb_type);
     795     3470737 :     fill_decode_caches(h, sl, mb_type);
     796             : 
     797             :     //mb_pred
     798     3470737 :     if(IS_INTRA(mb_type)){
     799             :         int pred_mode;
     800             : //            init_top_left_availability(h);
     801     1367194 :         if(IS_INTRA4x4(mb_type)){
     802             :             int i;
     803     1158903 :             int di = 1;
     804     1158903 :             if(dct8x8_allowed && get_bits1(&sl->gb)){
     805      541655 :                 mb_type |= MB_TYPE_8x8DCT;
     806      541655 :                 di = 4;
     807             :             }
     808             : 
     809             : //                fill_intra4x4_pred_table(h);
     810    13201491 :             for(i=0; i<16; i+=di){
     811    12042588 :                 int mode = pred_intra_mode(h, sl, i);
     812             : 
     813    12042588 :                 if(!get_bits1(&sl->gb)){
     814     6502103 :                     const int rem_mode= get_bits(&sl->gb, 3);
     815     6502103 :                     mode = rem_mode + (rem_mode >= mode);
     816             :                 }
     817             : 
     818    12042588 :                 if(di==4)
     819     2166620 :                     fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
     820             :                 else
     821     9875968 :                     sl->intra4x4_pred_mode_cache[scan8[i]] = mode;
     822             :             }
     823     1158903 :             write_back_intra_pred_mode(h, sl);
     824     2317806 :             if (ff_h264_check_intra4x4_pred_mode(sl->intra4x4_pred_mode_cache, h->avctx,
     825     2317806 :                                                  sl->top_samples_available, sl->left_samples_available) < 0)
     826           0 :                 return -1;
     827             :         }else{
     828      416582 :             sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
     829      208291 :                                                                      sl->left_samples_available, sl->intra16x16_pred_mode, 0);
     830      208291 :             if (sl->intra16x16_pred_mode < 0)
     831           4 :                 return -1;
     832             :         }
     833     1367190 :         if(decode_chroma){
     834     2680122 :             pred_mode= ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
     835     1340061 :                                                      sl->left_samples_available, get_ue_golomb_31(&sl->gb), 1);
     836     1340061 :             if(pred_mode < 0)
     837           4 :                 return -1;
     838     1340057 :             sl->chroma_pred_mode = pred_mode;
     839             :         } else {
     840       27129 :             sl->chroma_pred_mode = DC_128_PRED8x8;
     841             :         }
     842     2103543 :     }else if(partition_count==4){
     843             :         int i, j, sub_partition_count[4], list, ref[2][4];
     844             : 
     845      511483 :         if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
     846      889995 :             for(i=0; i<4; i++){
     847      711996 :                 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
     848      711996 :                 if(sl->sub_mb_type[i] >=13){
     849           0 :                     av_log(h->avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
     850           1 :                     return -1;
     851             :                 }
     852      711996 :                 sub_partition_count[i] = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
     853      711996 :                 sl->sub_mb_type[i]     = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].type;
     854             :             }
     855      177999 :             if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
     856       55683 :                 ff_h264_pred_direct_motion(h, sl, &mb_type);
     857      111366 :                 sl->ref_cache[0][scan8[4]] =
     858      167049 :                 sl->ref_cache[1][scan8[4]] =
     859      167049 :                 sl->ref_cache[0][scan8[12]] =
     860      111366 :                 sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
     861             :             }
     862             :         }else{
     863             :             av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
     864     1667419 :             for(i=0; i<4; i++){
     865     1333936 :                 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
     866     1333936 :                 if(sl->sub_mb_type[i] >=4){
     867           1 :                     av_log(h->avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
     868           1 :                     return -1;
     869             :                 }
     870     1333935 :                 sub_partition_count[i] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
     871     1333935 :                 sl->sub_mb_type[i]     = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].type;
     872             :             }
     873             :         }
     874             : 
     875     1200963 :         for (list = 0; list < sl->list_count; list++) {
     876      689481 :             int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
     877     3447405 :             for(i=0; i<4; i++){
     878     2757924 :                 if(IS_DIRECT(sl->sub_mb_type[i])) continue;
     879     2527266 :                 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
     880             :                     unsigned int tmp;
     881     2200238 :                     if(ref_count == 1){
     882      756045 :                         tmp= 0;
     883     1444193 :                     }else if(ref_count == 2){
     884      454436 :                         tmp= get_bits1(&sl->gb)^1;
     885             :                     }else{
     886      989757 :                         tmp= get_ue_golomb_31(&sl->gb);
     887      989757 :                         if(tmp>=ref_count){
     888           0 :                             av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
     889           0 :                             return -1;
     890             :                         }
     891             :                     }
     892     2200238 :                     ref[list][i]= tmp;
     893             :                 }else{
     894             :                  //FIXME
     895      327028 :                     ref[list][i] = -1;
     896             :                 }
     897             :             }
     898             :         }
     899             : 
     900      511482 :         if(dct8x8_allowed)
     901       51527 :             dct8x8_allowed = get_dct8x8_allowed(h, sl);
     902             : 
     903     1200963 :         for (list = 0; list < sl->list_count; list++) {
     904     3447405 :             for(i=0; i<4; i++){
     905     2757924 :                 if(IS_DIRECT(sl->sub_mb_type[i])) {
     906      230658 :                     sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
     907      230658 :                     continue;
     908             :                 }
     909     5054532 :                 sl->ref_cache[list][ scan8[4*i]   ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
     910     5054532 :                 sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
     911             : 
     912     2527266 :                 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
     913     2200238 :                     const int sub_mb_type= sl->sub_mb_type[i];
     914     2200238 :                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
     915     5863666 :                     for(j=0; j<sub_partition_count[i]; j++){
     916             :                         int mx, my;
     917     3663428 :                         const int index= 4*i + block_width*j;
     918     3663428 :                         int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
     919     3663428 :                         pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
     920     3663428 :                         mx += get_se_golomb(&sl->gb);
     921     3663428 :                         my += get_se_golomb(&sl->gb);
     922             :                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
     923             : 
     924     3663428 :                         if(IS_SUB_8X8(sub_mb_type)){
     925     2283068 :                             mv_cache[ 1 ][0]=
     926     2283068 :                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
     927     2283068 :                             mv_cache[ 1 ][1]=
     928     2283068 :                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
     929     2521894 :                         }else if(IS_SUB_8X4(sub_mb_type)){
     930     1024320 :                             mv_cache[ 1 ][0]= mx;
     931     1024320 :                             mv_cache[ 1 ][1]= my;
     932     1497574 :                         }else if(IS_SUB_4X8(sub_mb_type)){
     933      688602 :                             mv_cache[ 8 ][0]= mx;
     934      688602 :                             mv_cache[ 8 ][1]= my;
     935             :                         }
     936     3663428 :                         mv_cache[ 0 ][0]= mx;
     937     3663428 :                         mv_cache[ 0 ][1]= my;
     938             :                     }
     939             :                 }else{
     940      327028 :                     uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
     941      654056 :                     p[0] = p[1]=
     942      654056 :                     p[8] = p[9]= 0;
     943             :                 }
     944             :             }
     945             :         }
     946     1592060 :     }else if(IS_DIRECT(mb_type)){
     947      120891 :         ff_h264_pred_direct_motion(h, sl, &mb_type);
     948      120891 :         dct8x8_allowed &= h->ps.sps->direct_8x8_inference_flag;
     949             :     }else{
     950             :         int list, mx, my, i;
     951             :          //FIXME we should set ref_idx_l? to 0 if we use that later ...
     952     1471169 :         if(IS_16X16(mb_type)){
     953     2248138 :             for (list = 0; list < sl->list_count; list++) {
     954             :                     unsigned int val;
     955     1253730 :                     if(IS_DIR(mb_type, 0, list)){
     956     1050176 :                         unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
     957     1050176 :                         if (rc == 1) {
     958      550938 :                             val= 0;
     959      499238 :                         } else if (rc == 2) {
     960      135504 :                             val= get_bits1(&sl->gb)^1;
     961             :                         }else{
     962      363734 :                             val= get_ue_golomb_31(&sl->gb);
     963      363734 :                             if (val >= rc) {
     964           0 :                                 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
     965           1 :                                 return -1;
     966             :                             }
     967             :                         }
     968     1050176 :                     fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
     969             :                     }
     970             :             }
     971     2248138 :             for (list = 0; list < sl->list_count; list++) {
     972     1253730 :                 if(IS_DIR(mb_type, 0, list)){
     973     1050176 :                     pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
     974     1050176 :                     mx += get_se_golomb(&sl->gb);
     975     1050176 :                     my += get_se_golomb(&sl->gb);
     976             :                     ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
     977             : 
     978     1050176 :                     fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
     979             :                 }
     980             :             }
     981             :         }
     982      476761 :         else if(IS_16X8(mb_type)){
     983      603268 :             for (list = 0; list < sl->list_count; list++) {
     984     1052512 :                     for(i=0; i<2; i++){
     985             :                         unsigned int val;
     986      701675 :                         if(IS_DIR(mb_type, i, list)){
     987      547617 :                             unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
     988      547617 :                             if (rc == 1) {
     989      205017 :                                 val= 0;
     990      342600 :                             } else if (rc == 2) {
     991       80255 :                                 val= get_bits1(&sl->gb)^1;
     992             :                             }else{
     993      262345 :                                 val= get_ue_golomb_31(&sl->gb);
     994      262345 :                                 if (val >= rc) {
     995           1 :                                     av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
     996           1 :                                     return -1;
     997             :                                 }
     998             :                             }
     999             :                         }else
    1000      154058 :                             val= LIST_NOT_USED&0xFF;
    1001      701674 :                         fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
    1002             :                     }
    1003             :             }
    1004      603267 :             for (list = 0; list < sl->list_count; list++) {
    1005     1052511 :                 for(i=0; i<2; i++){
    1006             :                     unsigned int val;
    1007      701674 :                     if(IS_DIR(mb_type, i, list)){
    1008      547616 :                         pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
    1009      547616 :                         mx += get_se_golomb(&sl->gb);
    1010      547616 :                         my += get_se_golomb(&sl->gb);
    1011             :                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
    1012             : 
    1013      547616 :                         val= pack16to32(mx,my);
    1014             :                     }else
    1015      154058 :                         val=0;
    1016      701674 :                     fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
    1017             :                 }
    1018             :             }
    1019             :         }else{
    1020             :             av_assert2(IS_8X16(mb_type));
    1021      528553 :             for (list = 0; list < sl->list_count; list++) {
    1022      912669 :                     for(i=0; i<2; i++){
    1023             :                         unsigned int val;
    1024      608446 :                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
    1025      481848 :                             unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
    1026      481848 :                             if (rc == 1) {
    1027      180847 :                                 val= 0;
    1028      301001 :                             } else if (rc == 2) {
    1029       82740 :                                 val= get_bits1(&sl->gb)^1;
    1030             :                             }else{
    1031      218261 :                                 val= get_ue_golomb_31(&sl->gb);
    1032      218261 :                                 if (val >= rc) {
    1033           0 :                                     av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
    1034           0 :                                     return -1;
    1035             :                                 }
    1036             :                             }
    1037             :                         }else
    1038      126598 :                             val= LIST_NOT_USED&0xFF;
    1039      608446 :                         fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
    1040             :                     }
    1041             :             }
    1042      528553 :             for (list = 0; list < sl->list_count; list++) {
    1043      912669 :                 for(i=0; i<2; i++){
    1044             :                     unsigned int val;
    1045      608446 :                     if(IS_DIR(mb_type, i, list)){
    1046      481848 :                         pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
    1047      481848 :                         mx += get_se_golomb(&sl->gb);
    1048      481848 :                         my += get_se_golomb(&sl->gb);
    1049             :                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
    1050             : 
    1051      481848 :                         val= pack16to32(mx,my);
    1052             :                     }else
    1053      126598 :                         val=0;
    1054      608446 :                     fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
    1055             :                 }
    1056             :             }
    1057             :         }
    1058             :     }
    1059             : 
    1060     3470727 :     if(IS_INTER(mb_type))
    1061     2103541 :         write_back_motion(h, sl, mb_type);
    1062             : 
    1063     3470727 :     if(!IS_INTRA16x16(mb_type)){
    1064     3262444 :         cbp= get_ue_golomb(&sl->gb);
    1065             : 
    1066     3262444 :         if(decode_chroma){
    1067     3223094 :             if(cbp > 47){
    1068           1 :                 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
    1069           1 :                 return -1;
    1070             :             }
    1071     3223093 :             if (IS_INTRA4x4(mb_type))
    1072     1134754 :                 cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
    1073             :             else
    1074     2088339 :                 cbp = ff_h264_golomb_to_inter_cbp[cbp];
    1075             :         }else{
    1076       39350 :             if(cbp > 15){
    1077           0 :                 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
    1078           0 :                 return -1;
    1079             :             }
    1080       39350 :             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
    1081       15201 :             else                     cbp= golomb_to_inter_cbp_gray[cbp];
    1082             :         }
    1083             :     } else {
    1084      208283 :         if (!decode_chroma && cbp>15) {
    1085           0 :             av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
    1086           0 :             return AVERROR_INVALIDDATA;
    1087             :         }
    1088             :     }
    1089             : 
    1090     3470726 :     if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
    1091      272479 :         mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
    1092             :     }
    1093     3470726 :     sl->cbp=
    1094     3470726 :     h->cbp_table[mb_xy]= cbp;
    1095     3470726 :     h->cur_pic.mb_type[mb_xy] = mb_type;
    1096             : 
    1097     6274632 :     if(cbp || IS_INTRA16x16(mb_type)){
    1098             :         int i4x4, i8x8, chroma_idx;
    1099             :         int dquant;
    1100             :         int ret;
    1101     2803906 :         GetBitContext *gb = &sl->gb;
    1102             :         const uint8_t *scan, *scan8x8;
    1103     2803906 :         const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
    1104             : 
    1105     2803906 :         dquant= get_se_golomb(&sl->gb);
    1106             : 
    1107     2803906 :         sl->qscale += (unsigned)dquant;
    1108             : 
    1109     2803906 :         if (((unsigned)sl->qscale) > max_qp){
    1110        8071 :             if (sl->qscale < 0) sl->qscale += max_qp + 1;
    1111        4210 :             else                sl->qscale -= max_qp+1;
    1112        8071 :             if (((unsigned)sl->qscale) > max_qp){
    1113           0 :                 av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
    1114           0 :                 return -1;
    1115             :             }
    1116             :         }
    1117             : 
    1118     2803906 :         sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
    1119     2803906 :         sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
    1120             : 
    1121     2803906 :         if(IS_INTERLACED(mb_type)){
    1122      824191 :             scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
    1123      824191 :             scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
    1124             :         }else{
    1125     1979715 :             scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
    1126     1979715 :             scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
    1127             :         }
    1128             : 
    1129     2803906 :         if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
    1130           0 :             return -1;
    1131             :         }
    1132     2803906 :         h->cbp_table[mb_xy] |= ret << 12;
    1133     2803906 :         if (CHROMA444(h)) {
    1134           0 :             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
    1135           0 :                 return -1;
    1136             :             }
    1137           0 :             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
    1138           0 :                 return -1;
    1139             :             }
    1140             :         } else {
    1141     2803906 :             const int num_c8x8 = h->ps.sps->chroma_format_idc;
    1142             : 
    1143     2803906 :             if(cbp&0x30){
    1144     4702035 :                 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
    1145     6269380 :                     if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
    1146             :                                         CHROMA_DC_BLOCK_INDEX + chroma_idx,
    1147     3134690 :                                         CHROMA422(h) ? ff_h264_chroma422_dc_scan : ff_h264_chroma_dc_scan,
    1148             :                                         NULL, 4 * num_c8x8) < 0) {
    1149           0 :                         return -1;
    1150             :                     }
    1151             :             }
    1152             : 
    1153     2803906 :             if(cbp&0x20){
    1154     3018924 :                 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
    1155     2012616 :                     const uint32_t *qmul = h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
    1156     2012616 :                     int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
    1157     4412376 :                     for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
    1158    11998800 :                         for (i4x4 = 0; i4x4 < 4; i4x4++) {
    1159     9599040 :                             const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
    1160     9599040 :                             if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
    1161           0 :                                 return -1;
    1162     9599040 :                             mb += 16 << pixel_shift;
    1163             :                         }
    1164             :                     }
    1165             :                 }
    1166             :             }else{
    1167     1797598 :                 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
    1168     1797598 :                 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
    1169             :             }
    1170             :         }
    1171             :     }else{
    1172      666820 :         fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
    1173      666820 :         fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
    1174      666820 :         fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
    1175             :     }
    1176     3470726 :     h->cur_pic.qscale_table[mb_xy] = sl->qscale;
    1177     3470726 :     write_back_non_zero_count(h, sl);
    1178             : 
    1179     3470726 :     return 0;
    1180             : }

Generated by: LCOV version 1.13