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