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