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 FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * H.264 / AVC / MPEG4 part10 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
1105 #define STORE_BLOCK(type) \
1106     do { \
1107         uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base; \
1108  \
1109         int j= scantable[index[--coeff_count]]; \
1110  \
1111         if( get_cabac( CC, ctx ) == 0 ) { \
1112             node_ctx = coeff_abs_level_transition[0][node_ctx]; \
1113             if( is_dc ) { \
1114                 ((type*)block)[j] = get_cabac_bypass_sign( CC, -1); \
1115             }else{ \
1116                 ((type*)block)[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; \
1117             } \
1118         } else { \
1119             int coeff_abs = 2; \
1120             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base; \
1121             node_ctx = coeff_abs_level_transition[1][node_ctx]; \
1122 \
1123             while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { \
1124                 coeff_abs++; \
1125             } \
1126 \
1127             if( coeff_abs >= 15 ) { \
1128                 int j = 0; \
1129                 while( get_cabac_bypass( CC ) ) { \
1130                     j++; \
1131                 } \
1132 \
1133                 coeff_abs=1; \
1134                 while( j-- ) { \
1135                     coeff_abs += coeff_abs + get_cabac_bypass( CC ); \
1136                 } \
1137                 coeff_abs+= 14; \
1138             } \
1139 \
1140             if( is_dc ) { \
1141                 ((type*)block)[j] = get_cabac_bypass_sign( CC, -coeff_abs ); \
1142             }else{ \
1143                 ((type*)block)[j] = ((int)(get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32)) >> 6; \
1144             } \
1145         } \
1146     } while ( coeff_count );
1147
1148         if (h->pixel_shift) {
1149             STORE_BLOCK(int32_t)
1150         } else {
1151             STORE_BLOCK(int16_t)
1152         }
1153 #ifdef CABAC_ON_STACK
1154             h->cabac.range     = cc.range     ;
1155             h->cabac.low       = cc.low       ;
1156             h->cabac.bytestream= cc.bytestream;
1157 #endif
1158
1159 }
1160
1161 static void decode_cabac_residual_dc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1162     decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1);
1163 }
1164
1165 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 ) {
1166     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1167 }
1168
1169 /* cat: 0-> DC 16x16  n = 0
1170  *      1-> AC 16x16  n = luma4x4idx
1171  *      2-> Luma4x4   n = luma4x4idx
1172  *      3-> DC Chroma n = iCbCr
1173  *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1174  *      5-> Luma8x8   n = 4 * luma8x8idx */
1175
1176 /* Partially inline the CABAC residual decode: inline the coded block flag.
1177  * This has very little impact on binary size and improves performance
1178  * because it allows improved constant propagation into get_cabac_cbf_ctx,
1179  * as well as because most blocks have zero CBFs. */
1180
1181 static av_always_inline void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1182     /* read coded block flag */
1183     if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 1 ) ] ) == 0 ) {
1184         h->non_zero_count_cache[scan8[n]] = 0;
1185         return;
1186     }
1187     decode_cabac_residual_dc_internal( h, block, cat, n, scantable, max_coeff );
1188 }
1189
1190 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 ) {
1191     /* read coded block flag */
1192     if( cat != 5 && get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 0 ) ] ) == 0 ) {
1193         h->non_zero_count_cache[scan8[n]] = 0;
1194         return;
1195     }
1196     decode_cabac_residual_nondc_internal( h, block, cat, n, scantable, qmul, max_coeff );
1197 }
1198
1199 /**
1200  * decodes a macroblock
1201  * @return 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1202  */
1203 int ff_h264_decode_mb_cabac(H264Context *h) {
1204     MpegEncContext * const s = &h->s;
1205     int mb_xy;
1206     int mb_type, partition_count, cbp = 0;
1207     int dct8x8_allowed= h->pps.transform_8x8_mode;
1208     const int pixel_shift = h->pixel_shift;
1209
1210     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1211
1212     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1213     if( h->slice_type_nos != AV_PICTURE_TYPE_I ) {
1214         int skip;
1215         /* a skipped mb needs the aff flag from the following mb */
1216         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1217             skip = h->next_mb_skipped;
1218         else
1219             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1220         /* read skip flags */
1221         if( skip ) {
1222             if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1223                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1224                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1225                 if(!h->next_mb_skipped)
1226                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1227             }
1228
1229             decode_mb_skip(h);
1230
1231             h->cbp_table[mb_xy] = 0;
1232             h->chroma_pred_mode_table[mb_xy] = 0;
1233             h->last_qscale_diff = 0;
1234
1235             return 0;
1236
1237         }
1238     }
1239     if(FRAME_MBAFF){
1240         if( (s->mb_y&1) == 0 )
1241             h->mb_mbaff =
1242             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1243     }
1244
1245     h->prev_mb_skipped = 0;
1246
1247     fill_decode_neighbors(h, -(MB_FIELD));
1248
1249     if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
1250         int ctx = 0;
1251         assert(h->slice_type_nos == AV_PICTURE_TYPE_B);
1252
1253         if( !IS_DIRECT( h->left_type[0]-1 ) )
1254             ctx++;
1255         if( !IS_DIRECT( h->top_type-1 ) )
1256             ctx++;
1257
1258         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1259             mb_type= 0; /* B_Direct_16x16 */
1260         }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1261             mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1262         }else{
1263             int bits;
1264             bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1265             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1266             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1267             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1268             if( bits < 8 ){
1269                 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1270             }else if( bits == 13 ){
1271                 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1272                 goto decode_intra_mb;
1273             }else if( bits == 14 ){
1274                 mb_type= 11; /* B_L1_L0_8x16 */
1275             }else if( bits == 15 ){
1276                 mb_type= 22; /* B_8x8 */
1277             }else{
1278                 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1279                 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1280             }
1281         }
1282             partition_count= b_mb_type_info[mb_type].partition_count;
1283             mb_type=         b_mb_type_info[mb_type].type;
1284     } else if( h->slice_type_nos == AV_PICTURE_TYPE_P ) {
1285         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1286             /* P-type */
1287             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1288                 /* P_L0_D16x16, P_8x8 */
1289                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1290             } else {
1291                 /* P_L0_D8x16, P_L0_D16x8 */
1292                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1293             }
1294             partition_count= p_mb_type_info[mb_type].partition_count;
1295             mb_type=         p_mb_type_info[mb_type].type;
1296         } else {
1297             mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1298             goto decode_intra_mb;
1299         }
1300     } else {
1301         mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1302         if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
1303             mb_type--;
1304         assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
1305 decode_intra_mb:
1306         partition_count = 0;
1307         cbp= i_mb_type_info[mb_type].cbp;
1308         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1309         mb_type= i_mb_type_info[mb_type].type;
1310     }
1311     if(MB_FIELD)
1312         mb_type |= MB_TYPE_INTERLACED;
1313
1314     h->slice_table[ mb_xy ]= h->slice_num;
1315
1316     if(IS_INTRA_PCM(mb_type)) {
1317         const int mb_size = (384*h->sps.bit_depth_luma) >> 3;
1318         const uint8_t *ptr;
1319
1320         // We assume these blocks are very rare so we do not optimize it.
1321         // FIXME The two following lines get the bitstream position in the cabac
1322         // decode, I think it should be done by a function in cabac.h (or cabac.c).
1323         ptr= h->cabac.bytestream;
1324         if(h->cabac.low&0x1) ptr--;
1325         if(CABAC_BITS==16){
1326             if(h->cabac.low&0x1FF) ptr--;
1327         }
1328
1329         // The pixels are stored in the same order as levels in h->mb array.
1330         memcpy(h->mb, ptr, 2*mb_size/3); ptr+=2*mb_size/3;
1331         if(CHROMA){
1332             memcpy(h->mb+mb_size/3, ptr, mb_size/3); ptr+=mb_size/3;
1333         }
1334
1335         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1336
1337         // All blocks are present
1338         h->cbp_table[mb_xy] = 0x1ef;
1339         h->chroma_pred_mode_table[mb_xy] = 0;
1340         // In deblocking, the quantizer is 0
1341         s->current_picture.qscale_table[mb_xy]= 0;
1342         // All coeffs are present
1343         memset(h->non_zero_count[mb_xy], 16, 32);
1344         s->current_picture.mb_type[mb_xy]= mb_type;
1345         h->last_qscale_diff = 0;
1346         return 0;
1347     }
1348
1349     if(MB_MBAFF){
1350         h->ref_count[0] <<= 1;
1351         h->ref_count[1] <<= 1;
1352     }
1353
1354     fill_decode_caches(h, mb_type);
1355
1356     if( IS_INTRA( mb_type ) ) {
1357         int i, pred_mode;
1358         if( IS_INTRA4x4( mb_type ) ) {
1359             if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1360                 mb_type |= MB_TYPE_8x8DCT;
1361                 for( i = 0; i < 16; i+=4 ) {
1362                     int pred = pred_intra_mode( h, i );
1363                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1364                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1365                 }
1366             } else {
1367                 for( i = 0; i < 16; i++ ) {
1368                     int pred = pred_intra_mode( h, i );
1369                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1370
1371                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1372                 }
1373             }
1374             ff_h264_write_back_intra_pred_mode(h);
1375             if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1376         } else {
1377             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1378             if( h->intra16x16_pred_mode < 0 ) return -1;
1379         }
1380         if(CHROMA){
1381             h->chroma_pred_mode_table[mb_xy] =
1382             pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1383
1384             pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1385             if( pred_mode < 0 ) return -1;
1386             h->chroma_pred_mode= pred_mode;
1387         } else {
1388             h->chroma_pred_mode= DC_128_PRED8x8;
1389         }
1390     } else if( partition_count == 4 ) {
1391         int i, j, sub_partition_count[4], list, ref[2][4];
1392
1393         if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
1394             for( i = 0; i < 4; i++ ) {
1395                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1396                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1397                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1398             }
1399             if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1400                           h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1401                 ff_h264_pred_direct_motion(h, &mb_type);
1402                 h->ref_cache[0][scan8[4]] =
1403                 h->ref_cache[1][scan8[4]] =
1404                 h->ref_cache[0][scan8[12]] =
1405                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1406                     for( i = 0; i < 4; i++ )
1407                         fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1408             }
1409         } else {
1410             for( i = 0; i < 4; i++ ) {
1411                 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1412                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1413                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1414             }
1415         }
1416
1417         for( list = 0; list < h->list_count; list++ ) {
1418                 for( i = 0; i < 4; i++ ) {
1419                     if(IS_DIRECT(h->sub_mb_type[i])) continue;
1420                     if(IS_DIR(h->sub_mb_type[i], 0, list)){
1421                         if( h->ref_count[list] > 1 ){
1422                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1423                             if(ref[list][i] >= (unsigned)h->ref_count[list]){
1424                                 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1425                                 return -1;
1426                             }
1427                         }else
1428                             ref[list][i] = 0;
1429                     } else {
1430                         ref[list][i] = -1;
1431                     }
1432                                                        h->ref_cache[list][ scan8[4*i]+1 ]=
1433                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1434                 }
1435         }
1436
1437         if(dct8x8_allowed)
1438             dct8x8_allowed = get_dct8x8_allowed(h);
1439
1440         for(list=0; list<h->list_count; list++){
1441             for(i=0; i<4; i++){
1442                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1443                 if(IS_DIRECT(h->sub_mb_type[i])){
1444                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
1445                     continue;
1446                 }
1447
1448                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1449                     const int sub_mb_type= h->sub_mb_type[i];
1450                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1451                     for(j=0; j<sub_partition_count[i]; j++){
1452                         int mpx, mpy;
1453                         int mx, my;
1454                         const int index= 4*i + block_width*j;
1455                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1456                         uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1457                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
1458                         DECODE_CABAC_MB_MVD( h, list, index)
1459                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1460
1461                         if(IS_SUB_8X8(sub_mb_type)){
1462                             mv_cache[ 1 ][0]=
1463                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1464                             mv_cache[ 1 ][1]=
1465                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1466
1467                             mvd_cache[ 1 ][0]=
1468                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
1469                             mvd_cache[ 1 ][1]=
1470                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
1471                         }else if(IS_SUB_8X4(sub_mb_type)){
1472                             mv_cache[ 1 ][0]= mx;
1473                             mv_cache[ 1 ][1]= my;
1474
1475                             mvd_cache[ 1 ][0]=  mpx;
1476                             mvd_cache[ 1 ][1]= mpy;
1477                         }else if(IS_SUB_4X8(sub_mb_type)){
1478                             mv_cache[ 8 ][0]= mx;
1479                             mv_cache[ 8 ][1]= my;
1480
1481                             mvd_cache[ 8 ][0]= mpx;
1482                             mvd_cache[ 8 ][1]= mpy;
1483                         }
1484                         mv_cache[ 0 ][0]= mx;
1485                         mv_cache[ 0 ][1]= my;
1486
1487                         mvd_cache[ 0 ][0]= mpx;
1488                         mvd_cache[ 0 ][1]= mpy;
1489                     }
1490                 }else{
1491                     fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
1492                     fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
1493                 }
1494             }
1495         }
1496     } else if( IS_DIRECT(mb_type) ) {
1497         ff_h264_pred_direct_motion(h, &mb_type);
1498         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
1499         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
1500         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1501     } else {
1502         int list, i;
1503         if(IS_16X16(mb_type)){
1504             for(list=0; list<h->list_count; list++){
1505                 if(IS_DIR(mb_type, 0, list)){
1506                     int ref;
1507                     if(h->ref_count[list] > 1){
1508                         ref= decode_cabac_mb_ref(h, list, 0);
1509                         if(ref >= (unsigned)h->ref_count[list]){
1510                             av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1511                             return -1;
1512                         }
1513                     }else
1514                         ref=0;
1515                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1516                 }
1517             }
1518             for(list=0; list<h->list_count; list++){
1519                 if(IS_DIR(mb_type, 0, list)){
1520                     int mx,my,mpx,mpy;
1521                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1522                     DECODE_CABAC_MB_MVD( h, list, 0)
1523                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1524
1525                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
1526                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1527                 }
1528             }
1529         }
1530         else if(IS_16X8(mb_type)){
1531             for(list=0; list<h->list_count; list++){
1532                     for(i=0; i<2; i++){
1533                         if(IS_DIR(mb_type, i, list)){
1534                             int ref;
1535                             if(h->ref_count[list] > 1){
1536                                 ref= decode_cabac_mb_ref( h, list, 8*i );
1537                                 if(ref >= (unsigned)h->ref_count[list]){
1538                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1539                                     return -1;
1540                                 }
1541                             }else
1542                                 ref=0;
1543                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1544                         }else
1545                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1546                     }
1547             }
1548             for(list=0; list<h->list_count; list++){
1549                 for(i=0; i<2; i++){
1550                     if(IS_DIR(mb_type, i, list)){
1551                         int mx,my,mpx,mpy;
1552                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1553                         DECODE_CABAC_MB_MVD( h, list, 8*i)
1554                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1555
1556                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
1557                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1558                     }else{
1559                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
1560                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1561                     }
1562                 }
1563             }
1564         }else{
1565             assert(IS_8X16(mb_type));
1566             for(list=0; list<h->list_count; list++){
1567                     for(i=0; i<2; i++){
1568                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1569                             int ref;
1570                             if(h->ref_count[list] > 1){
1571                                 ref= decode_cabac_mb_ref( h, list, 4*i );
1572                                 if(ref >= (unsigned)h->ref_count[list]){
1573                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1574                                     return -1;
1575                                 }
1576                             }else
1577                                 ref=0;
1578                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1579                         }else
1580                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1581                     }
1582             }
1583             for(list=0; list<h->list_count; list++){
1584                 for(i=0; i<2; i++){
1585                     if(IS_DIR(mb_type, i, list)){
1586                         int mx,my,mpx,mpy;
1587                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1588                         DECODE_CABAC_MB_MVD( h, list, 4*i)
1589
1590                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1591                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
1592                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1593                     }else{
1594                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
1595                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1596                     }
1597                 }
1598             }
1599         }
1600     }
1601
1602    if( IS_INTER( mb_type ) ) {
1603         h->chroma_pred_mode_table[mb_xy] = 0;
1604         write_back_motion( h, mb_type );
1605    }
1606
1607     if( !IS_INTRA16x16( mb_type ) ) {
1608         cbp  = decode_cabac_mb_cbp_luma( h );
1609         if(CHROMA)
1610             cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1611     }
1612
1613     h->cbp_table[mb_xy] = h->cbp = cbp;
1614
1615     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1616         mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1617     }
1618     s->current_picture.mb_type[mb_xy]= mb_type;
1619
1620     if( cbp || IS_INTRA16x16( mb_type ) ) {
1621         const uint8_t *scan, *scan8x8;
1622         const uint32_t *qmul;
1623
1624         if(IS_INTERLACED(mb_type)){
1625             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1626             scan= s->qscale ? h->field_scan : h->field_scan_q0;
1627         }else{
1628             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1629             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1630         }
1631
1632         // decode_cabac_mb_dqp
1633         if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1634             int val = 1;
1635             int ctx= 2;
1636             const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1637
1638             while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1639                 ctx= 3;
1640                 val++;
1641                 if(val > 2*max_qp){ //prevent infinite loop
1642                     av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1643                     return -1;
1644                 }
1645             }
1646
1647             if( val&0x01 )
1648                 val=   (val + 1)>>1 ;
1649             else
1650                 val= -((val + 1)>>1);
1651             h->last_qscale_diff = val;
1652             s->qscale += val;
1653             if(((unsigned)s->qscale) > max_qp){
1654                 if(s->qscale<0) s->qscale+= max_qp+1;
1655                 else            s->qscale-= max_qp+1;
1656             }
1657             h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1658             h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1659         }else
1660             h->last_qscale_diff=0;
1661
1662         if( IS_INTRA16x16( mb_type ) ) {
1663             int i;
1664             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1665             AV_ZERO128(h->mb_luma_dc+0);
1666             AV_ZERO128(h->mb_luma_dc+8);
1667             AV_ZERO128(h->mb_luma_dc+16);
1668             AV_ZERO128(h->mb_luma_dc+24);
1669             decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16);
1670
1671             if( cbp&15 ) {
1672                 qmul = h->dequant4_coeff[0][s->qscale];
1673                 for( i = 0; i < 16; i++ ) {
1674                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1675                     decode_cabac_residual_nondc(h, h->mb + (16*i << pixel_shift), 1, i, scan + 1, qmul, 15);
1676                 }
1677             } else {
1678                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1679             }
1680         } else {
1681             int i8x8, i4x4;
1682             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1683                 if( cbp & (1<<i8x8) ) {
1684                     if( IS_8x8DCT(mb_type) ) {
1685                         decode_cabac_residual_nondc(h, h->mb + (64*i8x8 << pixel_shift), 5, 4*i8x8,
1686                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1687                     } else {
1688                         qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1689                         for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1690                             const int index = 4*i8x8 + i4x4;
1691                             //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1692 //START_TIMER
1693                             decode_cabac_residual_nondc(h, h->mb + (16*index << pixel_shift), 2, index, scan, qmul, 16);
1694 //STOP_TIMER("decode_residual")
1695                         }
1696                     }
1697                 } else {
1698                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1699                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1700                 }
1701             }
1702         }
1703
1704         if( cbp&0x30 ){
1705             int c;
1706             for( c = 0; c < 2; c++ ) {
1707                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1708                 decode_cabac_residual_dc(h, h->mb + ((256 + 16*4*c) << pixel_shift), 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
1709             }
1710         }
1711
1712         if( cbp&0x20 ) {
1713             int c, i;
1714             for( c = 0; c < 2; c++ ) {
1715                 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1716                 for( i = 0; i < 4; i++ ) {
1717                     const int index = 16 + 4 * c + i;
1718                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1719                     decode_cabac_residual_nondc(h, h->mb + (16*index << pixel_shift), 4, index, scan + 1, qmul, 15);
1720                 }
1721             }
1722         } else {
1723             uint8_t * const nnz= &h->non_zero_count_cache[0];
1724             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1725             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1726         }
1727     } else {
1728         uint8_t * const nnz= &h->non_zero_count_cache[0];
1729         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1730         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1731         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1732         h->last_qscale_diff = 0;
1733     }
1734
1735     s->current_picture.qscale_table[mb_xy]= s->qscale;
1736     write_back_non_zero_count(h);
1737
1738     if(MB_MBAFF){
1739         h->ref_count[0] >>= 1;
1740         h->ref_count[1] >>= 1;
1741     }
1742
1743     return 0;
1744 }