git.sesse.net Git - ffmpeg/blob - libavcodec/h264_cabac.c

   1 /*
   2  * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding
   3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * H.264 / AVC / MPEG4 part10 cabac decoding.
  25  * @author Michael Niedermayer <michaelni@gmx.at>
  26  */
  27
  28 #define CABAC 1
  29
  30 #include "internal.h"
  31 #include "dsputil.h"
  32 #include "avcodec.h"
  33 #include "h264.h"
  34 #include "h264data.h"
  35 #include "h264_mvpred.h"
  36 #include "golomb.h"
  37
  38 #include "cabac.h"
  39 #if ARCH_X86
  40 #include "x86/h264_i386.h"
  41 #endif
  42
  43 //#undef NDEBUG
  44 #include <assert.h>
  45
  46 /* Cabac pre state table */
  47
  48 static const int8_t cabac_context_init_I[460][2] =
  49 {
  50     /* 0 - 10 */
  51     { 20, -15 }, {  2, 54 },  {  3,  74 }, { 20, -15 },
  52     {  2,  54 }, {  3, 74 },  { -28,127 }, { -23, 104 },
  53     { -6,  53 }, { -1, 54 },  {  7,  51 },
  54
  55     /* 11 - 23 unsused for I */
  56     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  57     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  58     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  59     { 0, 0 },
  60
  61     /* 24- 39 */
  62     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  63     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  64     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  65     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  66
  67     /* 40 - 53 */
  68     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  69     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  70     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  71     { 0, 0 },    { 0, 0 },
  72
  73     /* 54 - 59 */
  74     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  75     { 0, 0 },    { 0, 0 },
  76
  77     /* 60 - 69 */
  78     { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
  79     { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
  80     { 13, 41 },  { 3, 62 },
  81
  82     /* 70 -> 87 */
  83     { 0, 11 },   { 1, 55 },   { 0, 69 },     { -17, 127 },
  84     { -13, 102 },{ 0, 82 },   { -7, 74 },    { -21, 107 },
  85     { -27, 127 },{ -31, 127 },{ -24, 127 },  { -18, 95 },
  86     { -27, 127 },{ -21, 114 },{ -30, 127 },  { -17, 123 },
  87     { -12, 115 },{ -16, 122 },
  88
  89     /* 88 -> 104 */
  90     { -11, 115 },{ -12, 63 }, { -2, 68 },    { -15, 84 },
  91     { -13, 104 },{ -3, 70 },  { -8, 93 },    { -10, 90 },
  92     { -30, 127 },{ -1, 74 },  { -6, 97 },    { -7, 91 },
  93     { -20, 127 },{ -4, 56 },  { -5, 82 },    { -7, 76 },
  94     { -22, 125 },
  95
  96     /* 105 -> 135 */
  97     { -7, 93 },  { -11, 87 }, { -3, 77 },    { -5, 71 },
  98     { -4, 63 },  { -4, 68 },  { -12, 84 },   { -7, 62 },
  99     { -7, 65 },  { 8, 61 },   { 5, 56 },     { -2, 66 },
 100     { 1, 64 },   { 0, 61 },   { -2, 78 },    { 1, 50 },
 101     { 7, 52 },   { 10, 35 },  { 0, 44 },     { 11, 38 },
 102     { 1, 45 },   { 0, 46 },   { 5, 44 },     { 31, 17 },
 103     { 1, 51 },   { 7, 50 },   { 28, 19 },    { 16, 33 },
 104     { 14, 62 },  { -13, 108 },{ -15, 100 },
 105
 106     /* 136 -> 165 */
 107     { -13, 101 },{ -13, 91 }, { -12, 94 },   { -10, 88 },
 108     { -16, 84 }, { -10, 86 }, { -7, 83 },    { -13, 87 },
 109     { -19, 94 }, { 1, 70 },   { 0, 72 },     { -5, 74 },
 110     { 18, 59 },  { -8, 102 }, { -15, 100 },  { 0, 95 },
 111     { -4, 75 },  { 2, 72 },   { -11, 75 },   { -3, 71 },
 112     { 15, 46 },  { -13, 69 }, { 0, 62 },     { 0, 65 },
 113     { 21, 37 },  { -15, 72 }, { 9, 57 },     { 16, 54 },
 114     { 0, 62 },   { 12, 72 },
 115
 116     /* 166 -> 196 */
 117     { 24, 0 },   { 15, 9 },   { 8, 25 },     { 13, 18 },
 118     { 15, 9 },   { 13, 19 },  { 10, 37 },    { 12, 18 },
 119     { 6, 29 },   { 20, 33 },  { 15, 30 },    { 4, 45 },
 120     { 1, 58 },   { 0, 62 },   { 7, 61 },     { 12, 38 },
 121     { 11, 45 },  { 15, 39 },  { 11, 42 },    { 13, 44 },
 122     { 16, 45 },  { 12, 41 },  { 10, 49 },    { 30, 34 },
 123     { 18, 42 },  { 10, 55 },  { 17, 51 },    { 17, 46 },
 124     { 0, 89 },   { 26, -19 }, { 22, -17 },
 125
 126     /* 197 -> 226 */
 127     { 26, -17 }, { 30, -25 }, { 28, -20 },   { 33, -23 },
 128     { 37, -27 }, { 33, -23 }, { 40, -28 },   { 38, -17 },
 129     { 33, -11 }, { 40, -15 }, { 41, -6 },    { 38, 1 },
 130     { 41, 17 },  { 30, -6 },  { 27, 3 },     { 26, 22 },
 131     { 37, -16 }, { 35, -4 },  { 38, -8 },    { 38, -3 },
 132     { 37, 3 },   { 38, 5 },   { 42, 0 },     { 35, 16 },
 133     { 39, 22 },  { 14, 48 },  { 27, 37 },    { 21, 60 },
 134     { 12, 68 },  { 2, 97 },
 135
 136     /* 227 -> 251 */
 137     { -3, 71 },  { -6, 42 },  { -5, 50 },    { -3, 54 },
 138     { -2, 62 },  { 0, 58 },   { 1, 63 },     { -2, 72 },
 139     { -1, 74 },  { -9, 91 },  { -5, 67 },    { -5, 27 },
 140     { -3, 39 },  { -2, 44 },  { 0, 46 },     { -16, 64 },
 141     { -8, 68 },  { -10, 78 }, { -6, 77 },    { -10, 86 },
 142     { -12, 92 }, { -15, 55 }, { -10, 60 },   { -6, 62 },
 143     { -4, 65 },
 144
 145     /* 252 -> 275 */
 146     { -12, 73 }, { -8, 76 },  { -7, 80 },    { -9, 88 },
 147     { -17, 110 },{ -11, 97 }, { -20, 84 },   { -11, 79 },
 148     { -6, 73 },  { -4, 74 },  { -13, 86 },   { -13, 96 },
 149     { -11, 97 }, { -19, 117 },{ -8, 78 },    { -5, 33 },
 150     { -4, 48 },  { -2, 53 },  { -3, 62 },    { -13, 71 },
 151     { -10, 79 }, { -12, 86 }, { -13, 90 },   { -14, 97 },
 152
 153     /* 276 a bit special (not used, bypass is used instead) */
 154     { 0, 0 },
 155
 156     /* 277 -> 307 */
 157     { -6, 93 },  { -6, 84 },  { -8, 79 },    { 0, 66 },
 158     { -1, 71 },  { 0, 62 },   { -2, 60 },    { -2, 59 },
 159     { -5, 75 },  { -3, 62 },  { -4, 58 },    { -9, 66 },
 160     { -1, 79 },  { 0, 71 },   { 3, 68 },     { 10, 44 },
 161     { -7, 62 },  { 15, 36 },  { 14, 40 },    { 16, 27 },
 162     { 12, 29 },  { 1, 44 },   { 20, 36 },    { 18, 32 },
 163     { 5, 42 },   { 1, 48 },   { 10, 62 },    { 17, 46 },
 164     { 9, 64 },   { -12, 104 },{ -11, 97 },
 165
 166     /* 308 -> 337 */
 167     { -16, 96 }, { -7, 88 },  { -8, 85 },    { -7, 85 },
 168     { -9, 85 },  { -13, 88 }, { 4, 66 },     { -3, 77 },
 169     { -3, 76 },  { -6, 76 },  { 10, 58 },    { -1, 76 },
 170     { -1, 83 },  { -7, 99 },  { -14, 95 },   { 2, 95 },
 171     { 0, 76 },   { -5, 74 },  { 0, 70 },     { -11, 75 },
 172     { 1, 68 },   { 0, 65 },   { -14, 73 },   { 3, 62 },
 173     { 4, 62 },   { -1, 68 },  { -13, 75 },   { 11, 55 },
 174     { 5, 64 },   { 12, 70 },
 175
 176     /* 338 -> 368 */
 177     { 15, 6 },   { 6, 19 },   { 7, 16 },     { 12, 14 },
 178     { 18, 13 },  { 13, 11 },  { 13, 15 },    { 15, 16 },
 179     { 12, 23 },  { 13, 23 },  { 15, 20 },    { 14, 26 },
 180     { 14, 44 },  { 17, 40 },  { 17, 47 },    { 24, 17 },
 181     { 21, 21 },  { 25, 22 },  { 31, 27 },    { 22, 29 },
 182     { 19, 35 },  { 14, 50 },  { 10, 57 },    { 7, 63 },
 183     { -2, 77 },  { -4, 82 },  { -3, 94 },    { 9, 69 },
 184     { -12, 109 },{ 36, -35 }, { 36, -34 },
 185
 186     /* 369 -> 398 */
 187     { 32, -26 }, { 37, -30 }, { 44, -32 },   { 34, -18 },
 188     { 34, -15 }, { 40, -15 }, { 33, -7 },    { 35, -5 },
 189     { 33, 0 },   { 38, 2 },   { 33, 13 },    { 23, 35 },
 190     { 13, 58 },  { 29, -3 },  { 26, 0 },     { 22, 30 },
 191     { 31, -7 },  { 35, -15 }, { 34, -3 },    { 34, 3 },
 192     { 36, -1 },  { 34, 5 },   { 32, 11 },    { 35, 5 },
 193     { 34, 12 },  { 39, 11 },  { 30, 29 },    { 34, 26 },
 194     { 29, 39 },  { 19, 66 },
 195
 196     /* 399 -> 435 */
 197     {  31,  21 }, {  31,  31 }, {  25,  50 },
 198     { -17, 120 }, { -20, 112 }, { -18, 114 }, { -11,  85 },
 199     { -15,  92 }, { -14,  89 }, { -26,  71 }, { -15,  81 },
 200     { -14,  80 }, {   0,  68 }, { -14,  70 }, { -24,  56 },
 201     { -23,  68 }, { -24,  50 }, { -11,  74 }, {  23, -13 },
 202     {  26, -13 }, {  40, -15 }, {  49, -14 }, {  44,   3 },
 203     {  45,   6 }, {  44,  34 }, {  33,  54 }, {  19,  82 },
 204     {  -3,  75 }, {  -1,  23 }, {   1,  34 }, {   1,  43 },
 205     {   0,  54 }, {  -2,  55 }, {   0,  61 }, {   1,  64 },
 206     {   0,  68 }, {  -9,  92 },
 207
 208     /* 436 -> 459 */
 209     { -14, 106 }, { -13,  97 }, { -15,  90 }, { -12,  90 },
 210     { -18,  88 }, { -10,  73 }, {  -9,  79 }, { -14,  86 },
 211     { -10,  73 }, { -10,  70 }, { -10,  69 }, {  -5,  66 },
 212     {  -9,  64 }, {  -5,  58 }, {   2,  59 }, {  21, -10 },
 213     {  24, -11 }, {  28,  -8 }, {  28,  -1 }, {  29,   3 },
 214     {  29,   9 }, {  35,  20 }, {  29,  36 }, {  14,  67 }
 215 };
 216
 217 static const int8_t cabac_context_init_PB[3][460][2] =
 218 {
 219     /* i_cabac_init_idc == 0 */
 220     {
 221         /* 0 - 10 */
 222         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
 223         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
 224         {  -6,  53 }, {  -1,  54 }, {   7,  51 },
 225
 226         /* 11 - 23 */
 227         {  23,  33 }, {  23,   2 }, {  21,   0 }, {   1,   9 },
 228         {   0,  49 }, { -37, 118 }, {   5,  57 }, { -13,  78 },
 229         { -11,  65 }, {   1,  62 }, {  12,  49 }, {  -4,  73 },
 230         {  17,  50 },
 231
 232         /* 24 - 39 */
 233         {  18,  64 }, {   9,  43 }, {  29,   0 }, {  26,  67 },
 234         {  16,  90 }, {   9, 104 }, { -46, 127 }, { -20, 104 },
 235         {   1,  67 }, { -13,  78 }, { -11,  65 }, {   1,  62 },
 236         {  -6,  86 }, { -17,  95 }, {  -6,  61 }, {   9,  45 },
 237
 238         /* 40 - 53 */
 239         {  -3,  69 }, {  -6,  81 }, { -11,  96 }, {   6,  55 },
 240         {   7,  67 }, {  -5,  86 }, {   2,  88 }, {   0,  58 },
 241         {  -3,  76 }, { -10,  94 }, {   5,  54 }, {   4,  69 },
 242         {  -3,  81 }, {   0,  88 },
 243
 244         /* 54 - 59 */
 245         {  -7,  67 }, {  -5,  74 }, {  -4,  74 }, {  -5,  80 },
 246         {  -7,  72 }, {   1,  58 },
 247
 248         /* 60 - 69 */
 249         {   0,  41 }, {   0,  63 }, {   0,  63 }, { 0, 63 },
 250         {  -9,  83 }, {   4,  86 }, {   0,  97 }, { -7, 72 },
 251         {  13,  41 }, {   3,  62 },
 252
 253         /* 70 - 87 */
 254         {   0,  45 }, {  -4,  78 }, {  -3,  96 }, { -27,  126 },
 255         { -28,  98 }, { -25, 101 }, { -23,  67 }, { -28,  82 },
 256         { -20,  94 }, { -16,  83 }, { -22, 110 }, { -21,  91 },
 257         { -18, 102 }, { -13,  93 }, { -29, 127 }, {  -7,  92 },
 258         {  -5,  89 }, {  -7,  96 }, { -13, 108 }, {  -3,  46 },
 259         {  -1,  65 }, {  -1,  57 }, {  -9,  93 }, {  -3,  74 },
 260         {  -9,  92 }, {  -8,  87 }, { -23, 126 }, {   5,  54 },
 261         {   6,  60 }, {   6,  59 }, {   6,  69 }, {  -1,  48 },
 262         {   0,  68 }, {  -4,  69 }, {  -8,  88 },
 263
 264         /* 105 -> 165 */
 265         {  -2,  85 }, {  -6,  78 }, {  -1,  75 }, {  -7,  77 },
 266         {   2,  54 }, {   5,  50 }, {  -3,  68 }, {   1,  50 },
 267         {   6,  42 }, {  -4,  81 }, {   1,  63 }, {  -4,  70 },
 268         {   0,  67 }, {   2,  57 }, {  -2,  76 }, {  11,  35 },
 269         {   4,  64 }, {   1,  61 }, {  11,  35 }, {  18,  25 },
 270         {  12,  24 }, {  13,  29 }, {  13,  36 }, { -10,  93 },
 271         {  -7,  73 }, {  -2,  73 }, {  13,  46 }, {   9,  49 },
 272         {  -7, 100 }, {   9,  53 }, {   2,  53 }, {   5,  53 },
 273         {  -2,  61 }, {   0,  56 }, {   0,  56 }, { -13,  63 },
 274         {  -5,  60 }, {  -1,  62 }, {   4,  57 }, {  -6,  69 },
 275         {   4,  57 }, {  14,  39 }, {   4,  51 }, {  13,  68 },
 276         {   3,  64 }, {   1,  61 }, {   9,  63 }, {   7,  50 },
 277         {  16,  39 }, {   5,  44 }, {   4,  52 }, {  11,  48 },
 278         {  -5,  60 }, {  -1,  59 }, {   0,  59 }, {  22,  33 },
 279         {   5,  44 }, {  14,  43 }, {  -1,  78 }, {   0,  60 },
 280         {   9,  69 },
 281
 282         /* 166 - 226 */
 283         {  11,  28 }, {   2,  40 }, {   3,  44 }, {   0,  49 },
 284         {   0,  46 }, {   2,  44 }, {   2,  51 }, {   0,  47 },
 285         {   4,  39 }, {   2,  62 }, {   6,  46 }, {   0,  54 },
 286         {   3,  54 }, {   2,  58 }, {   4,  63 }, {   6,  51 },
 287         {   6,  57 }, {   7,  53 }, {   6,  52 }, {   6,  55 },
 288         {  11,  45 }, {  14,  36 }, {   8,  53 }, {  -1,  82 },
 289         {   7,  55 }, {  -3,  78 }, {  15,  46 }, {  22,  31 },
 290         {  -1,  84 }, {  25,   7 }, {  30,  -7 }, {  28,   3 },
 291         {  28,   4 }, {  32,   0 }, {  34,  -1 }, {  30,   6 },
 292         {  30,   6 }, {  32,   9 }, {  31,  19 }, {  26,  27 },
 293         {  26,  30 }, {  37,  20 }, {  28,  34 }, {  17,  70 },
 294         {   1,  67 }, {   5,  59 }, {   9,  67 }, {  16,  30 },
 295         {  18,  32 }, {  18,  35 }, {  22,  29 }, {  24,  31 },
 296         {  23,  38 }, {  18,  43 }, {  20,  41 }, {  11,  63 },
 297         {   9,  59 }, {   9,  64 }, {  -1,  94 }, {  -2,  89 },
 298         {  -9, 108 },
 299
 300         /* 227 - 275 */
 301         {  -6,  76 }, {  -2,  44 }, {   0,  45 }, {   0,  52 },
 302         {  -3,  64 }, {  -2,  59 }, {  -4,  70 }, {  -4,  75 },
 303         {  -8,  82 }, { -17, 102 }, {  -9,  77 }, {   3,  24 },
 304         {   0,  42 }, {   0,  48 }, {   0,  55 }, {  -6,  59 },
 305         {  -7,  71 }, { -12,  83 }, { -11,  87 }, { -30, 119 },
 306         {   1,  58 }, {  -3,  29 }, {  -1,  36 }, {   1,  38 },
 307         {   2,  43 }, {  -6,  55 }, {   0,  58 }, {   0,  64 },
 308         {  -3,  74 }, { -10,  90 }, {   0,  70 }, {  -4,  29 },
 309         {   5,  31 }, {   7,  42 }, {   1,  59 }, {  -2,  58 },
 310         {  -3,  72 }, {  -3,  81 }, { -11,  97 }, {   0,  58 },
 311         {   8,   5 }, {  10,  14 }, {  14,  18 }, {  13,  27 },
 312         {   2,  40 }, {   0,  58 }, {  -3,  70 }, {  -6,  79 },
 313         {  -8,  85 },
 314
 315         /* 276 a bit special (not used, bypass is used instead) */
 316         { 0, 0 },
 317
 318         /* 277 - 337 */
 319         { -13, 106 }, { -16, 106 }, { -10,  87 }, { -21, 114 },
 320         { -18, 110 }, { -14,  98 }, { -22, 110 }, { -21, 106 },
 321         { -18, 103 }, { -21, 107 }, { -23, 108 }, { -26, 112 },
 322         { -10,  96 }, { -12,  95 }, {  -5,  91 }, {  -9,  93 },
 323         { -22,  94 }, {  -5,  86 }, {   9,  67 }, {  -4,  80 },
 324         { -10,  85 }, {  -1,  70 }, {   7,  60 }, {   9,  58 },
 325         {   5,  61 }, {  12,  50 }, {  15,  50 }, {  18,  49 },
 326         {  17,  54 }, {  10,  41 }, {   7,  46 }, {  -1,  51 },
 327         {   7,  49 }, {   8,  52 }, {   9,  41 }, {   6,  47 },
 328         {   2,  55 }, {  13,  41 }, {  10,  44 }, {   6,  50 },
 329         {   5,  53 }, {  13,  49 }, {   4,  63 }, {   6,  64 },
 330         {  -2,  69 }, {  -2,  59 }, {   6,  70 }, {  10,  44 },
 331         {   9,  31 }, {  12,  43 }, {   3,  53 }, {  14,  34 },
 332         {  10,  38 }, {  -3,  52 }, {  13,  40 }, {  17,  32 },
 333         {   7,  44 }, {   7,  38 }, {  13,  50 }, {  10,  57 },
 334         {  26,  43 },
 335
 336         /* 338 - 398 */
 337         {  14,  11 }, {  11,  14 }, {   9,  11 }, {  18,  11 },
 338         {  21,   9 }, {  23,  -2 }, {  32, -15 }, {  32, -15 },
 339         {  34, -21 }, {  39, -23 }, {  42, -33 }, {  41, -31 },
 340         {  46, -28 }, {  38, -12 }, {  21,  29 }, {  45, -24 },
 341         {  53, -45 }, {  48, -26 }, {  65, -43 }, {  43, -19 },
 342         {  39, -10 }, {  30,   9 }, {  18,  26 }, {  20,  27 },
 343         {   0,  57 }, { -14,  82 }, {  -5,  75 }, { -19,  97 },
 344         { -35, 125 }, {  27,   0 }, {  28,   0 }, {  31,  -4 },
 345         {  27,   6 }, {  34,   8 }, {  30,  10 }, {  24,  22 },
 346         {  33,  19 }, {  22,  32 }, {  26,  31 }, {  21,  41 },
 347         {  26,  44 }, {  23,  47 }, {  16,  65 }, {  14,  71 },
 348         {   8,  60 }, {   6,  63 }, {  17,  65 }, {  21,  24 },
 349         {  23,  20 }, {  26,  23 }, {  27,  32 }, {  28,  23 },
 350         {  28,  24 }, {  23,  40 }, {  24,  32 }, {  28,  29 },
 351         {  23,  42 }, {  19,  57 }, {  22,  53 }, {  22,  61 },
 352         {  11,  86 },
 353
 354         /* 399 - 435 */
 355         {  12,  40 }, {  11,  51 }, {  14,  59 },
 356         {  -4,  79 }, {  -7,  71 }, {  -5,  69 }, {  -9,  70 },
 357         {  -8,  66 }, { -10,  68 }, { -19,  73 }, { -12,  69 },
 358         { -16,  70 }, { -15,  67 }, { -20,  62 }, { -19,  70 },
 359         { -16,  66 }, { -22,  65 }, { -20,  63 }, {   9,  -2 },
 360         {  26,  -9 }, {  33,  -9 }, {  39,  -7 }, {  41,  -2 },
 361         {  45,   3 }, {  49,   9 }, {  45,  27 }, {  36,  59 },
 362         {  -6,  66 }, {  -7,  35 }, {  -7,  42 }, {  -8,  45 },
 363         {  -5,  48 }, { -12,  56 }, {  -6,  60 }, {  -5,  62 },
 364         {  -8,  66 }, {  -8,  76 },
 365
 366         /* 436 - 459 */
 367         {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },
 368         { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },
 369         {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },
 370         { -14,  66 }, {   0,  59 }, {   2,  59 }, {  21, -13 },
 371         {  33, -14 }, {  39,  -7 }, {  46,  -2 }, {  51,   2 },
 372         {  60,   6 }, {  61,  17 }, {  55,  34 }, {  42,  62 },
 373     },
 374
 375     /* i_cabac_init_idc == 1 */
 376     {
 377         /* 0 - 10 */
 378         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
 379         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
 380         {  -6,  53 }, {  -1,  54 }, {   7,  51 },
 381
 382         /* 11 - 23 */
 383         {  22,  25 }, {  34,   0 }, {  16,   0 }, {  -2,   9 },
 384         {   4,  41 }, { -29, 118 }, {   2,  65 }, {  -6,  71 },
 385         { -13,  79 }, {   5,  52 }, {   9,  50 }, {  -3,  70 },
 386         {  10,  54 },
 387
 388         /* 24 - 39 */
 389         {  26,  34 }, {  19,  22 }, {  40,   0 }, {  57,   2 },
 390         {  41,  36 }, {  26,  69 }, { -45, 127 }, { -15, 101 },
 391         {  -4,  76 }, {  -6,  71 }, { -13,  79 }, {   5,  52 },
 392         {   6,  69 }, { -13,  90 }, {   0,  52 }, {   8,  43 },
 393
 394         /* 40 - 53 */
 395         {  -2,  69 },{  -5,  82 },{ -10,  96 },{   2,  59 },
 396         {   2,  75 },{  -3,  87 },{  -3,  100 },{   1,  56 },
 397         {  -3,  74 },{  -6,  85 },{   0,  59 },{  -3,  81 },
 398         {  -7,  86 },{  -5,  95 },
 399
 400         /* 54 - 59 */
 401         {  -1,  66 },{  -1,  77 },{   1,  70 },{  -2,  86 },
 402         {  -5,  72 },{   0,  61 },
 403
 404         /* 60 - 69 */
 405         { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
 406         { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
 407         { 13, 41 },  { 3, 62 },
 408
 409         /* 70 - 104 */
 410         {  13,  15 }, {   7,  51 }, {   2,  80 }, { -39, 127 },
 411         { -18,  91 }, { -17,  96 }, { -26,  81 }, { -35,  98 },
 412         { -24, 102 }, { -23,  97 }, { -27, 119 }, { -24,  99 },
 413         { -21, 110 }, { -18, 102 }, { -36, 127 }, {   0,  80 },
 414         {  -5,  89 }, {  -7,  94 }, {  -4,  92 }, {   0,  39 },
 415         {   0,  65 }, { -15,  84 }, { -35, 127 }, {  -2,  73 },
 416         { -12, 104 }, {  -9,  91 }, { -31, 127 }, {   3,  55 },
 417         {   7,  56 }, {   7,  55 }, {   8,  61 }, {  -3,  53 },
 418         {   0,  68 }, {  -7,  74 }, {  -9,  88 },
 419
 420         /* 105 -> 165 */
 421         { -13, 103 }, { -13,  91 }, {  -9,  89 }, { -14,  92 },
 422         {  -8,  76 }, { -12,  87 }, { -23, 110 }, { -24, 105 },
 423         { -10,  78 }, { -20, 112 }, { -17,  99 }, { -78, 127 },
 424         { -70, 127 }, { -50, 127 }, { -46, 127 }, {  -4,  66 },
 425         {  -5,  78 }, {  -4,  71 }, {  -8,  72 }, {   2,  59 },
 426         {  -1,  55 }, {  -7,  70 }, {  -6,  75 }, {  -8,  89 },
 427         { -34, 119 }, {  -3,  75 }, {  32,  20 }, {  30,  22 },
 428         { -44, 127 }, {   0,  54 }, {  -5,  61 }, {   0,  58 },
 429         {  -1,  60 }, {  -3,  61 }, {  -8,  67 }, { -25,  84 },
 430         { -14,  74 }, {  -5,  65 }, {   5,  52 }, {   2,  57 },
 431         {   0,  61 }, {  -9,  69 }, { -11,  70 }, {  18,  55 },
 432         {  -4,  71 }, {   0,  58 }, {   7,  61 }, {   9,  41 },
 433         {  18,  25 }, {   9,  32 }, {   5,  43 }, {   9,  47 },
 434         {   0,  44 }, {   0,  51 }, {   2,  46 }, {  19,  38 },
 435         {  -4,  66 }, {  15,  38 }, {  12,  42 }, {   9,  34 },
 436         {   0,  89 },
 437
 438         /* 166 - 226 */
 439         {   4,  45 }, {  10,  28 }, {  10,  31 }, {  33, -11 },
 440         {  52, -43 }, {  18,  15 }, {  28,   0 }, {  35, -22 },
 441         {  38, -25 }, {  34,   0 }, {  39, -18 }, {  32, -12 },
 442         { 102, -94 }, {   0,   0 }, {  56, -15 }, {  33,  -4 },
 443         {  29,  10 }, {  37,  -5 }, {  51, -29 }, {  39,  -9 },
 444         {  52, -34 }, {  69, -58 }, {  67, -63 }, {  44,  -5 },
 445         {  32,   7 }, {  55, -29 }, {  32,   1 }, {   0,   0 },
 446         {  27,  36 }, {  33, -25 }, {  34, -30 }, {  36, -28 },
 447         {  38, -28 }, {  38, -27 }, {  34, -18 }, {  35, -16 },
 448         {  34, -14 }, {  32,  -8 }, {  37,  -6 }, {  35,   0 },
 449         {  30,  10 }, {  28,  18 }, {  26,  25 }, {  29,  41 },
 450         {   0,  75 }, {   2,  72 }, {   8,  77 }, {  14,  35 },
 451         {  18,  31 }, {  17,  35 }, {  21,  30 }, {  17,  45 },
 452         {  20,  42 }, {  18,  45 }, {  27,  26 }, {  16,  54 },
 453         {   7,  66 }, {  16,  56 }, {  11,  73 }, {  10,  67 },
 454         { -10, 116 },
 455
 456         /* 227 - 275 */
 457         { -23, 112 }, { -15,  71 }, {  -7,  61 }, {   0,  53 },
 458         {  -5,  66 }, { -11,  77 }, {  -9,  80 }, {  -9,  84 },
 459         { -10,  87 }, { -34, 127 }, { -21, 101 }, {  -3,  39 },
 460         {  -5,  53 }, {  -7,  61 }, { -11,  75 }, { -15,  77 },
 461         { -17,  91 }, { -25, 107 }, { -25, 111 }, { -28, 122 },
 462         { -11,  76 }, { -10,  44 }, { -10,  52 }, { -10,  57 },
 463         {  -9,  58 }, { -16,  72 }, {  -7,  69 }, {  -4,  69 },
 464         {  -5,  74 }, {  -9,  86 }, {   2,  66 }, {  -9,  34 },
 465         {   1,  32 }, {  11,  31 }, {   5,  52 }, {  -2,  55 },
 466         {  -2,  67 }, {   0,  73 }, {  -8,  89 }, {   3,  52 },
 467         {   7,   4 }, {  10,   8 }, {  17,   8 }, {  16,  19 },
 468         {   3,  37 }, {  -1,  61 }, {  -5,  73 }, {  -1,  70 },
 469         {  -4,  78 },
 470
 471         /* 276 a bit special (not used, bypass is used instead) */
 472         { 0, 0 },
 473
 474         /* 277 - 337 */
 475         { -21, 126 }, { -23, 124 }, { -20, 110 }, { -26, 126 },
 476         { -25, 124 }, { -17, 105 }, { -27, 121 }, { -27, 117 },
 477         { -17, 102 }, { -26, 117 }, { -27, 116 }, { -33, 122 },
 478         { -10,  95 }, { -14, 100 }, {  -8,  95 }, { -17, 111 },
 479         { -28, 114 }, {  -6,  89 }, {  -2,  80 }, {  -4,  82 },
 480         {  -9,  85 }, {  -8,  81 }, {  -1,  72 }, {   5,  64 },
 481         {   1,  67 }, {   9,  56 }, {   0,  69 }, {   1,  69 },
 482         {   7,  69 }, {  -7,  69 }, {  -6,  67 }, { -16,  77 },
 483         {  -2,  64 }, {   2,  61 }, {  -6,  67 }, {  -3,  64 },
 484         {   2,  57 }, {  -3,  65 }, {  -3,  66 }, {   0,  62 },
 485         {   9,  51 }, {  -1,  66 }, {  -2,  71 }, {  -2,  75 },
 486         {  -1,  70 }, {  -9,  72 }, {  14,  60 }, {  16,  37 },
 487         {   0,  47 }, {  18,  35 }, {  11,  37 }, {  12,  41 },
 488         {  10,  41 }, {   2,  48 }, {  12,  41 }, {  13,  41 },
 489         {   0,  59 }, {   3,  50 }, {  19,  40 }, {   3,  66 },
 490         {  18,  50 },
 491
 492         /* 338 - 398 */
 493         {  19,  -6 }, {  18,  -6 }, {  14,   0 }, {  26, -12 },
 494         {  31, -16 }, {  33, -25 }, {  33, -22 }, {  37, -28 },
 495         {  39, -30 }, {  42, -30 }, {  47, -42 }, {  45, -36 },
 496         {  49, -34 }, {  41, -17 }, {  32,   9 }, {  69, -71 },
 497         {  63, -63 }, {  66, -64 }, {  77, -74 }, {  54, -39 },
 498         {  52, -35 }, {  41, -10 }, {  36,   0 }, {  40,  -1 },
 499         {  30,  14 }, {  28,  26 }, {  23,  37 }, {  12,  55 },
 500         {  11,  65 }, {  37, -33 }, {  39, -36 }, {  40, -37 },
 501         {  38, -30 }, {  46, -33 }, {  42, -30 }, {  40, -24 },
 502         {  49, -29 }, {  38, -12 }, {  40, -10 }, {  38,  -3 },
 503         {  46,  -5 }, {  31,  20 }, {  29,  30 }, {  25,  44 },
 504         {  12,  48 }, {  11,  49 }, {  26,  45 }, {  22,  22 },
 505         {  23,  22 }, {  27,  21 }, {  33,  20 }, {  26,  28 },
 506         {  30,  24 }, {  27,  34 }, {  18,  42 }, {  25,  39 },
 507         {  18,  50 }, {  12,  70 }, {  21,  54 }, {  14,  71 },
 508         {  11,  83 },
 509
 510         /* 399 - 435 */
 511         {  25,  32 }, {  21,  49 }, {  21,  54 },
 512         {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },
 513         { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },
 514         {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },
 515         { -14,  66 }, {   0,  59 }, {   2,  59 }, {  17, -10 },
 516         {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },
 517         {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },
 518         {  -5,  71 }, {   0,  24 }, {  -1,  36 }, {  -2,  42 },
 519         {  -2,  52 }, {  -9,  57 }, {  -6,  63 }, {  -4,  65 },
 520         {  -4,  67 }, {  -7,  82 },
 521
 522         /* 436 - 459 */
 523         {  -3,  81 }, {  -3,  76 }, {  -7,  72 }, {  -6,  78 },
 524         { -12,  72 }, { -14,  68 }, {  -3,  70 }, {  -6,  76 },
 525         {  -5,  66 }, {  -5,  62 }, {   0,  57 }, {  -4,  61 },
 526         {  -9,  60 }, {   1,  54 }, {   2,  58 }, {  17, -10 },
 527         {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },
 528         {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },
 529     },
 530
 531     /* i_cabac_init_idc == 2 */
 532     {
 533         /* 0 - 10 */
 534         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
 535         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
 536         {  -6,  53 }, {  -1,  54 }, {   7,  51 },
 537
 538         /* 11 - 23 */
 539         {  29,  16 }, {  25,   0 }, {  14,   0 }, { -10,  51 },
 540         {  -3,  62 }, { -27,  99 }, {  26,  16 }, {  -4,  85 },
 541         { -24, 102 }, {   5,  57 }, {   6,  57 }, { -17,  73 },
 542         {  14,  57 },
 543
 544         /* 24 - 39 */
 545         {  20,  40 }, {  20,  10 }, {  29,   0 }, {  54,   0 },
 546         {  37,  42 }, {  12,  97 }, { -32, 127 }, { -22, 117 },
 547         {  -2,  74 }, {  -4,  85 }, { -24, 102 }, {   5,  57 },
 548         {  -6,  93 }, { -14,  88 }, {  -6,  44 }, {   4,  55 },
 549
 550         /* 40 - 53 */
 551         { -11,  89 },{ -15,  103 },{ -21,  116 },{  19,  57 },
 552         {  20,  58 },{   4,  84 },{   6,  96 },{   1,  63 },
 553         {  -5,  85 },{ -13,  106 },{   5,  63 },{   6,  75 },
 554         {  -3,  90 },{  -1,  101 },
 555
 556         /* 54 - 59 */
 557         {   3,  55 },{  -4,  79 },{  -2,  75 },{ -12,  97 },
 558         {  -7,  50 },{   1,  60 },
 559
 560         /* 60 - 69 */
 561         { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
 562         { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
 563         { 13, 41 },  { 3, 62 },
 564
 565         /* 70 - 104 */
 566         {   7,  34 }, {  -9,  88 }, { -20, 127 }, { -36, 127 },
 567         { -17,  91 }, { -14,  95 }, { -25,  84 }, { -25,  86 },
 568         { -12,  89 }, { -17,  91 }, { -31, 127 }, { -14,  76 },
 569         { -18, 103 }, { -13,  90 }, { -37, 127 }, {  11,  80 },
 570         {   5,  76 }, {   2,  84 }, {   5,  78 }, {  -6,  55 },
 571         {   4,  61 }, { -14,  83 }, { -37, 127 }, {  -5,  79 },
 572         { -11, 104 }, { -11,  91 }, { -30, 127 }, {   0,  65 },
 573         {  -2,  79 }, {   0,  72 }, {  -4,  92 }, {  -6,  56 },
 574         {   3,  68 }, {  -8,  71 }, { -13,  98 },
 575
 576         /* 105 -> 165 */
 577         {  -4,  86 }, { -12,  88 }, {  -5,  82 }, {  -3,  72 },
 578         {  -4,  67 }, {  -8,  72 }, { -16,  89 }, {  -9,  69 },
 579         {  -1,  59 }, {   5,  66 }, {   4,  57 }, {  -4,  71 },
 580         {  -2,  71 }, {   2,  58 }, {  -1,  74 }, {  -4,  44 },
 581         {  -1,  69 }, {   0,  62 }, {  -7,  51 }, {  -4,  47 },
 582         {  -6,  42 }, {  -3,  41 }, {  -6,  53 }, {   8,  76 },
 583         {  -9,  78 }, { -11,  83 }, {   9,  52 }, {   0,  67 },
 584         {  -5,  90 }, {   1,  67 }, { -15,  72 }, {  -5,  75 },
 585         {  -8,  80 }, { -21,  83 }, { -21,  64 }, { -13,  31 },
 586         { -25,  64 }, { -29,  94 }, {   9,  75 }, {  17,  63 },
 587         {  -8,  74 }, {  -5,  35 }, {  -2,  27 }, {  13,  91 },
 588         {   3,  65 }, {  -7,  69 }, {   8,  77 }, { -10,  66 },
 589         {   3,  62 }, {  -3,  68 }, { -20,  81 }, {   0,  30 },
 590         {   1,   7 }, {  -3,  23 }, { -21,  74 }, {  16,  66 },
 591         { -23, 124 }, {  17,  37 }, {  44, -18 }, {  50, -34 },
 592         { -22, 127 },
 593
 594         /* 166 - 226 */
 595         {   4,  39 }, {   0,  42 }, {   7,  34 }, {  11,  29 },
 596         {   8,  31 }, {   6,  37 }, {   7,  42 }, {   3,  40 },
 597         {   8,  33 }, {  13,  43 }, {  13,  36 }, {   4,  47 },
 598         {   3,  55 }, {   2,  58 }, {   6,  60 }, {   8,  44 },
 599         {  11,  44 }, {  14,  42 }, {   7,  48 }, {   4,  56 },
 600         {   4,  52 }, {  13,  37 }, {   9,  49 }, {  19,  58 },
 601         {  10,  48 }, {  12,  45 }, {   0,  69 }, {  20,  33 },
 602         {   8,  63 }, {  35, -18 }, {  33, -25 }, {  28,  -3 },
 603         {  24,  10 }, {  27,   0 }, {  34, -14 }, {  52, -44 },
 604         {  39, -24 }, {  19,  17 }, {  31,  25 }, {  36,  29 },
 605         {  24,  33 }, {  34,  15 }, {  30,  20 }, {  22,  73 },
 606         {  20,  34 }, {  19,  31 }, {  27,  44 }, {  19,  16 },
 607         {  15,  36 }, {  15,  36 }, {  21,  28 }, {  25,  21 },
 608         {  30,  20 }, {  31,  12 }, {  27,  16 }, {  24,  42 },
 609         {   0,  93 }, {  14,  56 }, {  15,  57 }, {  26,  38 },
 610         { -24, 127 },
 611
 612         /* 227 - 275 */
 613         { -24, 115 }, { -22,  82 }, {  -9,  62 }, {   0,  53 },
 614         {   0,  59 }, { -14,  85 }, { -13,  89 }, { -13,  94 },
 615         { -11,  92 }, { -29, 127 }, { -21, 100 }, { -14,  57 },
 616         { -12,  67 }, { -11,  71 }, { -10,  77 }, { -21,  85 },
 617         { -16,  88 }, { -23, 104 }, { -15,  98 }, { -37, 127 },
 618         { -10,  82 }, {  -8,  48 }, {  -8,  61 }, {  -8,  66 },
 619         {  -7,  70 }, { -14,  75 }, { -10,  79 }, {  -9,  83 },
 620         { -12,  92 }, { -18, 108 }, {  -4,  79 }, { -22,  69 },
 621         { -16,  75 }, {  -2,  58 }, {   1,  58 }, { -13,  78 },
 622         {  -9,  83 }, {  -4,  81 }, { -13,  99 }, { -13,  81 },
 623         {  -6,  38 }, { -13,  62 }, {  -6,  58 }, {  -2,  59 },
 624         { -16,  73 }, { -10,  76 }, { -13,  86 }, {  -9,  83 },
 625         { -10,  87 },
 626
 627         /* 276 a bit special (not used, bypass is used instead) */
 628         { 0, 0 },
 629
 630         /* 277 - 337 */
 631         { -22, 127 }, { -25, 127 }, { -25, 120 }, { -27, 127 },
 632         { -19, 114 }, { -23, 117 }, { -25, 118 }, { -26, 117 },
 633         { -24, 113 }, { -28, 118 }, { -31, 120 }, { -37, 124 },
 634         { -10,  94 }, { -15, 102 }, { -10,  99 }, { -13, 106 },
 635         { -50, 127 }, {  -5,  92 }, {  17,  57 }, {  -5,  86 },
 636         { -13,  94 }, { -12,  91 }, {  -2,  77 }, {   0,  71 },
 637         {  -1,  73 }, {   4,  64 }, {  -7,  81 }, {   5,  64 },
 638         {  15,  57 }, {   1,  67 }, {   0,  68 }, { -10,  67 },
 639         {   1,  68 }, {   0,  77 }, {   2,  64 }, {   0,  68 },
 640         {  -5,  78 }, {   7,  55 }, {   5,  59 }, {   2,  65 },
 641         {  14,  54 }, {  15,  44 }, {   5,  60 }, {   2,  70 },
 642         {  -2,  76 }, { -18,  86 }, {  12,  70 }, {   5,  64 },
 643         { -12,  70 }, {  11,  55 }, {   5,  56 }, {   0,  69 },
 644         {   2,  65 }, {  -6,  74 }, {   5,  54 }, {   7,  54 },
 645         {  -6,  76 }, { -11,  82 }, {  -2,  77 }, {  -2,  77 },
 646         {  25,  42 },
 647
 648         /* 338 - 398 */
 649         {  17, -13 }, {  16,  -9 }, {  17, -12 }, {  27, -21 },
 650         {  37, -30 }, {  41, -40 }, {  42, -41 }, {  48, -47 },
 651         {  39, -32 }, {  46, -40 }, {  52, -51 }, {  46, -41 },
 652         {  52, -39 }, {  43, -19 }, {  32,  11 }, {  61, -55 },
 653         {  56, -46 }, {  62, -50 }, {  81, -67 }, {  45, -20 },
 654         {  35,  -2 }, {  28,  15 }, {  34,   1 }, {  39,   1 },
 655         {  30,  17 }, {  20,  38 }, {  18,  45 }, {  15,  54 },
 656         {   0,  79 }, {  36, -16 }, {  37, -14 }, {  37, -17 },
 657         {  32,   1 }, {  34,  15 }, {  29,  15 }, {  24,  25 },
 658         {  34,  22 }, {  31,  16 }, {  35,  18 }, {  31,  28 },
 659         {  33,  41 }, {  36,  28 }, {  27,  47 }, {  21,  62 },
 660         {  18,  31 }, {  19,  26 }, {  36,  24 }, {  24,  23 },
 661         {  27,  16 }, {  24,  30 }, {  31,  29 }, {  22,  41 },
 662         {  22,  42 }, {  16,  60 }, {  15,  52 }, {  14,  60 },
 663         {   3,  78 }, { -16, 123 }, {  21,  53 }, {  22,  56 },
 664         {  25,  61 },
 665
 666         /* 399 - 435 */
 667         {  21,  33 }, {  19,  50 }, {  17,  61 },
 668         {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },
 669         { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },
 670         { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },
 671         { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },
 672         {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },
 673         {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },
 674         {  -9,  71 }, {  -7,  37 }, {  -8,  44 }, { -11,  49 },
 675         { -10,  56 }, { -12,  59 }, {  -8,  63 }, {  -9,  67 },
 676         {  -6,  68 }, { -10,  79 },
 677
 678         /* 436 - 459 */
 679         {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },
 680         { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },
 681         { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },
 682         { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },
 683         {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },
 684         {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },
 685     }
 686 };
 687
 688 void ff_h264_init_cabac_states(H264Context *h) {
 689     MpegEncContext * const s = &h->s;
 690     int i;
 691     const int8_t (*tab)[2];
 692     const int slice_qp = av_clip(s->qscale - 6*(h->sps.bit_depth_luma-8), 0, 51);
 693
 694     if( h->slice_type_nos == AV_PICTURE_TYPE_I ) tab = cabac_context_init_I;
 695     else                                 tab = cabac_context_init_PB[h->cabac_init_idc];
 696
 697     /* calculate pre-state */
 698     for( i= 0; i < 460; i++ ) {
 699         int pre = 2*(((tab[i][0] * slice_qp) >>4 ) + tab[i][1]) - 127;
 700
 701         pre^= pre>>31;
 702         if(pre > 124)
 703             pre= 124 + (pre&1);
 704
 705         h->cabac_state[i] =  pre;
 706     }
 707 }
 708
 709 static int decode_cabac_field_decoding_flag(H264Context *h) {
 710     MpegEncContext * const s = &h->s;
 711     const long mbb_xy = h->mb_xy - 2L*s->mb_stride;
 712
 713     unsigned long ctx = 0;
 714
 715     ctx += h->mb_field_decoding_flag & !!s->mb_x; //for FMO:(s->current_picture.mb_type[mba_xy]>>7)&(h->slice_table[mba_xy] == h->slice_num);
 716     ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num);
 717
 718     return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
 719 }
 720
 721 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
 722     uint8_t *state= &h->cabac_state[ctx_base];
 723     int mb_type;
 724
 725     if(intra_slice){
 726         int ctx=0;
 727         if( h->left_type[0] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
 728             ctx++;
 729         if( h->top_type     & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
 730             ctx++;
 731         if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
 732             return 0;   /* I4x4 */
 733         state += 2;
 734     }else{
 735         if( get_cabac_noinline( &h->cabac, state ) == 0 )
 736             return 0;   /* I4x4 */
 737     }
 738
 739     if( get_cabac_terminate( &h->cabac ) )
 740         return 25;  /* PCM */
 741
 742     mb_type = 1; /* I16x16 */
 743     mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
 744     if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
 745         mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
 746     mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
 747     mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
 748     return mb_type;
 749 }
 750
 751 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
 752     MpegEncContext * const s = &h->s;
 753     int mba_xy, mbb_xy;
 754     int ctx = 0;
 755
 756     if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
 757         int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
 758         mba_xy = mb_xy - 1;
 759         if( (mb_y&1)
 760             && h->slice_table[mba_xy] == h->slice_num
 761             && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
 762             mba_xy += s->mb_stride;
 763         if( MB_FIELD ){
 764             mbb_xy = mb_xy - s->mb_stride;
 765             if( !(mb_y&1)
 766                 && h->slice_table[mbb_xy] == h->slice_num
 767                 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
 768                 mbb_xy -= s->mb_stride;
 769         }else
 770             mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
 771     }else{
 772         int mb_xy = h->mb_xy;
 773         mba_xy = mb_xy - 1;
 774         mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
 775     }
 776
 777     if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
 778         ctx++;
 779     if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
 780         ctx++;
 781
 782     if( h->slice_type_nos == AV_PICTURE_TYPE_B )
 783         ctx += 13;
 784     return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
 785 }
 786
 787 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
 788     int mode = 0;
 789
 790     if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
 791         return pred_mode;
 792
 793     mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
 794     mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
 795     mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
 796
 797     return mode + ( mode >= pred_mode );
 798 }
 799
 800 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
 801     const int mba_xy = h->left_mb_xy[0];
 802     const int mbb_xy = h->top_mb_xy;
 803
 804     int ctx = 0;
 805
 806     /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
 807     if( h->left_type[0] && h->chroma_pred_mode_table[mba_xy] != 0 )
 808         ctx++;
 809
 810     if( h->top_type     && h->chroma_pred_mode_table[mbb_xy] != 0 )
 811         ctx++;
 812
 813     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
 814         return 0;
 815
 816     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
 817         return 1;
 818     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
 819         return 2;
 820     else
 821         return 3;
 822 }
 823
 824 static int decode_cabac_mb_cbp_luma( H264Context *h) {
 825     int cbp_b, cbp_a, ctx, cbp = 0;
 826
 827     cbp_a = h->left_cbp;
 828     cbp_b = h->top_cbp;
 829
 830     ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
 831     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
 832     ctx = !(cbp   & 0x01) + 2 * !(cbp_b & 0x08);
 833     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
 834     ctx = !(cbp_a & 0x08) + 2 * !(cbp   & 0x01);
 835     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
 836     ctx = !(cbp   & 0x04) + 2 * !(cbp   & 0x02);
 837     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
 838     return cbp;
 839 }
 840 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
 841     int ctx;
 842     int cbp_a, cbp_b;
 843
 844     cbp_a = (h->left_cbp>>4)&0x03;
 845     cbp_b = (h-> top_cbp>>4)&0x03;
 846
 847     ctx = 0;
 848     if( cbp_a > 0 ) ctx++;
 849     if( cbp_b > 0 ) ctx += 2;
 850     if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
 851         return 0;
 852
 853     ctx = 4;
 854     if( cbp_a == 2 ) ctx++;
 855     if( cbp_b == 2 ) ctx += 2;
 856     return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
 857 }
 858
 859 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
 860     if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
 861         return 0;   /* 8x8 */
 862     if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
 863         return 1;   /* 8x4 */
 864     if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
 865         return 2;   /* 4x8 */
 866     return 3;       /* 4x4 */
 867 }
 868 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
 869     int type;
 870     if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
 871         return 0;   /* B_Direct_8x8 */
 872     if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
 873         return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
 874     type = 3;
 875     if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
 876         if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
 877             return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
 878         type += 4;
 879     }
 880     type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
 881     type +=   get_cabac( &h->cabac, &h->cabac_state[39] );
 882     return type;
 883 }
 884
 885 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
 886     int refa = h->ref_cache[list][scan8[n] - 1];
 887     int refb = h->ref_cache[list][scan8[n] - 8];
 888     int ref  = 0;
 889     int ctx  = 0;
 890
 891     if( h->slice_type_nos == AV_PICTURE_TYPE_B) {
 892         if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
 893             ctx++;
 894         if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
 895             ctx += 2;
 896     } else {
 897         if( refa > 0 )
 898             ctx++;
 899         if( refb > 0 )
 900             ctx += 2;
 901     }
 902
 903     while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
 904         ref++;
 905         ctx = (ctx>>2)+4;
 906         if(ref >= 32 /*h->ref_list[list]*/){
 907             return -1;
 908         }
 909     }
 910     return ref;
 911 }
 912
 913 static int decode_cabac_mb_mvd( H264Context *h, int ctxbase, int amvd, int *mvda) {
 914     int mvd;
 915
 916     if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+((amvd-3)>>(INT_BIT-1))+((amvd-33)>>(INT_BIT-1))+2])){
 917 //    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){
 918         *mvda= 0;
 919         return 0;
 920     }
 921
 922     mvd= 1;
 923     ctxbase+= 3;
 924     while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) {
 925         if( mvd < 4 )
 926             ctxbase++;
 927         mvd++;
 928     }
 929
 930     if( mvd >= 9 ) {
 931         int k = 3;
 932         while( get_cabac_bypass( &h->cabac ) ) {
 933             mvd += 1 << k;
 934             k++;
 935             if(k>24){
 936                 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
 937                 return INT_MIN;
 938             }
 939         }
 940         while( k-- ) {
 941             mvd += get_cabac_bypass( &h->cabac )<<k;
 942         }
 943         *mvda=mvd < 70 ? mvd : 70;
 944     }else
 945         *mvda=mvd;
 946     return get_cabac_bypass_sign( &h->cabac, -mvd );
 947 }
 948
 949 #define DECODE_CABAC_MB_MVD( h,  list,  n )\
 950 {\
 951     int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\
 952                 h->mvd_cache[list][scan8[n] - 8][0];\
 953     int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\
 954                 h->mvd_cache[list][scan8[n] - 8][1];\
 955 \
 956     mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\
 957     my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\
 958 }
 959
 960 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
 961     int nza, nzb;
 962     int ctx = 0;
 963
 964     if( is_dc ) {
 965         if( cat == 0 ) {
 966             nza = h->left_cbp&0x100;
 967             nzb = h-> top_cbp&0x100;
 968         } else {
 969             idx -= CHROMA_DC_BLOCK_INDEX;
 970             nza = (h->left_cbp>>(6+idx))&0x01;
 971             nzb = (h-> top_cbp>>(6+idx))&0x01;
 972         }
 973     } else {
 974         assert(cat == 1 || cat == 2 || cat == 4);
 975         nza = h->non_zero_count_cache[scan8[idx] - 1];
 976         nzb = h->non_zero_count_cache[scan8[idx] - 8];
 977     }
 978
 979     if( nza > 0 )
 980         ctx++;
 981
 982     if( nzb > 0 )
 983         ctx += 2;
 984
 985     return ctx + 4 * cat;
 986 }
 987
 988 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
 989     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 990     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 991     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
 992     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
 993 };
 994
 995 static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {
 996     static const int significant_coeff_flag_offset[2][6] = {
 997       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
 998       { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
 999     };
1000     static const int last_coeff_flag_offset[2][6] = {
1001       { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1002       { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1003     };
1004     static const int coeff_abs_level_m1_offset[6] = {
1005         227+0, 227+10, 227+20, 227+30, 227+39, 426
1006     };
1007     static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1008       { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1009         4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1010         7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1011        12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1012       { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1013         6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1014         9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1015         9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1016     };
1017     /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1018      * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1019      * map node ctx => cabac ctx for level=1 */
1020     static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1021     /* map node ctx => cabac ctx for level>1 */
1022     static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1023     static const uint8_t coeff_abs_level_transition[2][8] = {
1024     /* update node ctx after decoding a level=1 */
1025         { 1, 2, 3, 3, 4, 5, 6, 7 },
1026     /* update node ctx after decoding a level>1 */
1027         { 4, 4, 4, 4, 5, 6, 7, 7 }
1028     };
1029
1030     int index[64];
1031
1032     int av_unused last;
1033     int coeff_count = 0;
1034     int node_ctx = 0;
1035
1036     uint8_t *significant_coeff_ctx_base;
1037     uint8_t *last_coeff_ctx_base;
1038     uint8_t *abs_level_m1_ctx_base;
1039
1040 #if !ARCH_X86
1041 #define CABAC_ON_STACK
1042 #endif
1043 #ifdef CABAC_ON_STACK
1044 #define CC &cc
1045     CABACContext cc;
1046     cc.range     = h->cabac.range;
1047     cc.low       = h->cabac.low;
1048     cc.bytestream= h->cabac.bytestream;
1049 #else
1050 #define CC &h->cabac
1051 #endif
1052
1053     significant_coeff_ctx_base = h->cabac_state
1054         + significant_coeff_flag_offset[MB_FIELD][cat];
1055     last_coeff_ctx_base = h->cabac_state
1056         + last_coeff_flag_offset[MB_FIELD][cat];
1057     abs_level_m1_ctx_base = h->cabac_state
1058         + coeff_abs_level_m1_offset[cat];
1059
1060     if( !is_dc && cat == 5 ) {
1061 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1062         for(last= 0; last < coefs; last++) { \
1063             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1064             if( get_cabac( CC, sig_ctx )) { \
1065                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1066                 index[coeff_count++] = last; \
1067                 if( get_cabac( CC, last_ctx ) ) { \
1068                     last= max_coeff; \
1069                     break; \
1070                 } \
1071             } \
1072         }\
1073         if( last == max_coeff -1 ) {\
1074             index[coeff_count++] = last;\
1075         }
1076         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1077 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1078         coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1079     } else {
1080         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1081 #else
1082         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1083     } else {
1084         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1085 #endif
1086     }
1087     assert(coeff_count > 0);
1088
1089     if( is_dc ) {
1090         if( cat == 0 )
1091             h->cbp_table[h->mb_xy] |= 0x100;
1092         else
1093             h->cbp_table[h->mb_xy] |= 0x40 << (n - CHROMA_DC_BLOCK_INDEX);
1094         h->non_zero_count_cache[scan8[n]] = coeff_count;
1095     } else {
1096         if( cat == 5 )
1097             fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1098         else {
1099             assert( cat == 1 || cat == 2 || cat == 4 );
1100             h->non_zero_count_cache[scan8[n]] = coeff_count;
1101         }
1102     }
1103
1104 #define STORE_BLOCK(type) \
1105     do { \
1106         uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base; \
1107  \
1108         int j= scantable[index[--coeff_count]]; \
1109  \
1110         if( get_cabac( CC, ctx ) == 0 ) { \
1111             node_ctx = coeff_abs_level_transition[0][node_ctx]; \
1112             if( is_dc ) { \
1113                 ((type*)block)[j] = get_cabac_bypass_sign( CC, -1); \
1114             }else{ \
1115                 ((type*)block)[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; \
1116             } \
1117         } else { \
1118             int coeff_abs = 2; \
1119             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base; \
1120             node_ctx = coeff_abs_level_transition[1][node_ctx]; \
1121 \
1122             while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { \
1123                 coeff_abs++; \
1124             } \
1125 \
1126             if( coeff_abs >= 15 ) { \
1127                 int j = 0; \
1128                 while( get_cabac_bypass( CC ) ) { \
1129                     j++; \
1130                 } \
1131 \
1132                 coeff_abs=1; \
1133                 while( j-- ) { \
1134                     coeff_abs += coeff_abs + get_cabac_bypass( CC ); \
1135                 } \
1136                 coeff_abs+= 14; \
1137             } \
1138 \
1139             if( is_dc ) { \
1140                 ((type*)block)[j] = get_cabac_bypass_sign( CC, -coeff_abs ); \
1141             }else{ \
1142                 ((type*)block)[j] = ((int)(get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32)) >> 6; \
1143             } \
1144         } \
1145     } while ( coeff_count );
1146
1147     if (h->pixel_shift) {
1148         STORE_BLOCK(int32_t)
1149     } else {
1150         STORE_BLOCK(int16_t)
1151     }
1152 #ifdef CABAC_ON_STACK
1153             h->cabac.range     = cc.range     ;
1154             h->cabac.low       = cc.low       ;
1155             h->cabac.bytestream= cc.bytestream;
1156 #endif
1157
1158 }
1159
1160 static void decode_cabac_residual_dc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1161     decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1);
1162 }
1163
1164 static void decode_cabac_residual_nondc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1165     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1166 }
1167
1168 /* cat: 0-> DC 16x16  n = 0
1169  *      1-> AC 16x16  n = luma4x4idx
1170  *      2-> Luma4x4   n = luma4x4idx
1171  *      3-> DC Chroma n = iCbCr
1172  *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1173  *      5-> Luma8x8   n = 4 * luma8x8idx */
1174
1175 /* Partially inline the CABAC residual decode: inline the coded block flag.
1176  * This has very little impact on binary size and improves performance
1177  * because it allows improved constant propagation into get_cabac_cbf_ctx,
1178  * as well as because most blocks have zero CBFs. */
1179
1180 static av_always_inline void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1181     /* read coded block flag */
1182     if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 1 ) ] ) == 0 ) {
1183         h->non_zero_count_cache[scan8[n]] = 0;
1184         return;
1185     }
1186     decode_cabac_residual_dc_internal( h, block, cat, n, scantable, max_coeff );
1187 }
1188
1189 static av_always_inline void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1190     /* read coded block flag */
1191     if( cat != 5 && get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 0 ) ] ) == 0 ) {
1192         h->non_zero_count_cache[scan8[n]] = 0;
1193         return;
1194     }
1195     decode_cabac_residual_nondc_internal( h, block, cat, n, scantable, qmul, max_coeff );
1196 }
1197
1198 /**
1199  * decodes a macroblock
1200  * @return 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1201  */
1202 int ff_h264_decode_mb_cabac(H264Context *h) {
1203     MpegEncContext * const s = &h->s;
1204     int mb_xy;
1205     int mb_type, partition_count, cbp = 0;
1206     int dct8x8_allowed= h->pps.transform_8x8_mode;
1207     const int pixel_shift = h->pixel_shift;
1208
1209     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1210
1211     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1212     if( h->slice_type_nos != AV_PICTURE_TYPE_I ) {
1213         int skip;
1214         /* a skipped mb needs the aff flag from the following mb */
1215         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1216             skip = h->next_mb_skipped;
1217         else
1218             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1219         /* read skip flags */
1220         if( skip ) {
1221             if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1222                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1223                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1224                 if(!h->next_mb_skipped)
1225                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1226             }
1227
1228             decode_mb_skip(h);
1229
1230             h->cbp_table[mb_xy] = 0;
1231             h->chroma_pred_mode_table[mb_xy] = 0;
1232             h->last_qscale_diff = 0;
1233
1234             return 0;
1235
1236         }
1237     }
1238     if(FRAME_MBAFF){
1239         if( (s->mb_y&1) == 0 )
1240             h->mb_mbaff =
1241             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1242     }
1243
1244     h->prev_mb_skipped = 0;
1245
1246     fill_decode_neighbors(h, -(MB_FIELD));
1247
1248     if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
1249         int ctx = 0;
1250         assert(h->slice_type_nos == AV_PICTURE_TYPE_B);
1251
1252         if( !IS_DIRECT( h->left_type[0]-1 ) )
1253             ctx++;
1254         if( !IS_DIRECT( h->top_type-1 ) )
1255             ctx++;
1256
1257         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1258             mb_type= 0; /* B_Direct_16x16 */
1259         }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1260             mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1261         }else{
1262             int bits;
1263             bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1264             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1265             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1266             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1267             if( bits < 8 ){
1268                 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1269             }else if( bits == 13 ){
1270                 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1271                 goto decode_intra_mb;
1272             }else if( bits == 14 ){
1273                 mb_type= 11; /* B_L1_L0_8x16 */
1274             }else if( bits == 15 ){
1275                 mb_type= 22; /* B_8x8 */
1276             }else{
1277                 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1278                 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1279             }
1280         }
1281             partition_count= b_mb_type_info[mb_type].partition_count;
1282             mb_type=         b_mb_type_info[mb_type].type;
1283     } else if( h->slice_type_nos == AV_PICTURE_TYPE_P ) {
1284         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1285             /* P-type */
1286             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1287                 /* P_L0_D16x16, P_8x8 */
1288                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1289             } else {
1290                 /* P_L0_D8x16, P_L0_D16x8 */
1291                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1292             }
1293             partition_count= p_mb_type_info[mb_type].partition_count;
1294             mb_type=         p_mb_type_info[mb_type].type;
1295         } else {
1296             mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1297             goto decode_intra_mb;
1298         }
1299     } else {
1300         mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1301         if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
1302             mb_type--;
1303         assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
1304 decode_intra_mb:
1305         partition_count = 0;
1306         cbp= i_mb_type_info[mb_type].cbp;
1307         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1308         mb_type= i_mb_type_info[mb_type].type;
1309     }
1310     if(MB_FIELD)
1311         mb_type |= MB_TYPE_INTERLACED;
1312
1313     h->slice_table[ mb_xy ]= h->slice_num;
1314
1315     if(IS_INTRA_PCM(mb_type)) {
1316         const int mb_size = (384*h->sps.bit_depth_luma) >> 3;
1317         const uint8_t *ptr;
1318
1319         // We assume these blocks are very rare so we do not optimize it.
1320         // FIXME The two following lines get the bitstream position in the cabac
1321         // decode, I think it should be done by a function in cabac.h (or cabac.c).
1322         ptr= h->cabac.bytestream;
1323         if(h->cabac.low&0x1) ptr--;
1324         if(CABAC_BITS==16){
1325             if(h->cabac.low&0x1FF) ptr--;
1326         }
1327
1328         // The pixels are stored in the same order as levels in h->mb array.
1329         memcpy(h->mb, ptr, 2*mb_size/3); ptr+=2*mb_size/3;
1330         if(CHROMA){
1331             memcpy(h->mb+mb_size/3, ptr, mb_size/3); ptr+=mb_size/3;
1332         }
1333
1334         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1335
1336         // All blocks are present
1337         h->cbp_table[mb_xy] = 0x1ef;
1338         h->chroma_pred_mode_table[mb_xy] = 0;
1339         // In deblocking, the quantizer is 0
1340         s->current_picture.qscale_table[mb_xy]= 0;
1341         // All coeffs are present
1342         memset(h->non_zero_count[mb_xy], 16, 32);
1343         s->current_picture.mb_type[mb_xy]= mb_type;
1344         h->last_qscale_diff = 0;
1345         return 0;
1346     }
1347
1348     if(MB_MBAFF){
1349         h->ref_count[0] <<= 1;
1350         h->ref_count[1] <<= 1;
1351     }
1352
1353     fill_decode_caches(h, mb_type);
1354
1355     if( IS_INTRA( mb_type ) ) {
1356         int i, pred_mode;
1357         if( IS_INTRA4x4( mb_type ) ) {
1358             if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1359                 mb_type |= MB_TYPE_8x8DCT;
1360                 for( i = 0; i < 16; i+=4 ) {
1361                     int pred = pred_intra_mode( h, i );
1362                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1363                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1364                 }
1365             } else {
1366                 for( i = 0; i < 16; i++ ) {
1367                     int pred = pred_intra_mode( h, i );
1368                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1369
1370                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1371                 }
1372             }
1373             ff_h264_write_back_intra_pred_mode(h);
1374             if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1375         } else {
1376             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1377             if( h->intra16x16_pred_mode < 0 ) return -1;
1378         }
1379         if(CHROMA){
1380             h->chroma_pred_mode_table[mb_xy] =
1381             pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1382
1383             pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1384             if( pred_mode < 0 ) return -1;
1385             h->chroma_pred_mode= pred_mode;
1386         } else {
1387             h->chroma_pred_mode= DC_128_PRED8x8;
1388         }
1389     } else if( partition_count == 4 ) {
1390         int i, j, sub_partition_count[4], list, ref[2][4];
1391
1392         if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
1393             for( i = 0; i < 4; i++ ) {
1394                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1395                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1396                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1397             }
1398             if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1399                           h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1400                 ff_h264_pred_direct_motion(h, &mb_type);
1401                 h->ref_cache[0][scan8[4]] =
1402                 h->ref_cache[1][scan8[4]] =
1403                 h->ref_cache[0][scan8[12]] =
1404                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1405                     for( i = 0; i < 4; i++ )
1406                         fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1407             }
1408         } else {
1409             for( i = 0; i < 4; i++ ) {
1410                 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1411                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1412                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1413             }
1414         }
1415
1416         for( list = 0; list < h->list_count; list++ ) {
1417                 for( i = 0; i < 4; i++ ) {
1418                     if(IS_DIRECT(h->sub_mb_type[i])) continue;
1419                     if(IS_DIR(h->sub_mb_type[i], 0, list)){
1420                         if( h->ref_count[list] > 1 ){
1421                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1422                             if(ref[list][i] >= (unsigned)h->ref_count[list]){
1423                                 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1424                                 return -1;
1425                             }
1426                         }else
1427                             ref[list][i] = 0;
1428                     } else {
1429                         ref[list][i] = -1;
1430                     }
1431                                                        h->ref_cache[list][ scan8[4*i]+1 ]=
1432                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1433                 }
1434         }
1435
1436         if(dct8x8_allowed)
1437             dct8x8_allowed = get_dct8x8_allowed(h);
1438
1439         for(list=0; list<h->list_count; list++){
1440             for(i=0; i<4; i++){
1441                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1442                 if(IS_DIRECT(h->sub_mb_type[i])){
1443                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
1444                     continue;
1445                 }
1446
1447                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1448                     const int sub_mb_type= h->sub_mb_type[i];
1449                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1450                     for(j=0; j<sub_partition_count[i]; j++){
1451                         int mpx, mpy;
1452                         int mx, my;
1453                         const int index= 4*i + block_width*j;
1454                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1455                         uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1456                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
1457                         DECODE_CABAC_MB_MVD( h, list, index)
1458                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1459
1460                         if(IS_SUB_8X8(sub_mb_type)){
1461                             mv_cache[ 1 ][0]=
1462                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1463                             mv_cache[ 1 ][1]=
1464                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1465
1466                             mvd_cache[ 1 ][0]=
1467                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
1468                             mvd_cache[ 1 ][1]=
1469                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
1470                         }else if(IS_SUB_8X4(sub_mb_type)){
1471                             mv_cache[ 1 ][0]= mx;
1472                             mv_cache[ 1 ][1]= my;
1473
1474                             mvd_cache[ 1 ][0]=  mpx;
1475                             mvd_cache[ 1 ][1]= mpy;
1476                         }else if(IS_SUB_4X8(sub_mb_type)){
1477                             mv_cache[ 8 ][0]= mx;
1478                             mv_cache[ 8 ][1]= my;
1479
1480                             mvd_cache[ 8 ][0]= mpx;
1481                             mvd_cache[ 8 ][1]= mpy;
1482                         }
1483                         mv_cache[ 0 ][0]= mx;
1484                         mv_cache[ 0 ][1]= my;
1485
1486                         mvd_cache[ 0 ][0]= mpx;
1487                         mvd_cache[ 0 ][1]= mpy;
1488                     }
1489                 }else{
1490                     fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
1491                     fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
1492                 }
1493             }
1494         }
1495     } else if( IS_DIRECT(mb_type) ) {
1496         ff_h264_pred_direct_motion(h, &mb_type);
1497         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
1498         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
1499         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1500     } else {
1501         int list, i;
1502         if(IS_16X16(mb_type)){
1503             for(list=0; list<h->list_count; list++){
1504                 if(IS_DIR(mb_type, 0, list)){
1505                     int ref;
1506                     if(h->ref_count[list] > 1){
1507                         ref= decode_cabac_mb_ref(h, list, 0);
1508                         if(ref >= (unsigned)h->ref_count[list]){
1509                             av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1510                             return -1;
1511                         }
1512                     }else
1513                         ref=0;
1514                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1515                 }
1516             }
1517             for(list=0; list<h->list_count; list++){
1518                 if(IS_DIR(mb_type, 0, list)){
1519                     int mx,my,mpx,mpy;
1520                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1521                     DECODE_CABAC_MB_MVD( h, list, 0)
1522                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1523
1524                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
1525                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1526                 }
1527             }
1528         }
1529         else if(IS_16X8(mb_type)){
1530             for(list=0; list<h->list_count; list++){
1531                     for(i=0; i<2; i++){
1532                         if(IS_DIR(mb_type, i, list)){
1533                             int ref;
1534                             if(h->ref_count[list] > 1){
1535                                 ref= decode_cabac_mb_ref( h, list, 8*i );
1536                                 if(ref >= (unsigned)h->ref_count[list]){
1537                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1538                                     return -1;
1539                                 }
1540                             }else
1541                                 ref=0;
1542                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1543                         }else
1544                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1545                     }
1546             }
1547             for(list=0; list<h->list_count; list++){
1548                 for(i=0; i<2; i++){
1549                     if(IS_DIR(mb_type, i, list)){
1550                         int mx,my,mpx,mpy;
1551                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1552                         DECODE_CABAC_MB_MVD( h, list, 8*i)
1553                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1554
1555                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
1556                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1557                     }else{
1558                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
1559                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1560                     }
1561                 }
1562             }
1563         }else{
1564             assert(IS_8X16(mb_type));
1565             for(list=0; list<h->list_count; list++){
1566                     for(i=0; i<2; i++){
1567                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1568                             int ref;
1569                             if(h->ref_count[list] > 1){
1570                                 ref= decode_cabac_mb_ref( h, list, 4*i );
1571                                 if(ref >= (unsigned)h->ref_count[list]){
1572                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1573                                     return -1;
1574                                 }
1575                             }else
1576                                 ref=0;
1577                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1578                         }else
1579                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1580                     }
1581             }
1582             for(list=0; list<h->list_count; list++){
1583                 for(i=0; i<2; i++){
1584                     if(IS_DIR(mb_type, i, list)){
1585                         int mx,my,mpx,mpy;
1586                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1587                         DECODE_CABAC_MB_MVD( h, list, 4*i)
1588
1589                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1590                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
1591                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1592                     }else{
1593                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
1594                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1595                     }
1596                 }
1597             }
1598         }
1599     }
1600
1601    if( IS_INTER( mb_type ) ) {
1602         h->chroma_pred_mode_table[mb_xy] = 0;
1603         write_back_motion( h, mb_type );
1604    }
1605
1606     if( !IS_INTRA16x16( mb_type ) ) {
1607         cbp  = decode_cabac_mb_cbp_luma( h );
1608         if(CHROMA)
1609             cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1610     }
1611
1612     h->cbp_table[mb_xy] = h->cbp = cbp;
1613
1614     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1615         mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1616     }
1617     s->current_picture.mb_type[mb_xy]= mb_type;
1618
1619     if( cbp || IS_INTRA16x16( mb_type ) ) {
1620         const uint8_t *scan, *scan8x8;
1621         const uint32_t *qmul;
1622
1623         if(IS_INTERLACED(mb_type)){
1624             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1625             scan= s->qscale ? h->field_scan : h->field_scan_q0;
1626         }else{
1627             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1628             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1629         }
1630
1631         // decode_cabac_mb_dqp
1632         if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1633             int val = 1;
1634             int ctx= 2;
1635             const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1636
1637             while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1638                 ctx= 3;
1639                 val++;
1640                 if(val > 2*max_qp){ //prevent infinite loop
1641                     av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1642                     return -1;
1643                 }
1644             }
1645
1646             if( val&0x01 )
1647                 val=   (val + 1)>>1 ;
1648             else
1649                 val= -((val + 1)>>1);
1650             h->last_qscale_diff = val;
1651             s->qscale += val;
1652             if(((unsigned)s->qscale) > max_qp){
1653                 if(s->qscale<0) s->qscale+= max_qp+1;
1654                 else            s->qscale-= max_qp+1;
1655             }
1656             h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1657             h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1658         }else
1659             h->last_qscale_diff=0;
1660
1661         if( IS_INTRA16x16( mb_type ) ) {
1662             int i;
1663             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1664             AV_ZERO128(h->mb_luma_dc+0);
1665             AV_ZERO128(h->mb_luma_dc+8);
1666             AV_ZERO128(h->mb_luma_dc+16);
1667             AV_ZERO128(h->mb_luma_dc+24);
1668             decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16);
1669
1670             if( cbp&15 ) {
1671                 qmul = h->dequant4_coeff[0][s->qscale];
1672                 for( i = 0; i < 16; i++ ) {
1673                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1674                     decode_cabac_residual_nondc(h, h->mb + (16*i << pixel_shift), 1, i, scan + 1, qmul, 15);
1675                 }
1676             } else {
1677                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1678             }
1679         } else {
1680             int i8x8, i4x4;
1681             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1682                 if( cbp & (1<<i8x8) ) {
1683                     if( IS_8x8DCT(mb_type) ) {
1684                         decode_cabac_residual_nondc(h, h->mb + (64*i8x8 << pixel_shift), 5, 4*i8x8,
1685                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1686                     } else {
1687                         qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1688                         for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1689                             const int index = 4*i8x8 + i4x4;
1690                             //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1691 //START_TIMER
1692                             decode_cabac_residual_nondc(h, h->mb + (16*index << pixel_shift), 2, index, scan, qmul, 16);
1693 //STOP_TIMER("decode_residual")
1694                         }
1695                     }
1696                 } else {
1697                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1698                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1699                 }
1700             }
1701         }
1702
1703         if( cbp&0x30 ){
1704             int c;
1705             for( c = 0; c < 2; c++ ) {
1706                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1707                 decode_cabac_residual_dc(h, h->mb + ((256 + 16*4*c) << pixel_shift), 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
1708             }
1709         }
1710
1711         if( cbp&0x20 ) {
1712             int c, i;
1713             for( c = 0; c < 2; c++ ) {
1714                 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1715                 for( i = 0; i < 4; i++ ) {
1716                     const int index = 16 + 4 * c + i;
1717                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1718                     decode_cabac_residual_nondc(h, h->mb + (16*index << pixel_shift), 4, index, scan + 1, qmul, 15);
1719                 }
1720             }
1721         } else {
1722             uint8_t * const nnz= &h->non_zero_count_cache[0];
1723             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1724             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1725         }
1726     } else {
1727         uint8_t * const nnz= &h->non_zero_count_cache[0];
1728         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1729         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1730         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1731         h->last_qscale_diff = 0;
1732     }
1733
1734     s->current_picture.qscale_table[mb_xy]= s->qscale;
1735     write_back_non_zero_count(h);
1736
1737     if(MB_MBAFF){
1738         h->ref_count[0] >>= 1;
1739         h->ref_count[1] >>= 1;
1740     }
1741
1742     return 0;
1743 }