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