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