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 libavcodec/h264_cabac.c
  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
 693     if( h->slice_type_nos == FF_I_TYPE ) tab = cabac_context_init_I;
 694     else                                 tab = cabac_context_init_PB[h->cabac_init_idc];
 695
 696     /* calculate pre-state */
 697     for( i= 0; i < 460; i++ ) {
 698         int pre = 2*(((tab[i][0] * s->qscale) >>4 ) + tab[i][1]) - 127;
 699
 700         pre^= pre>>31;
 701         if(pre > 124)
 702             pre= 124 + (pre&1);
 703
 704         h->cabac_state[i] =  pre;
 705     }
 706 }
 707
 708 static int decode_cabac_field_decoding_flag(H264Context *h) {
 709     MpegEncContext * const s = &h->s;
 710     const long mbb_xy = h->mb_xy - 2L*s->mb_stride;
 711
 712     unsigned long ctx = 0;
 713
 714     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);
 715     ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num);
 716
 717     return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
 718 }
 719
 720 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
 721     uint8_t *state= &h->cabac_state[ctx_base];
 722     int mb_type;
 723
 724     if(intra_slice){
 725         int ctx=0;
 726         if( h->left_type[0] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
 727             ctx++;
 728         if( h->top_type     & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
 729             ctx++;
 730         if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
 731             return 0;   /* I4x4 */
 732         state += 2;
 733     }else{
 734         if( get_cabac_noinline( &h->cabac, state ) == 0 )
 735             return 0;   /* I4x4 */
 736     }
 737
 738     if( get_cabac_terminate( &h->cabac ) )
 739         return 25;  /* PCM */
 740
 741     mb_type = 1; /* I16x16 */
 742     mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
 743     if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
 744         mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
 745     mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
 746     mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
 747     return mb_type;
 748 }
 749
 750 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
 751     MpegEncContext * const s = &h->s;
 752     int mba_xy, mbb_xy;
 753     int ctx = 0;
 754
 755     if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
 756         int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
 757         mba_xy = mb_xy - 1;
 758         if( (mb_y&1)
 759             && h->slice_table[mba_xy] == h->slice_num
 760             && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
 761             mba_xy += s->mb_stride;
 762         if( MB_FIELD ){
 763             mbb_xy = mb_xy - s->mb_stride;
 764             if( !(mb_y&1)
 765                 && h->slice_table[mbb_xy] == h->slice_num
 766                 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
 767                 mbb_xy -= s->mb_stride;
 768         }else
 769             mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
 770     }else{
 771         int mb_xy = h->mb_xy;
 772         mba_xy = mb_xy - 1;
 773         mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
 774     }
 775
 776     if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
 777         ctx++;
 778     if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
 779         ctx++;
 780
 781     if( h->slice_type_nos == FF_B_TYPE )
 782         ctx += 13;
 783     return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
 784 }
 785
 786 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
 787     int mode = 0;
 788
 789     if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
 790         return pred_mode;
 791
 792     mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
 793     mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
 794     mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
 795
 796     return mode + ( mode >= pred_mode );
 797 }
 798
 799 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
 800     const int mba_xy = h->left_mb_xy[0];
 801     const int mbb_xy = h->top_mb_xy;
 802
 803     int ctx = 0;
 804
 805     /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
 806     if( h->left_type[0] && h->chroma_pred_mode_table[mba_xy] != 0 )
 807         ctx++;
 808
 809     if( h->top_type     && h->chroma_pred_mode_table[mbb_xy] != 0 )
 810         ctx++;
 811
 812     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
 813         return 0;
 814
 815     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
 816         return 1;
 817     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
 818         return 2;
 819     else
 820         return 3;
 821 }
 822
 823 static int decode_cabac_mb_cbp_luma( H264Context *h) {
 824     int cbp_b, cbp_a, ctx, cbp = 0;
 825
 826     cbp_a = h->left_cbp;
 827     cbp_b = h->top_cbp;
 828
 829     ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
 830     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
 831     ctx = !(cbp   & 0x01) + 2 * !(cbp_b & 0x08);
 832     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
 833     ctx = !(cbp_a & 0x08) + 2 * !(cbp   & 0x01);
 834     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
 835     ctx = !(cbp   & 0x04) + 2 * !(cbp   & 0x02);
 836     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
 837     return cbp;
 838 }
 839 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
 840     int ctx;
 841     int cbp_a, cbp_b;
 842
 843     cbp_a = (h->left_cbp>>4)&0x03;
 844     cbp_b = (h-> top_cbp>>4)&0x03;
 845
 846     ctx = 0;
 847     if( cbp_a > 0 ) ctx++;
 848     if( cbp_b > 0 ) ctx += 2;
 849     if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
 850         return 0;
 851
 852     ctx = 4;
 853     if( cbp_a == 2 ) ctx++;
 854     if( cbp_b == 2 ) ctx += 2;
 855     return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
 856 }
 857
 858 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
 859     if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
 860         return 0;   /* 8x8 */
 861     if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
 862         return 1;   /* 8x4 */
 863     if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
 864         return 2;   /* 4x8 */
 865     return 3;       /* 4x4 */
 866 }
 867 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
 868     int type;
 869     if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
 870         return 0;   /* B_Direct_8x8 */
 871     if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
 872         return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
 873     type = 3;
 874     if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
 875         if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
 876             return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
 877         type += 4;
 878     }
 879     type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
 880     type +=   get_cabac( &h->cabac, &h->cabac_state[39] );
 881     return type;
 882 }
 883
 884 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
 885     int refa = h->ref_cache[list][scan8[n] - 1];
 886     int refb = h->ref_cache[list][scan8[n] - 8];
 887     int ref  = 0;
 888     int ctx  = 0;
 889
 890     if( h->slice_type_nos == FF_B_TYPE) {
 891         if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
 892             ctx++;
 893         if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
 894             ctx += 2;
 895     } else {
 896         if( refa > 0 )
 897             ctx++;
 898         if( refb > 0 )
 899             ctx += 2;
 900     }
 901
 902     while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
 903         ref++;
 904         ctx = (ctx>>2)+4;
 905         if(ref >= 32 /*h->ref_list[list]*/){
 906             return -1;
 907         }
 908     }
 909     return ref;
 910 }
 911
 912 static int decode_cabac_mb_mvd( H264Context *h, int ctxbase, int amvd, int *mvda) {
 913     int mvd;
 914
 915     if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+((amvd-3)>>(INT_BIT-1))+((amvd-33)>>(INT_BIT-1))+2])){
 916 //    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){
 917         *mvda= 0;
 918         return 0;
 919     }
 920
 921     mvd= 1;
 922     ctxbase+= 3;
 923     while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) {
 924         if( mvd < 4 )
 925             ctxbase++;
 926         mvd++;
 927     }
 928
 929     if( mvd >= 9 ) {
 930         int k = 3;
 931         while( get_cabac_bypass( &h->cabac ) ) {
 932             mvd += 1 << k;
 933             k++;
 934             if(k>24){
 935                 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
 936                 return INT_MIN;
 937             }
 938         }
 939         while( k-- ) {
 940             mvd += get_cabac_bypass( &h->cabac )<<k;
 941         }
 942         *mvda=mvd < 70 ? mvd : 70;
 943     }else
 944         *mvda=mvd;
 945     return get_cabac_bypass_sign( &h->cabac, -mvd );
 946 }
 947
 948 #define DECODE_CABAC_MB_MVD( h,  list,  n )\
 949 {\
 950     int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\
 951                 h->mvd_cache[list][scan8[n] - 8][0];\
 952     int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\
 953                 h->mvd_cache[list][scan8[n] - 8][1];\
 954 \
 955     mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\
 956     my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\
 957 }
 958
 959 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
 960     int nza, nzb;
 961     int ctx = 0;
 962
 963     if( is_dc ) {
 964         if( cat == 0 ) {
 965             nza = h->left_cbp&0x100;
 966             nzb = h-> top_cbp&0x100;
 967         } else {
 968             nza = (h->left_cbp>>(6+idx))&0x01;
 969             nzb = (h-> top_cbp>>(6+idx))&0x01;
 970         }
 971     } else {
 972         assert(cat == 1 || cat == 2 || cat == 4);
 973         nza = h->non_zero_count_cache[scan8[idx] - 1];
 974         nzb = h->non_zero_count_cache[scan8[idx] - 8];
 975     }
 976
 977     if( nza > 0 )
 978         ctx++;
 979
 980     if( nzb > 0 )
 981         ctx += 2;
 982
 983     return ctx + 4 * cat;
 984 }
 985
 986 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
 987     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 988     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 989     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
 990     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
 991 };
 992
 993 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 ) {
 994     static const int significant_coeff_flag_offset[2][6] = {
 995       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
 996       { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
 997     };
 998     static const int last_coeff_flag_offset[2][6] = {
 999       { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1000       { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1001     };
1002     static const int coeff_abs_level_m1_offset[6] = {
1003         227+0, 227+10, 227+20, 227+30, 227+39, 426
1004     };
1005     static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1006       { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1007         4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1008         7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1009        12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1010       { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1011         6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1012         9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1013         9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1014     };
1015     /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1016      * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1017      * map node ctx => cabac ctx for level=1 */
1018     static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1019     /* map node ctx => cabac ctx for level>1 */
1020     static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1021     static const uint8_t coeff_abs_level_transition[2][8] = {
1022     /* update node ctx after decoding a level=1 */
1023         { 1, 2, 3, 3, 4, 5, 6, 7 },
1024     /* update node ctx after decoding a level>1 */
1025         { 4, 4, 4, 4, 5, 6, 7, 7 }
1026     };
1027
1028     int index[64];
1029
1030     int av_unused last;
1031     int coeff_count = 0;
1032     int node_ctx = 0;
1033
1034     uint8_t *significant_coeff_ctx_base;
1035     uint8_t *last_coeff_ctx_base;
1036     uint8_t *abs_level_m1_ctx_base;
1037
1038 #if !ARCH_X86
1039 #define CABAC_ON_STACK
1040 #endif
1041 #ifdef CABAC_ON_STACK
1042 #define CC &cc
1043     CABACContext cc;
1044     cc.range     = h->cabac.range;
1045     cc.low       = h->cabac.low;
1046     cc.bytestream= h->cabac.bytestream;
1047 #else
1048 #define CC &h->cabac
1049 #endif
1050
1051
1052     /* cat: 0-> DC 16x16  n = 0
1053      *      1-> AC 16x16  n = luma4x4idx
1054      *      2-> Luma4x4   n = luma4x4idx
1055      *      3-> DC Chroma n = iCbCr
1056      *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1057      *      5-> Luma8x8   n = 4 * luma8x8idx
1058      */
1059
1060     /* read coded block flag */
1061     if( is_dc || cat != 5 ) {
1062         if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1063             if( !is_dc )
1064                 h->non_zero_count_cache[scan8[n]] = 0;
1065
1066 #ifdef CABAC_ON_STACK
1067             h->cabac.range     = cc.range     ;
1068             h->cabac.low       = cc.low       ;
1069             h->cabac.bytestream= cc.bytestream;
1070 #endif
1071             return;
1072         }
1073     }
1074
1075     significant_coeff_ctx_base = h->cabac_state
1076         + significant_coeff_flag_offset[MB_FIELD][cat];
1077     last_coeff_ctx_base = h->cabac_state
1078         + last_coeff_flag_offset[MB_FIELD][cat];
1079     abs_level_m1_ctx_base = h->cabac_state
1080         + coeff_abs_level_m1_offset[cat];
1081
1082     if( !is_dc && cat == 5 ) {
1083 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1084         for(last= 0; last < coefs; last++) { \
1085             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1086             if( get_cabac( CC, sig_ctx )) { \
1087                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1088                 index[coeff_count++] = last; \
1089                 if( get_cabac( CC, last_ctx ) ) { \
1090                     last= max_coeff; \
1091                     break; \
1092                 } \
1093             } \
1094         }\
1095         if( last == max_coeff -1 ) {\
1096             index[coeff_count++] = last;\
1097         }
1098         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1099 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1100         coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1101     } else {
1102         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1103 #else
1104         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1105     } else {
1106         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1107 #endif
1108     }
1109     assert(coeff_count > 0);
1110
1111     if( is_dc ) {
1112         if( cat == 0 )
1113             h->cbp_table[h->mb_xy] |= 0x100;
1114         else
1115             h->cbp_table[h->mb_xy] |= 0x40 << n;
1116     } else {
1117         if( cat == 5 )
1118             fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1119         else {
1120             assert( cat == 1 || cat == 2 || cat == 4 );
1121             h->non_zero_count_cache[scan8[n]] = coeff_count;
1122         }
1123     }
1124
1125     do {
1126         uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1127
1128         int j= scantable[index[--coeff_count]];
1129
1130         if( get_cabac( CC, ctx ) == 0 ) {
1131             node_ctx = coeff_abs_level_transition[0][node_ctx];
1132             if( is_dc ) {
1133                 block[j] = get_cabac_bypass_sign( CC, -1);
1134             }else{
1135                 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1136             }
1137         } else {
1138             int coeff_abs = 2;
1139             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1140             node_ctx = coeff_abs_level_transition[1][node_ctx];
1141
1142             while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1143                 coeff_abs++;
1144             }
1145
1146             if( coeff_abs >= 15 ) {
1147                 int j = 0;
1148                 while( get_cabac_bypass( CC ) ) {
1149                     j++;
1150                 }
1151
1152                 coeff_abs=1;
1153                 while( j-- ) {
1154                     coeff_abs += coeff_abs + get_cabac_bypass( CC );
1155                 }
1156                 coeff_abs+= 14;
1157             }
1158
1159             if( is_dc ) {
1160                 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1161             }else{
1162                 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1163             }
1164         }
1165     } while( coeff_count );
1166 #ifdef CABAC_ON_STACK
1167             h->cabac.range     = cc.range     ;
1168             h->cabac.low       = cc.low       ;
1169             h->cabac.bytestream= cc.bytestream;
1170 #endif
1171
1172 }
1173
1174 static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1175     decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1);
1176 }
1177
1178 static void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1179     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1180 }
1181
1182 /**
1183  * decodes a macroblock
1184  * @return 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1185  */
1186 int ff_h264_decode_mb_cabac(H264Context *h) {
1187     MpegEncContext * const s = &h->s;
1188     int mb_xy;
1189     int mb_type, partition_count, cbp = 0;
1190     int dct8x8_allowed= h->pps.transform_8x8_mode;
1191
1192     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1193
1194     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1195     if( h->slice_type_nos != FF_I_TYPE ) {
1196         int skip;
1197         /* a skipped mb needs the aff flag from the following mb */
1198         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1199             skip = h->next_mb_skipped;
1200         else
1201             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1202         /* read skip flags */
1203         if( skip ) {
1204             if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1205                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1206                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1207                 if(!h->next_mb_skipped)
1208                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1209             }
1210
1211             decode_mb_skip(h);
1212
1213             h->cbp_table[mb_xy] = 0;
1214             h->chroma_pred_mode_table[mb_xy] = 0;
1215             h->last_qscale_diff = 0;
1216
1217             return 0;
1218
1219         }
1220     }
1221     if(FRAME_MBAFF){
1222         if( (s->mb_y&1) == 0 )
1223             h->mb_mbaff =
1224             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1225     }
1226
1227     h->prev_mb_skipped = 0;
1228
1229     fill_decode_neighbors(h, -(MB_FIELD));
1230
1231     if( h->slice_type_nos == FF_B_TYPE ) {
1232         int ctx = 0;
1233         assert(h->slice_type_nos == FF_B_TYPE);
1234
1235         if( !IS_DIRECT( h->left_type[0]-1 ) )
1236             ctx++;
1237         if( !IS_DIRECT( h->top_type-1 ) )
1238             ctx++;
1239
1240         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1241             mb_type= 0; /* B_Direct_16x16 */
1242         }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1243             mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1244         }else{
1245             int bits;
1246             bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1247             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1248             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1249             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1250             if( bits < 8 ){
1251                 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1252             }else if( bits == 13 ){
1253                 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1254                 goto decode_intra_mb;
1255             }else if( bits == 14 ){
1256                 mb_type= 11; /* B_L1_L0_8x16 */
1257             }else if( bits == 15 ){
1258                 mb_type= 22; /* B_8x8 */
1259             }else{
1260                 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1261                 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1262             }
1263         }
1264             partition_count= b_mb_type_info[mb_type].partition_count;
1265             mb_type=         b_mb_type_info[mb_type].type;
1266     } else if( h->slice_type_nos == FF_P_TYPE ) {
1267         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1268             /* P-type */
1269             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1270                 /* P_L0_D16x16, P_8x8 */
1271                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1272             } else {
1273                 /* P_L0_D8x16, P_L0_D16x8 */
1274                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1275             }
1276             partition_count= p_mb_type_info[mb_type].partition_count;
1277             mb_type=         p_mb_type_info[mb_type].type;
1278         } else {
1279             mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1280             goto decode_intra_mb;
1281         }
1282     } else {
1283         mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1284         if(h->slice_type == FF_SI_TYPE && mb_type)
1285             mb_type--;
1286         assert(h->slice_type_nos == FF_I_TYPE);
1287 decode_intra_mb:
1288         partition_count = 0;
1289         cbp= i_mb_type_info[mb_type].cbp;
1290         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1291         mb_type= i_mb_type_info[mb_type].type;
1292     }
1293     if(MB_FIELD)
1294         mb_type |= MB_TYPE_INTERLACED;
1295
1296     h->slice_table[ mb_xy ]= h->slice_num;
1297
1298     if(IS_INTRA_PCM(mb_type)) {
1299         const uint8_t *ptr;
1300
1301         // We assume these blocks are very rare so we do not optimize it.
1302         // FIXME The two following lines get the bitstream position in the cabac
1303         // decode, I think it should be done by a function in cabac.h (or cabac.c).
1304         ptr= h->cabac.bytestream;
1305         if(h->cabac.low&0x1) ptr--;
1306         if(CABAC_BITS==16){
1307             if(h->cabac.low&0x1FF) ptr--;
1308         }
1309
1310         // The pixels are stored in the same order as levels in h->mb array.
1311         memcpy(h->mb, ptr, 256); ptr+=256;
1312         if(CHROMA){
1313             memcpy(h->mb+128, ptr, 128); ptr+=128;
1314         }
1315
1316         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1317
1318         // All blocks are present
1319         h->cbp_table[mb_xy] = 0x1ef;
1320         h->chroma_pred_mode_table[mb_xy] = 0;
1321         // In deblocking, the quantizer is 0
1322         s->current_picture.qscale_table[mb_xy]= 0;
1323         // All coeffs are present
1324         memset(h->non_zero_count[mb_xy], 16, 32);
1325         s->current_picture.mb_type[mb_xy]= mb_type;
1326         h->last_qscale_diff = 0;
1327         return 0;
1328     }
1329
1330     if(MB_MBAFF){
1331         h->ref_count[0] <<= 1;
1332         h->ref_count[1] <<= 1;
1333     }
1334
1335     fill_decode_caches(h, mb_type);
1336
1337     if( IS_INTRA( mb_type ) ) {
1338         int i, pred_mode;
1339         if( IS_INTRA4x4( mb_type ) ) {
1340             if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1341                 mb_type |= MB_TYPE_8x8DCT;
1342                 for( i = 0; i < 16; i+=4 ) {
1343                     int pred = pred_intra_mode( h, i );
1344                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1345                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1346                 }
1347             } else {
1348                 for( i = 0; i < 16; i++ ) {
1349                     int pred = pred_intra_mode( h, i );
1350                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1351
1352                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1353                 }
1354             }
1355             ff_h264_write_back_intra_pred_mode(h);
1356             if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1357         } else {
1358             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1359             if( h->intra16x16_pred_mode < 0 ) return -1;
1360         }
1361         if(CHROMA){
1362             h->chroma_pred_mode_table[mb_xy] =
1363             pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1364
1365             pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1366             if( pred_mode < 0 ) return -1;
1367             h->chroma_pred_mode= pred_mode;
1368         }
1369     } else if( partition_count == 4 ) {
1370         int i, j, sub_partition_count[4], list, ref[2][4];
1371
1372         if( h->slice_type_nos == FF_B_TYPE ) {
1373             for( i = 0; i < 4; i++ ) {
1374                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1375                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1376                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1377             }
1378             if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1379                           h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1380                 ff_h264_pred_direct_motion(h, &mb_type);
1381                 h->ref_cache[0][scan8[4]] =
1382                 h->ref_cache[1][scan8[4]] =
1383                 h->ref_cache[0][scan8[12]] =
1384                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1385                     for( i = 0; i < 4; i++ )
1386                         fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1387             }
1388         } else {
1389             for( i = 0; i < 4; i++ ) {
1390                 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1391                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1392                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1393             }
1394         }
1395
1396         for( list = 0; list < h->list_count; list++ ) {
1397                 for( i = 0; i < 4; i++ ) {
1398                     if(IS_DIRECT(h->sub_mb_type[i])) continue;
1399                     if(IS_DIR(h->sub_mb_type[i], 0, list)){
1400                         if( h->ref_count[list] > 1 ){
1401                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1402                             if(ref[list][i] >= (unsigned)h->ref_count[list]){
1403                                 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1404                                 return -1;
1405                             }
1406                         }else
1407                             ref[list][i] = 0;
1408                     } else {
1409                         ref[list][i] = -1;
1410                     }
1411                                                        h->ref_cache[list][ scan8[4*i]+1 ]=
1412                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1413                 }
1414         }
1415
1416         if(dct8x8_allowed)
1417             dct8x8_allowed = get_dct8x8_allowed(h);
1418
1419         for(list=0; list<h->list_count; list++){
1420             for(i=0; i<4; i++){
1421                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1422                 if(IS_DIRECT(h->sub_mb_type[i])){
1423                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
1424                     continue;
1425                 }
1426
1427                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1428                     const int sub_mb_type= h->sub_mb_type[i];
1429                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1430                     for(j=0; j<sub_partition_count[i]; j++){
1431                         int mpx, mpy;
1432                         int mx, my;
1433                         const int index= 4*i + block_width*j;
1434                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1435                         uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1436                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
1437                         DECODE_CABAC_MB_MVD( h, list, index)
1438                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1439
1440                         if(IS_SUB_8X8(sub_mb_type)){
1441                             mv_cache[ 1 ][0]=
1442                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1443                             mv_cache[ 1 ][1]=
1444                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1445
1446                             mvd_cache[ 1 ][0]=
1447                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
1448                             mvd_cache[ 1 ][1]=
1449                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
1450                         }else if(IS_SUB_8X4(sub_mb_type)){
1451                             mv_cache[ 1 ][0]= mx;
1452                             mv_cache[ 1 ][1]= my;
1453
1454                             mvd_cache[ 1 ][0]=  mpx;
1455                             mvd_cache[ 1 ][1]= mpy;
1456                         }else if(IS_SUB_4X8(sub_mb_type)){
1457                             mv_cache[ 8 ][0]= mx;
1458                             mv_cache[ 8 ][1]= my;
1459
1460                             mvd_cache[ 8 ][0]= mpx;
1461                             mvd_cache[ 8 ][1]= mpy;
1462                         }
1463                         mv_cache[ 0 ][0]= mx;
1464                         mv_cache[ 0 ][1]= my;
1465
1466                         mvd_cache[ 0 ][0]= mpx;
1467                         mvd_cache[ 0 ][1]= mpy;
1468                     }
1469                 }else{
1470                     fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
1471                     fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
1472                 }
1473             }
1474         }
1475     } else if( IS_DIRECT(mb_type) ) {
1476         ff_h264_pred_direct_motion(h, &mb_type);
1477         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
1478         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
1479         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1480     } else {
1481         int list, i;
1482         if(IS_16X16(mb_type)){
1483             for(list=0; list<h->list_count; list++){
1484                 if(IS_DIR(mb_type, 0, list)){
1485                     int ref;
1486                     if(h->ref_count[list] > 1){
1487                         ref= decode_cabac_mb_ref(h, list, 0);
1488                         if(ref >= (unsigned)h->ref_count[list]){
1489                             av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1490                             return -1;
1491                         }
1492                     }else
1493                         ref=0;
1494                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1495                 }
1496             }
1497             for(list=0; list<h->list_count; list++){
1498                 if(IS_DIR(mb_type, 0, list)){
1499                     int mx,my,mpx,mpy;
1500                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1501                     DECODE_CABAC_MB_MVD( h, list, 0)
1502                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1503
1504                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
1505                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1506                 }
1507             }
1508         }
1509         else if(IS_16X8(mb_type)){
1510             for(list=0; list<h->list_count; list++){
1511                     for(i=0; i<2; i++){
1512                         if(IS_DIR(mb_type, i, list)){
1513                             int ref;
1514                             if(h->ref_count[list] > 1){
1515                                 ref= decode_cabac_mb_ref( h, list, 8*i );
1516                                 if(ref >= (unsigned)h->ref_count[list]){
1517                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1518                                     return -1;
1519                                 }
1520                             }else
1521                                 ref=0;
1522                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1523                         }else
1524                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1525                     }
1526             }
1527             for(list=0; list<h->list_count; list++){
1528                 for(i=0; i<2; i++){
1529                     if(IS_DIR(mb_type, i, list)){
1530                         int mx,my,mpx,mpy;
1531                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1532                         DECODE_CABAC_MB_MVD( h, list, 8*i)
1533                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1534
1535                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
1536                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1537                     }else{
1538                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
1539                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1540                     }
1541                 }
1542             }
1543         }else{
1544             assert(IS_8X16(mb_type));
1545             for(list=0; list<h->list_count; list++){
1546                     for(i=0; i<2; i++){
1547                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1548                             int ref;
1549                             if(h->ref_count[list] > 1){
1550                                 ref= decode_cabac_mb_ref( h, list, 4*i );
1551                                 if(ref >= (unsigned)h->ref_count[list]){
1552                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1553                                     return -1;
1554                                 }
1555                             }else
1556                                 ref=0;
1557                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1558                         }else
1559                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1560                     }
1561             }
1562             for(list=0; list<h->list_count; list++){
1563                 for(i=0; i<2; i++){
1564                     if(IS_DIR(mb_type, i, list)){
1565                         int mx,my,mpx,mpy;
1566                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1567                         DECODE_CABAC_MB_MVD( h, list, 4*i)
1568
1569                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1570                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
1571                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1572                     }else{
1573                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
1574                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1575                     }
1576                 }
1577             }
1578         }
1579     }
1580
1581    if( IS_INTER( mb_type ) ) {
1582         h->chroma_pred_mode_table[mb_xy] = 0;
1583         write_back_motion( h, mb_type );
1584    }
1585
1586     if( !IS_INTRA16x16( mb_type ) ) {
1587         cbp  = decode_cabac_mb_cbp_luma( h );
1588         if(CHROMA)
1589             cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1590     }
1591
1592     h->cbp_table[mb_xy] = h->cbp = cbp;
1593
1594     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1595         mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1596     }
1597     s->current_picture.mb_type[mb_xy]= mb_type;
1598
1599     if( cbp || IS_INTRA16x16( mb_type ) ) {
1600         const uint8_t *scan, *scan8x8, *dc_scan;
1601         const uint32_t *qmul;
1602
1603         if(IS_INTERLACED(mb_type)){
1604             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1605             scan= s->qscale ? h->field_scan : h->field_scan_q0;
1606             dc_scan= luma_dc_field_scan;
1607         }else{
1608             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1609             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1610             dc_scan= luma_dc_zigzag_scan;
1611         }
1612
1613         // decode_cabac_mb_dqp
1614         if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1615             int val = 1;
1616             int ctx= 2;
1617
1618             while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1619                 ctx= 3;
1620                 val++;
1621                 if(val > 102){ //prevent infinite loop
1622                     av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1623                     return -1;
1624                 }
1625             }
1626
1627             if( val&0x01 )
1628                 val=   (val + 1)>>1 ;
1629             else
1630                 val= -((val + 1)>>1);
1631             h->last_qscale_diff = val;
1632             s->qscale += val;
1633             if(((unsigned)s->qscale) > 51){
1634                 if(s->qscale<0) s->qscale+= 52;
1635                 else            s->qscale-= 52;
1636             }
1637             h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1638             h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1639         }else
1640             h->last_qscale_diff=0;
1641
1642         if( IS_INTRA16x16( mb_type ) ) {
1643             int i;
1644             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1645             decode_cabac_residual_dc( h, h->mb, 0, 0, dc_scan, 16);
1646
1647             if( cbp&15 ) {
1648                 qmul = h->dequant4_coeff[0][s->qscale];
1649                 for( i = 0; i < 16; i++ ) {
1650                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1651                     decode_cabac_residual_nondc(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1652                 }
1653             } else {
1654                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1655             }
1656         } else {
1657             int i8x8, i4x4;
1658             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1659                 if( cbp & (1<<i8x8) ) {
1660                     if( IS_8x8DCT(mb_type) ) {
1661                         decode_cabac_residual_nondc(h, h->mb + 64*i8x8, 5, 4*i8x8,
1662                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1663                     } else {
1664                         qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1665                         for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1666                             const int index = 4*i8x8 + i4x4;
1667                             //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1668 //START_TIMER
1669                             decode_cabac_residual_nondc(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1670 //STOP_TIMER("decode_residual")
1671                         }
1672                     }
1673                 } else {
1674                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1675                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1676                 }
1677             }
1678         }
1679
1680         if( cbp&0x30 ){
1681             int c;
1682             for( c = 0; c < 2; c++ ) {
1683                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1684                 decode_cabac_residual_dc(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, 4);
1685             }
1686         }
1687
1688         if( cbp&0x20 ) {
1689             int c, i;
1690             for( c = 0; c < 2; c++ ) {
1691                 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1692                 for( i = 0; i < 4; i++ ) {
1693                     const int index = 16 + 4 * c + i;
1694                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1695                     decode_cabac_residual_nondc(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1696                 }
1697             }
1698         } else {
1699             uint8_t * const nnz= &h->non_zero_count_cache[0];
1700             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1701             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1702         }
1703     } else {
1704         uint8_t * const nnz= &h->non_zero_count_cache[0];
1705         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1706         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1707         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1708         h->last_qscale_diff = 0;
1709     }
1710
1711     s->current_picture.qscale_table[mb_xy]= s->qscale;
1712     write_back_non_zero_count(h);
1713
1714     if(MB_MBAFF){
1715         h->ref_count[0] >>= 1;
1716         h->ref_count[1] >>= 1;
1717     }
1718
1719     return 0;
1720 }