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         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
1208     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1209
1210     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1211     if( h->slice_type_nos != AV_PICTURE_TYPE_I ) {
1212         int skip;
1213         /* a skipped mb needs the aff flag from the following mb */
1214         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1215             skip = h->next_mb_skipped;
1216         else
1217             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1218         /* read skip flags */
1219         if( skip ) {
1220             if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1221                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1222                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1223                 if(!h->next_mb_skipped)
1224                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1225             }
1226
1227             decode_mb_skip(h);
1228
1229             h->cbp_table[mb_xy] = 0;
1230             h->chroma_pred_mode_table[mb_xy] = 0;
1231             h->last_qscale_diff = 0;
1232
1233             return 0;
1234
1235         }
1236     }
1237     if(FRAME_MBAFF){
1238         if( (s->mb_y&1) == 0 )
1239             h->mb_mbaff =
1240             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1241     }
1242
1243     h->prev_mb_skipped = 0;
1244
1245     fill_decode_neighbors(h, -(MB_FIELD));
1246
1247     if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
1248         int ctx = 0;
1249         assert(h->slice_type_nos == AV_PICTURE_TYPE_B);
1250
1251         if( !IS_DIRECT( h->left_type[0]-1 ) )
1252             ctx++;
1253         if( !IS_DIRECT( h->top_type-1 ) )
1254             ctx++;
1255
1256         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1257             mb_type= 0; /* B_Direct_16x16 */
1258         }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1259             mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1260         }else{
1261             int bits;
1262             bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1263             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1264             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1265             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1266             if( bits < 8 ){
1267                 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1268             }else if( bits == 13 ){
1269                 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1270                 goto decode_intra_mb;
1271             }else if( bits == 14 ){
1272                 mb_type= 11; /* B_L1_L0_8x16 */
1273             }else if( bits == 15 ){
1274                 mb_type= 22; /* B_8x8 */
1275             }else{
1276                 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1277                 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1278             }
1279         }
1280             partition_count= b_mb_type_info[mb_type].partition_count;
1281             mb_type=         b_mb_type_info[mb_type].type;
1282     } else if( h->slice_type_nos == AV_PICTURE_TYPE_P ) {
1283         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1284             /* P-type */
1285             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1286                 /* P_L0_D16x16, P_8x8 */
1287                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1288             } else {
1289                 /* P_L0_D8x16, P_L0_D16x8 */
1290                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1291             }
1292             partition_count= p_mb_type_info[mb_type].partition_count;
1293             mb_type=         p_mb_type_info[mb_type].type;
1294         } else {
1295             mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1296             goto decode_intra_mb;
1297         }
1298     } else {
1299         mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1300         if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
1301             mb_type--;
1302         assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
1303 decode_intra_mb:
1304         partition_count = 0;
1305         cbp= i_mb_type_info[mb_type].cbp;
1306         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1307         mb_type= i_mb_type_info[mb_type].type;
1308     }
1309     if(MB_FIELD)
1310         mb_type |= MB_TYPE_INTERLACED;
1311
1312     h->slice_table[ mb_xy ]= h->slice_num;
1313
1314     if(IS_INTRA_PCM(mb_type)) {
1315         const int mb_size = 384*h->sps.bit_depth_luma/8;
1316         const uint8_t *ptr;
1317
1318         // We assume these blocks are very rare so we do not optimize it.
1319         // FIXME The two following lines get the bitstream position in the cabac
1320         // decode, I think it should be done by a function in cabac.h (or cabac.c).
1321         ptr= h->cabac.bytestream;
1322         if(h->cabac.low&0x1) ptr--;
1323         if(CABAC_BITS==16){
1324             if(h->cabac.low&0x1FF) ptr--;
1325         }
1326
1327         // The pixels are stored in the same order as levels in h->mb array.
1328         memcpy(h->mb, ptr, 2*mb_size/3); ptr+=2*mb_size/3;
1329         if(CHROMA){
1330             memcpy(h->mb+mb_size/3, ptr, mb_size/3); ptr+=mb_size/3;
1331         }
1332
1333         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1334
1335         // All blocks are present
1336         h->cbp_table[mb_xy] = 0x1ef;
1337         h->chroma_pred_mode_table[mb_xy] = 0;
1338         // In deblocking, the quantizer is 0
1339         s->current_picture.qscale_table[mb_xy]= 0;
1340         // All coeffs are present
1341         memset(h->non_zero_count[mb_xy], 16, 32);
1342         s->current_picture.mb_type[mb_xy]= mb_type;
1343         h->last_qscale_diff = 0;
1344         return 0;
1345     }
1346
1347     if(MB_MBAFF){
1348         h->ref_count[0] <<= 1;
1349         h->ref_count[1] <<= 1;
1350     }
1351
1352     fill_decode_caches(h, mb_type);
1353
1354     if( IS_INTRA( mb_type ) ) {
1355         int i, pred_mode;
1356         if( IS_INTRA4x4( mb_type ) ) {
1357             if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1358                 mb_type |= MB_TYPE_8x8DCT;
1359                 for( i = 0; i < 16; i+=4 ) {
1360                     int pred = pred_intra_mode( h, i );
1361                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1362                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1363                 }
1364             } else {
1365                 for( i = 0; i < 16; i++ ) {
1366                     int pred = pred_intra_mode( h, i );
1367                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1368
1369                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1370                 }
1371             }
1372             ff_h264_write_back_intra_pred_mode(h);
1373             if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1374         } else {
1375             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1376             if( h->intra16x16_pred_mode < 0 ) return -1;
1377         }
1378         if(CHROMA){
1379             h->chroma_pred_mode_table[mb_xy] =
1380             pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1381
1382             pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1383             if( pred_mode < 0 ) return -1;
1384             h->chroma_pred_mode= pred_mode;
1385         } else {
1386             h->chroma_pred_mode= DC_128_PRED8x8;
1387         }
1388     } else if( partition_count == 4 ) {
1389         int i, j, sub_partition_count[4], list, ref[2][4];
1390
1391         if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
1392             for( i = 0; i < 4; i++ ) {
1393                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1394                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1395                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1396             }
1397             if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1398                           h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1399                 ff_h264_pred_direct_motion(h, &mb_type);
1400                 h->ref_cache[0][scan8[4]] =
1401                 h->ref_cache[1][scan8[4]] =
1402                 h->ref_cache[0][scan8[12]] =
1403                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1404                     for( i = 0; i < 4; i++ )
1405                         fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1406             }
1407         } else {
1408             for( i = 0; i < 4; i++ ) {
1409                 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1410                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1411                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1412             }
1413         }
1414
1415         for( list = 0; list < h->list_count; list++ ) {
1416                 for( i = 0; i < 4; i++ ) {
1417                     if(IS_DIRECT(h->sub_mb_type[i])) continue;
1418                     if(IS_DIR(h->sub_mb_type[i], 0, list)){
1419                         if( h->ref_count[list] > 1 ){
1420                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1421                             if(ref[list][i] >= (unsigned)h->ref_count[list]){
1422                                 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1423                                 return -1;
1424                             }
1425                         }else
1426                             ref[list][i] = 0;
1427                     } else {
1428                         ref[list][i] = -1;
1429                     }
1430                                                        h->ref_cache[list][ scan8[4*i]+1 ]=
1431                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1432                 }
1433         }
1434
1435         if(dct8x8_allowed)
1436             dct8x8_allowed = get_dct8x8_allowed(h);
1437
1438         for(list=0; list<h->list_count; list++){
1439             for(i=0; i<4; i++){
1440                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1441                 if(IS_DIRECT(h->sub_mb_type[i])){
1442                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
1443                     continue;
1444                 }
1445
1446                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1447                     const int sub_mb_type= h->sub_mb_type[i];
1448                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1449                     for(j=0; j<sub_partition_count[i]; j++){
1450                         int mpx, mpy;
1451                         int mx, my;
1452                         const int index= 4*i + block_width*j;
1453                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1454                         uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1455                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
1456                         DECODE_CABAC_MB_MVD( h, list, index)
1457                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1458
1459                         if(IS_SUB_8X8(sub_mb_type)){
1460                             mv_cache[ 1 ][0]=
1461                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1462                             mv_cache[ 1 ][1]=
1463                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1464
1465                             mvd_cache[ 1 ][0]=
1466                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
1467                             mvd_cache[ 1 ][1]=
1468                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
1469                         }else if(IS_SUB_8X4(sub_mb_type)){
1470                             mv_cache[ 1 ][0]= mx;
1471                             mv_cache[ 1 ][1]= my;
1472
1473                             mvd_cache[ 1 ][0]=  mpx;
1474                             mvd_cache[ 1 ][1]= mpy;
1475                         }else if(IS_SUB_4X8(sub_mb_type)){
1476                             mv_cache[ 8 ][0]= mx;
1477                             mv_cache[ 8 ][1]= my;
1478
1479                             mvd_cache[ 8 ][0]= mpx;
1480                             mvd_cache[ 8 ][1]= mpy;
1481                         }
1482                         mv_cache[ 0 ][0]= mx;
1483                         mv_cache[ 0 ][1]= my;
1484
1485                         mvd_cache[ 0 ][0]= mpx;
1486                         mvd_cache[ 0 ][1]= mpy;
1487                     }
1488                 }else{
1489                     fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
1490                     fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
1491                 }
1492             }
1493         }
1494     } else if( IS_DIRECT(mb_type) ) {
1495         ff_h264_pred_direct_motion(h, &mb_type);
1496         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
1497         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
1498         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1499     } else {
1500         int list, i;
1501         if(IS_16X16(mb_type)){
1502             for(list=0; list<h->list_count; list++){
1503                 if(IS_DIR(mb_type, 0, list)){
1504                     int ref;
1505                     if(h->ref_count[list] > 1){
1506                         ref= decode_cabac_mb_ref(h, list, 0);
1507                         if(ref >= (unsigned)h->ref_count[list]){
1508                             av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1509                             return -1;
1510                         }
1511                     }else
1512                         ref=0;
1513                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1514                 }
1515             }
1516             for(list=0; list<h->list_count; list++){
1517                 if(IS_DIR(mb_type, 0, list)){
1518                     int mx,my,mpx,mpy;
1519                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1520                     DECODE_CABAC_MB_MVD( h, list, 0)
1521                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1522
1523                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
1524                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1525                 }
1526             }
1527         }
1528         else if(IS_16X8(mb_type)){
1529             for(list=0; list<h->list_count; list++){
1530                     for(i=0; i<2; i++){
1531                         if(IS_DIR(mb_type, i, list)){
1532                             int ref;
1533                             if(h->ref_count[list] > 1){
1534                                 ref= decode_cabac_mb_ref( h, list, 8*i );
1535                                 if(ref >= (unsigned)h->ref_count[list]){
1536                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1537                                     return -1;
1538                                 }
1539                             }else
1540                                 ref=0;
1541                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1542                         }else
1543                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1544                     }
1545             }
1546             for(list=0; list<h->list_count; list++){
1547                 for(i=0; i<2; i++){
1548                     if(IS_DIR(mb_type, i, list)){
1549                         int mx,my,mpx,mpy;
1550                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1551                         DECODE_CABAC_MB_MVD( h, list, 8*i)
1552                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1553
1554                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
1555                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1556                     }else{
1557                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
1558                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1559                     }
1560                 }
1561             }
1562         }else{
1563             assert(IS_8X16(mb_type));
1564             for(list=0; list<h->list_count; list++){
1565                     for(i=0; i<2; i++){
1566                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1567                             int ref;
1568                             if(h->ref_count[list] > 1){
1569                                 ref= decode_cabac_mb_ref( h, list, 4*i );
1570                                 if(ref >= (unsigned)h->ref_count[list]){
1571                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1572                                     return -1;
1573                                 }
1574                             }else
1575                                 ref=0;
1576                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1577                         }else
1578                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1579                     }
1580             }
1581             for(list=0; list<h->list_count; list++){
1582                 for(i=0; i<2; i++){
1583                     if(IS_DIR(mb_type, i, list)){
1584                         int mx,my,mpx,mpy;
1585                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1586                         DECODE_CABAC_MB_MVD( h, list, 4*i)
1587
1588                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1589                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
1590                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1591                     }else{
1592                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
1593                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1594                     }
1595                 }
1596             }
1597         }
1598     }
1599
1600    if( IS_INTER( mb_type ) ) {
1601         h->chroma_pred_mode_table[mb_xy] = 0;
1602         write_back_motion( h, mb_type );
1603    }
1604
1605     if( !IS_INTRA16x16( mb_type ) ) {
1606         cbp  = decode_cabac_mb_cbp_luma( h );
1607         if(CHROMA)
1608             cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1609     }
1610
1611     h->cbp_table[mb_xy] = h->cbp = cbp;
1612
1613     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1614         mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1615     }
1616     s->current_picture.mb_type[mb_xy]= mb_type;
1617
1618     if( cbp || IS_INTRA16x16( mb_type ) ) {
1619         const uint8_t *scan, *scan8x8;
1620         const uint32_t *qmul;
1621
1622         if(IS_INTERLACED(mb_type)){
1623             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1624             scan= s->qscale ? h->field_scan : h->field_scan_q0;
1625         }else{
1626             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1627             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1628         }
1629
1630         // decode_cabac_mb_dqp
1631         if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1632             int val = 1;
1633             int ctx= 2;
1634             const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1635
1636             while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1637                 ctx= 3;
1638                 val++;
1639                 if(val > 2*max_qp){ //prevent infinite loop
1640                     av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1641                     return -1;
1642                 }
1643             }
1644
1645             if( val&0x01 )
1646                 val=   (val + 1)>>1 ;
1647             else
1648                 val= -((val + 1)>>1);
1649             h->last_qscale_diff = val;
1650             s->qscale += val;
1651             if(((unsigned)s->qscale) > max_qp){
1652                 if(s->qscale<0) s->qscale+= max_qp+1;
1653                 else            s->qscale-= max_qp+1;
1654             }
1655             h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1656             h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1657         }else
1658             h->last_qscale_diff=0;
1659
1660         if( IS_INTRA16x16( mb_type ) ) {
1661             int i;
1662             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1663             AV_ZERO128(h->mb_luma_dc+0);
1664             AV_ZERO128(h->mb_luma_dc+8);
1665             AV_ZERO128(h->mb_luma_dc+16);
1666             AV_ZERO128(h->mb_luma_dc+24);
1667             decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16);
1668
1669             if( cbp&15 ) {
1670                 qmul = h->dequant4_coeff[0][s->qscale];
1671                 for( i = 0; i < 16; i++ ) {
1672                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1673                     decode_cabac_residual_nondc(h, h->mb + (16*i<<h->pixel_shift), 1, i, scan + 1, qmul, 15);
1674                 }
1675             } else {
1676                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1677             }
1678         } else {
1679             int i8x8, i4x4;
1680             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1681                 if( cbp & (1<<i8x8) ) {
1682                     if( IS_8x8DCT(mb_type) ) {
1683                         decode_cabac_residual_nondc(h, h->mb + (64*i8x8<<h->pixel_shift), 5, 4*i8x8,
1684                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1685                     } else {
1686                         qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1687                         for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1688                             const int index = 4*i8x8 + i4x4;
1689                             //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1690 //START_TIMER
1691                             decode_cabac_residual_nondc(h, h->mb + (16*index<<h->pixel_shift), 2, index, scan, qmul, 16);
1692 //STOP_TIMER("decode_residual")
1693                         }
1694                     }
1695                 } else {
1696                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1697                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1698                 }
1699             }
1700         }
1701
1702         if( cbp&0x30 ){
1703             int c;
1704             for( c = 0; c < 2; c++ ) {
1705                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1706                 decode_cabac_residual_dc(h, h->mb + ((256 + 16*4*c)<<h->pixel_shift), 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
1707             }
1708         }
1709
1710         if( cbp&0x20 ) {
1711             int c, i;
1712             for( c = 0; c < 2; c++ ) {
1713                 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1714                 for( i = 0; i < 4; i++ ) {
1715                     const int index = 16 + 4 * c + i;
1716                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1717                     decode_cabac_residual_nondc(h, h->mb + (16*index<<h->pixel_shift), 4, index, scan + 1, qmul, 15);
1718                 }
1719             }
1720         } else {
1721             uint8_t * const nnz= &h->non_zero_count_cache[0];
1722             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1723             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1724         }
1725     } else {
1726         uint8_t * const nnz= &h->non_zero_count_cache[0];
1727         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1728         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1729         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1730         h->last_qscale_diff = 0;
1731     }
1732
1733     s->current_picture.qscale_table[mb_xy]= s->qscale;
1734     write_back_non_zero_count(h);
1735
1736     if(MB_MBAFF){
1737         h->ref_count[0] >>= 1;
1738         h->ref_count[1] >>= 1;
1739     }
1740
1741     return 0;
1742 }