git.sesse.net Git - ffmpeg/blob - libavcodec/h264_cabac.c

   1 /*
   2  * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding
   3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file libavcodec/h264_cabac.c
  24  * H.264 / AVC / MPEG4 part10 cabac decoding.
  25  * @author Michael Niedermayer <michaelni@gmx.at>
  26  */
  27
  28 #define CABAC 1
  29
  30 #include "internal.h"
  31 #include "dsputil.h"
  32 #include "avcodec.h"
  33 #include "h264.h"
  34 #include "h264data.h"
  35 #include "h264_mvpred.h"
  36 #include "golomb.h"
  37
  38 #include "cabac.h"
  39 #if ARCH_X86
  40 #include "x86/h264_i386.h"
  41 #endif
  42
  43 //#undef NDEBUG
  44 #include <assert.h>
  45
  46 /* Cabac pre state table */
  47
  48 static const int8_t cabac_context_init_I[460][2] =
  49 {
  50     /* 0 - 10 */
  51     { 20, -15 }, {  2, 54 },  {  3,  74 }, { 20, -15 },
  52     {  2,  54 }, {  3, 74 },  { -28,127 }, { -23, 104 },
  53     { -6,  53 }, { -1, 54 },  {  7,  51 },
  54
  55     /* 11 - 23 unsused for I */
  56     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  57     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  58     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  59     { 0, 0 },
  60
  61     /* 24- 39 */
  62     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  63     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  64     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  65     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  66
  67     /* 40 - 53 */
  68     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  69     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  70     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  71     { 0, 0 },    { 0, 0 },
  72
  73     /* 54 - 59 */
  74     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
  75     { 0, 0 },    { 0, 0 },
  76
  77     /* 60 - 69 */
  78     { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
  79     { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
  80     { 13, 41 },  { 3, 62 },
  81
  82     /* 70 -> 87 */
  83     { 0, 11 },   { 1, 55 },   { 0, 69 },     { -17, 127 },
  84     { -13, 102 },{ 0, 82 },   { -7, 74 },    { -21, 107 },
  85     { -27, 127 },{ -31, 127 },{ -24, 127 },  { -18, 95 },
  86     { -27, 127 },{ -21, 114 },{ -30, 127 },  { -17, 123 },
  87     { -12, 115 },{ -16, 122 },
  88
  89     /* 88 -> 104 */
  90     { -11, 115 },{ -12, 63 }, { -2, 68 },    { -15, 84 },
  91     { -13, 104 },{ -3, 70 },  { -8, 93 },    { -10, 90 },
  92     { -30, 127 },{ -1, 74 },  { -6, 97 },    { -7, 91 },
  93     { -20, 127 },{ -4, 56 },  { -5, 82 },    { -7, 76 },
  94     { -22, 125 },
  95
  96     /* 105 -> 135 */
  97     { -7, 93 },  { -11, 87 }, { -3, 77 },    { -5, 71 },
  98     { -4, 63 },  { -4, 68 },  { -12, 84 },   { -7, 62 },
  99     { -7, 65 },  { 8, 61 },   { 5, 56 },     { -2, 66 },
 100     { 1, 64 },   { 0, 61 },   { -2, 78 },    { 1, 50 },
 101     { 7, 52 },   { 10, 35 },  { 0, 44 },     { 11, 38 },
 102     { 1, 45 },   { 0, 46 },   { 5, 44 },     { 31, 17 },
 103     { 1, 51 },   { 7, 50 },   { 28, 19 },    { 16, 33 },
 104     { 14, 62 },  { -13, 108 },{ -15, 100 },
 105
 106     /* 136 -> 165 */
 107     { -13, 101 },{ -13, 91 }, { -12, 94 },   { -10, 88 },
 108     { -16, 84 }, { -10, 86 }, { -7, 83 },    { -13, 87 },
 109     { -19, 94 }, { 1, 70 },   { 0, 72 },     { -5, 74 },
 110     { 18, 59 },  { -8, 102 }, { -15, 100 },  { 0, 95 },
 111     { -4, 75 },  { 2, 72 },   { -11, 75 },   { -3, 71 },
 112     { 15, 46 },  { -13, 69 }, { 0, 62 },     { 0, 65 },
 113     { 21, 37 },  { -15, 72 }, { 9, 57 },     { 16, 54 },
 114     { 0, 62 },   { 12, 72 },
 115
 116     /* 166 -> 196 */
 117     { 24, 0 },   { 15, 9 },   { 8, 25 },     { 13, 18 },
 118     { 15, 9 },   { 13, 19 },  { 10, 37 },    { 12, 18 },
 119     { 6, 29 },   { 20, 33 },  { 15, 30 },    { 4, 45 },
 120     { 1, 58 },   { 0, 62 },   { 7, 61 },     { 12, 38 },
 121     { 11, 45 },  { 15, 39 },  { 11, 42 },    { 13, 44 },
 122     { 16, 45 },  { 12, 41 },  { 10, 49 },    { 30, 34 },
 123     { 18, 42 },  { 10, 55 },  { 17, 51 },    { 17, 46 },
 124     { 0, 89 },   { 26, -19 }, { 22, -17 },
 125
 126     /* 197 -> 226 */
 127     { 26, -17 }, { 30, -25 }, { 28, -20 },   { 33, -23 },
 128     { 37, -27 }, { 33, -23 }, { 40, -28 },   { 38, -17 },
 129     { 33, -11 }, { 40, -15 }, { 41, -6 },    { 38, 1 },
 130     { 41, 17 },  { 30, -6 },  { 27, 3 },     { 26, 22 },
 131     { 37, -16 }, { 35, -4 },  { 38, -8 },    { 38, -3 },
 132     { 37, 3 },   { 38, 5 },   { 42, 0 },     { 35, 16 },
 133     { 39, 22 },  { 14, 48 },  { 27, 37 },    { 21, 60 },
 134     { 12, 68 },  { 2, 97 },
 135
 136     /* 227 -> 251 */
 137     { -3, 71 },  { -6, 42 },  { -5, 50 },    { -3, 54 },
 138     { -2, 62 },  { 0, 58 },   { 1, 63 },     { -2, 72 },
 139     { -1, 74 },  { -9, 91 },  { -5, 67 },    { -5, 27 },
 140     { -3, 39 },  { -2, 44 },  { 0, 46 },     { -16, 64 },
 141     { -8, 68 },  { -10, 78 }, { -6, 77 },    { -10, 86 },
 142     { -12, 92 }, { -15, 55 }, { -10, 60 },   { -6, 62 },
 143     { -4, 65 },
 144
 145     /* 252 -> 275 */
 146     { -12, 73 }, { -8, 76 },  { -7, 80 },    { -9, 88 },
 147     { -17, 110 },{ -11, 97 }, { -20, 84 },   { -11, 79 },
 148     { -6, 73 },  { -4, 74 },  { -13, 86 },   { -13, 96 },
 149     { -11, 97 }, { -19, 117 },{ -8, 78 },    { -5, 33 },
 150     { -4, 48 },  { -2, 53 },  { -3, 62 },    { -13, 71 },
 151     { -10, 79 }, { -12, 86 }, { -13, 90 },   { -14, 97 },
 152
 153     /* 276 a bit special (not used, bypass is used instead) */
 154     { 0, 0 },
 155
 156     /* 277 -> 307 */
 157     { -6, 93 },  { -6, 84 },  { -8, 79 },    { 0, 66 },
 158     { -1, 71 },  { 0, 62 },   { -2, 60 },    { -2, 59 },
 159     { -5, 75 },  { -3, 62 },  { -4, 58 },    { -9, 66 },
 160     { -1, 79 },  { 0, 71 },   { 3, 68 },     { 10, 44 },
 161     { -7, 62 },  { 15, 36 },  { 14, 40 },    { 16, 27 },
 162     { 12, 29 },  { 1, 44 },   { 20, 36 },    { 18, 32 },
 163     { 5, 42 },   { 1, 48 },   { 10, 62 },    { 17, 46 },
 164     { 9, 64 },   { -12, 104 },{ -11, 97 },
 165
 166     /* 308 -> 337 */
 167     { -16, 96 }, { -7, 88 },  { -8, 85 },    { -7, 85 },
 168     { -9, 85 },  { -13, 88 }, { 4, 66 },     { -3, 77 },
 169     { -3, 76 },  { -6, 76 },  { 10, 58 },    { -1, 76 },
 170     { -1, 83 },  { -7, 99 },  { -14, 95 },   { 2, 95 },
 171     { 0, 76 },   { -5, 74 },  { 0, 70 },     { -11, 75 },
 172     { 1, 68 },   { 0, 65 },   { -14, 73 },   { 3, 62 },
 173     { 4, 62 },   { -1, 68 },  { -13, 75 },   { 11, 55 },
 174     { 5, 64 },   { 12, 70 },
 175
 176     /* 338 -> 368 */
 177     { 15, 6 },   { 6, 19 },   { 7, 16 },     { 12, 14 },
 178     { 18, 13 },  { 13, 11 },  { 13, 15 },    { 15, 16 },
 179     { 12, 23 },  { 13, 23 },  { 15, 20 },    { 14, 26 },
 180     { 14, 44 },  { 17, 40 },  { 17, 47 },    { 24, 17 },
 181     { 21, 21 },  { 25, 22 },  { 31, 27 },    { 22, 29 },
 182     { 19, 35 },  { 14, 50 },  { 10, 57 },    { 7, 63 },
 183     { -2, 77 },  { -4, 82 },  { -3, 94 },    { 9, 69 },
 184     { -12, 109 },{ 36, -35 }, { 36, -34 },
 185
 186     /* 369 -> 398 */
 187     { 32, -26 }, { 37, -30 }, { 44, -32 },   { 34, -18 },
 188     { 34, -15 }, { 40, -15 }, { 33, -7 },    { 35, -5 },
 189     { 33, 0 },   { 38, 2 },   { 33, 13 },    { 23, 35 },
 190     { 13, 58 },  { 29, -3 },  { 26, 0 },     { 22, 30 },
 191     { 31, -7 },  { 35, -15 }, { 34, -3 },    { 34, 3 },
 192     { 36, -1 },  { 34, 5 },   { 32, 11 },    { 35, 5 },
 193     { 34, 12 },  { 39, 11 },  { 30, 29 },    { 34, 26 },
 194     { 29, 39 },  { 19, 66 },
 195
 196     /* 399 -> 435 */
 197     {  31,  21 }, {  31,  31 }, {  25,  50 },
 198     { -17, 120 }, { -20, 112 }, { -18, 114 }, { -11,  85 },
 199     { -15,  92 }, { -14,  89 }, { -26,  71 }, { -15,  81 },
 200     { -14,  80 }, {   0,  68 }, { -14,  70 }, { -24,  56 },
 201     { -23,  68 }, { -24,  50 }, { -11,  74 }, {  23, -13 },
 202     {  26, -13 }, {  40, -15 }, {  49, -14 }, {  44,   3 },
 203     {  45,   6 }, {  44,  34 }, {  33,  54 }, {  19,  82 },
 204     {  -3,  75 }, {  -1,  23 }, {   1,  34 }, {   1,  43 },
 205     {   0,  54 }, {  -2,  55 }, {   0,  61 }, {   1,  64 },
 206     {   0,  68 }, {  -9,  92 },
 207
 208     /* 436 -> 459 */
 209     { -14, 106 }, { -13,  97 }, { -15,  90 }, { -12,  90 },
 210     { -18,  88 }, { -10,  73 }, {  -9,  79 }, { -14,  86 },
 211     { -10,  73 }, { -10,  70 }, { -10,  69 }, {  -5,  66 },
 212     {  -9,  64 }, {  -5,  58 }, {   2,  59 }, {  21, -10 },
 213     {  24, -11 }, {  28,  -8 }, {  28,  -1 }, {  29,   3 },
 214     {  29,   9 }, {  35,  20 }, {  29,  36 }, {  14,  67 }
 215 };
 216
 217 static const int8_t cabac_context_init_PB[3][460][2] =
 218 {
 219     /* i_cabac_init_idc == 0 */
 220     {
 221         /* 0 - 10 */
 222         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
 223         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
 224         {  -6,  53 }, {  -1,  54 }, {   7,  51 },
 225
 226         /* 11 - 23 */
 227         {  23,  33 }, {  23,   2 }, {  21,   0 }, {   1,   9 },
 228         {   0,  49 }, { -37, 118 }, {   5,  57 }, { -13,  78 },
 229         { -11,  65 }, {   1,  62 }, {  12,  49 }, {  -4,  73 },
 230         {  17,  50 },
 231
 232         /* 24 - 39 */
 233         {  18,  64 }, {   9,  43 }, {  29,   0 }, {  26,  67 },
 234         {  16,  90 }, {   9, 104 }, { -46, 127 }, { -20, 104 },
 235         {   1,  67 }, { -13,  78 }, { -11,  65 }, {   1,  62 },
 236         {  -6,  86 }, { -17,  95 }, {  -6,  61 }, {   9,  45 },
 237
 238         /* 40 - 53 */
 239         {  -3,  69 }, {  -6,  81 }, { -11,  96 }, {   6,  55 },
 240         {   7,  67 }, {  -5,  86 }, {   2,  88 }, {   0,  58 },
 241         {  -3,  76 }, { -10,  94 }, {   5,  54 }, {   4,  69 },
 242         {  -3,  81 }, {   0,  88 },
 243
 244         /* 54 - 59 */
 245         {  -7,  67 }, {  -5,  74 }, {  -4,  74 }, {  -5,  80 },
 246         {  -7,  72 }, {   1,  58 },
 247
 248         /* 60 - 69 */
 249         {   0,  41 }, {   0,  63 }, {   0,  63 }, { 0, 63 },
 250         {  -9,  83 }, {   4,  86 }, {   0,  97 }, { -7, 72 },
 251         {  13,  41 }, {   3,  62 },
 252
 253         /* 70 - 87 */
 254         {   0,  45 }, {  -4,  78 }, {  -3,  96 }, { -27,  126 },
 255         { -28,  98 }, { -25, 101 }, { -23,  67 }, { -28,  82 },
 256         { -20,  94 }, { -16,  83 }, { -22, 110 }, { -21,  91 },
 257         { -18, 102 }, { -13,  93 }, { -29, 127 }, {  -7,  92 },
 258         {  -5,  89 }, {  -7,  96 }, { -13, 108 }, {  -3,  46 },
 259         {  -1,  65 }, {  -1,  57 }, {  -9,  93 }, {  -3,  74 },
 260         {  -9,  92 }, {  -8,  87 }, { -23, 126 }, {   5,  54 },
 261         {   6,  60 }, {   6,  59 }, {   6,  69 }, {  -1,  48 },
 262         {   0,  68 }, {  -4,  69 }, {  -8,  88 },
 263
 264         /* 105 -> 165 */
 265         {  -2,  85 }, {  -6,  78 }, {  -1,  75 }, {  -7,  77 },
 266         {   2,  54 }, {   5,  50 }, {  -3,  68 }, {   1,  50 },
 267         {   6,  42 }, {  -4,  81 }, {   1,  63 }, {  -4,  70 },
 268         {   0,  67 }, {   2,  57 }, {  -2,  76 }, {  11,  35 },
 269         {   4,  64 }, {   1,  61 }, {  11,  35 }, {  18,  25 },
 270         {  12,  24 }, {  13,  29 }, {  13,  36 }, { -10,  93 },
 271         {  -7,  73 }, {  -2,  73 }, {  13,  46 }, {   9,  49 },
 272         {  -7, 100 }, {   9,  53 }, {   2,  53 }, {   5,  53 },
 273         {  -2,  61 }, {   0,  56 }, {   0,  56 }, { -13,  63 },
 274         {  -5,  60 }, {  -1,  62 }, {   4,  57 }, {  -6,  69 },
 275         {   4,  57 }, {  14,  39 }, {   4,  51 }, {  13,  68 },
 276         {   3,  64 }, {   1,  61 }, {   9,  63 }, {   7,  50 },
 277         {  16,  39 }, {   5,  44 }, {   4,  52 }, {  11,  48 },
 278         {  -5,  60 }, {  -1,  59 }, {   0,  59 }, {  22,  33 },
 279         {   5,  44 }, {  14,  43 }, {  -1,  78 }, {   0,  60 },
 280         {   9,  69 },
 281
 282         /* 166 - 226 */
 283         {  11,  28 }, {   2,  40 }, {   3,  44 }, {   0,  49 },
 284         {   0,  46 }, {   2,  44 }, {   2,  51 }, {   0,  47 },
 285         {   4,  39 }, {   2,  62 }, {   6,  46 }, {   0,  54 },
 286         {   3,  54 }, {   2,  58 }, {   4,  63 }, {   6,  51 },
 287         {   6,  57 }, {   7,  53 }, {   6,  52 }, {   6,  55 },
 288         {  11,  45 }, {  14,  36 }, {   8,  53 }, {  -1,  82 },
 289         {   7,  55 }, {  -3,  78 }, {  15,  46 }, {  22,  31 },
 290         {  -1,  84 }, {  25,   7 }, {  30,  -7 }, {  28,   3 },
 291         {  28,   4 }, {  32,   0 }, {  34,  -1 }, {  30,   6 },
 292         {  30,   6 }, {  32,   9 }, {  31,  19 }, {  26,  27 },
 293         {  26,  30 }, {  37,  20 }, {  28,  34 }, {  17,  70 },
 294         {   1,  67 }, {   5,  59 }, {   9,  67 }, {  16,  30 },
 295         {  18,  32 }, {  18,  35 }, {  22,  29 }, {  24,  31 },
 296         {  23,  38 }, {  18,  43 }, {  20,  41 }, {  11,  63 },
 297         {   9,  59 }, {   9,  64 }, {  -1,  94 }, {  -2,  89 },
 298         {  -9, 108 },
 299
 300         /* 227 - 275 */
 301         {  -6,  76 }, {  -2,  44 }, {   0,  45 }, {   0,  52 },
 302         {  -3,  64 }, {  -2,  59 }, {  -4,  70 }, {  -4,  75 },
 303         {  -8,  82 }, { -17, 102 }, {  -9,  77 }, {   3,  24 },
 304         {   0,  42 }, {   0,  48 }, {   0,  55 }, {  -6,  59 },
 305         {  -7,  71 }, { -12,  83 }, { -11,  87 }, { -30, 119 },
 306         {   1,  58 }, {  -3,  29 }, {  -1,  36 }, {   1,  38 },
 307         {   2,  43 }, {  -6,  55 }, {   0,  58 }, {   0,  64 },
 308         {  -3,  74 }, { -10,  90 }, {   0,  70 }, {  -4,  29 },
 309         {   5,  31 }, {   7,  42 }, {   1,  59 }, {  -2,  58 },
 310         {  -3,  72 }, {  -3,  81 }, { -11,  97 }, {   0,  58 },
 311         {   8,   5 }, {  10,  14 }, {  14,  18 }, {  13,  27 },
 312         {   2,  40 }, {   0,  58 }, {  -3,  70 }, {  -6,  79 },
 313         {  -8,  85 },
 314
 315         /* 276 a bit special (not used, bypass is used instead) */
 316         { 0, 0 },
 317
 318         /* 277 - 337 */
 319         { -13, 106 }, { -16, 106 }, { -10,  87 }, { -21, 114 },
 320         { -18, 110 }, { -14,  98 }, { -22, 110 }, { -21, 106 },
 321         { -18, 103 }, { -21, 107 }, { -23, 108 }, { -26, 112 },
 322         { -10,  96 }, { -12,  95 }, {  -5,  91 }, {  -9,  93 },
 323         { -22,  94 }, {  -5,  86 }, {   9,  67 }, {  -4,  80 },
 324         { -10,  85 }, {  -1,  70 }, {   7,  60 }, {   9,  58 },
 325         {   5,  61 }, {  12,  50 }, {  15,  50 }, {  18,  49 },
 326         {  17,  54 }, {  10,  41 }, {   7,  46 }, {  -1,  51 },
 327         {   7,  49 }, {   8,  52 }, {   9,  41 }, {   6,  47 },
 328         {   2,  55 }, {  13,  41 }, {  10,  44 }, {   6,  50 },
 329         {   5,  53 }, {  13,  49 }, {   4,  63 }, {   6,  64 },
 330         {  -2,  69 }, {  -2,  59 }, {   6,  70 }, {  10,  44 },
 331         {   9,  31 }, {  12,  43 }, {   3,  53 }, {  14,  34 },
 332         {  10,  38 }, {  -3,  52 }, {  13,  40 }, {  17,  32 },
 333         {   7,  44 }, {   7,  38 }, {  13,  50 }, {  10,  57 },
 334         {  26,  43 },
 335
 336         /* 338 - 398 */
 337         {  14,  11 }, {  11,  14 }, {   9,  11 }, {  18,  11 },
 338         {  21,   9 }, {  23,  -2 }, {  32, -15 }, {  32, -15 },
 339         {  34, -21 }, {  39, -23 }, {  42, -33 }, {  41, -31 },
 340         {  46, -28 }, {  38, -12 }, {  21,  29 }, {  45, -24 },
 341         {  53, -45 }, {  48, -26 }, {  65, -43 }, {  43, -19 },
 342         {  39, -10 }, {  30,   9 }, {  18,  26 }, {  20,  27 },
 343         {   0,  57 }, { -14,  82 }, {  -5,  75 }, { -19,  97 },
 344         { -35, 125 }, {  27,   0 }, {  28,   0 }, {  31,  -4 },
 345         {  27,   6 }, {  34,   8 }, {  30,  10 }, {  24,  22 },
 346         {  33,  19 }, {  22,  32 }, {  26,  31 }, {  21,  41 },
 347         {  26,  44 }, {  23,  47 }, {  16,  65 }, {  14,  71 },
 348         {   8,  60 }, {   6,  63 }, {  17,  65 }, {  21,  24 },
 349         {  23,  20 }, {  26,  23 }, {  27,  32 }, {  28,  23 },
 350         {  28,  24 }, {  23,  40 }, {  24,  32 }, {  28,  29 },
 351         {  23,  42 }, {  19,  57 }, {  22,  53 }, {  22,  61 },
 352         {  11,  86 },
 353
 354         /* 399 - 435 */
 355         {  12,  40 }, {  11,  51 }, {  14,  59 },
 356         {  -4,  79 }, {  -7,  71 }, {  -5,  69 }, {  -9,  70 },
 357         {  -8,  66 }, { -10,  68 }, { -19,  73 }, { -12,  69 },
 358         { -16,  70 }, { -15,  67 }, { -20,  62 }, { -19,  70 },
 359         { -16,  66 }, { -22,  65 }, { -20,  63 }, {   9,  -2 },
 360         {  26,  -9 }, {  33,  -9 }, {  39,  -7 }, {  41,  -2 },
 361         {  45,   3 }, {  49,   9 }, {  45,  27 }, {  36,  59 },
 362         {  -6,  66 }, {  -7,  35 }, {  -7,  42 }, {  -8,  45 },
 363         {  -5,  48 }, { -12,  56 }, {  -6,  60 }, {  -5,  62 },
 364         {  -8,  66 }, {  -8,  76 },
 365
 366         /* 436 - 459 */
 367         {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },
 368         { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },
 369         {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },
 370         { -14,  66 }, {   0,  59 }, {   2,  59 }, {  21, -13 },
 371         {  33, -14 }, {  39,  -7 }, {  46,  -2 }, {  51,   2 },
 372         {  60,   6 }, {  61,  17 }, {  55,  34 }, {  42,  62 },
 373     },
 374
 375     /* i_cabac_init_idc == 1 */
 376     {
 377         /* 0 - 10 */
 378         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
 379         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
 380         {  -6,  53 }, {  -1,  54 }, {   7,  51 },
 381
 382         /* 11 - 23 */
 383         {  22,  25 }, {  34,   0 }, {  16,   0 }, {  -2,   9 },
 384         {   4,  41 }, { -29, 118 }, {   2,  65 }, {  -6,  71 },
 385         { -13,  79 }, {   5,  52 }, {   9,  50 }, {  -3,  70 },
 386         {  10,  54 },
 387
 388         /* 24 - 39 */
 389         {  26,  34 }, {  19,  22 }, {  40,   0 }, {  57,   2 },
 390         {  41,  36 }, {  26,  69 }, { -45, 127 }, { -15, 101 },
 391         {  -4,  76 }, {  -6,  71 }, { -13,  79 }, {   5,  52 },
 392         {   6,  69 }, { -13,  90 }, {   0,  52 }, {   8,  43 },
 393
 394         /* 40 - 53 */
 395         {  -2,  69 },{  -5,  82 },{ -10,  96 },{   2,  59 },
 396         {   2,  75 },{  -3,  87 },{  -3,  100 },{   1,  56 },
 397         {  -3,  74 },{  -6,  85 },{   0,  59 },{  -3,  81 },
 398         {  -7,  86 },{  -5,  95 },
 399
 400         /* 54 - 59 */
 401         {  -1,  66 },{  -1,  77 },{   1,  70 },{  -2,  86 },
 402         {  -5,  72 },{   0,  61 },
 403
 404         /* 60 - 69 */
 405         { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
 406         { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
 407         { 13, 41 },  { 3, 62 },
 408
 409         /* 70 - 104 */
 410         {  13,  15 }, {   7,  51 }, {   2,  80 }, { -39, 127 },
 411         { -18,  91 }, { -17,  96 }, { -26,  81 }, { -35,  98 },
 412         { -24, 102 }, { -23,  97 }, { -27, 119 }, { -24,  99 },
 413         { -21, 110 }, { -18, 102 }, { -36, 127 }, {   0,  80 },
 414         {  -5,  89 }, {  -7,  94 }, {  -4,  92 }, {   0,  39 },
 415         {   0,  65 }, { -15,  84 }, { -35, 127 }, {  -2,  73 },
 416         { -12, 104 }, {  -9,  91 }, { -31, 127 }, {   3,  55 },
 417         {   7,  56 }, {   7,  55 }, {   8,  61 }, {  -3,  53 },
 418         {   0,  68 }, {  -7,  74 }, {  -9,  88 },
 419
 420         /* 105 -> 165 */
 421         { -13, 103 }, { -13,  91 }, {  -9,  89 }, { -14,  92 },
 422         {  -8,  76 }, { -12,  87 }, { -23, 110 }, { -24, 105 },
 423         { -10,  78 }, { -20, 112 }, { -17,  99 }, { -78, 127 },
 424         { -70, 127 }, { -50, 127 }, { -46, 127 }, {  -4,  66 },
 425         {  -5,  78 }, {  -4,  71 }, {  -8,  72 }, {   2,  59 },
 426         {  -1,  55 }, {  -7,  70 }, {  -6,  75 }, {  -8,  89 },
 427         { -34, 119 }, {  -3,  75 }, {  32,  20 }, {  30,  22 },
 428         { -44, 127 }, {   0,  54 }, {  -5,  61 }, {   0,  58 },
 429         {  -1,  60 }, {  -3,  61 }, {  -8,  67 }, { -25,  84 },
 430         { -14,  74 }, {  -5,  65 }, {   5,  52 }, {   2,  57 },
 431         {   0,  61 }, {  -9,  69 }, { -11,  70 }, {  18,  55 },
 432         {  -4,  71 }, {   0,  58 }, {   7,  61 }, {   9,  41 },
 433         {  18,  25 }, {   9,  32 }, {   5,  43 }, {   9,  47 },
 434         {   0,  44 }, {   0,  51 }, {   2,  46 }, {  19,  38 },
 435         {  -4,  66 }, {  15,  38 }, {  12,  42 }, {   9,  34 },
 436         {   0,  89 },
 437
 438         /* 166 - 226 */
 439         {   4,  45 }, {  10,  28 }, {  10,  31 }, {  33, -11 },
 440         {  52, -43 }, {  18,  15 }, {  28,   0 }, {  35, -22 },
 441         {  38, -25 }, {  34,   0 }, {  39, -18 }, {  32, -12 },
 442         { 102, -94 }, {   0,   0 }, {  56, -15 }, {  33,  -4 },
 443         {  29,  10 }, {  37,  -5 }, {  51, -29 }, {  39,  -9 },
 444         {  52, -34 }, {  69, -58 }, {  67, -63 }, {  44,  -5 },
 445         {  32,   7 }, {  55, -29 }, {  32,   1 }, {   0,   0 },
 446         {  27,  36 }, {  33, -25 }, {  34, -30 }, {  36, -28 },
 447         {  38, -28 }, {  38, -27 }, {  34, -18 }, {  35, -16 },
 448         {  34, -14 }, {  32,  -8 }, {  37,  -6 }, {  35,   0 },
 449         {  30,  10 }, {  28,  18 }, {  26,  25 }, {  29,  41 },
 450         {   0,  75 }, {   2,  72 }, {   8,  77 }, {  14,  35 },
 451         {  18,  31 }, {  17,  35 }, {  21,  30 }, {  17,  45 },
 452         {  20,  42 }, {  18,  45 }, {  27,  26 }, {  16,  54 },
 453         {   7,  66 }, {  16,  56 }, {  11,  73 }, {  10,  67 },
 454         { -10, 116 },
 455
 456         /* 227 - 275 */
 457         { -23, 112 }, { -15,  71 }, {  -7,  61 }, {   0,  53 },
 458         {  -5,  66 }, { -11,  77 }, {  -9,  80 }, {  -9,  84 },
 459         { -10,  87 }, { -34, 127 }, { -21, 101 }, {  -3,  39 },
 460         {  -5,  53 }, {  -7,  61 }, { -11,  75 }, { -15,  77 },
 461         { -17,  91 }, { -25, 107 }, { -25, 111 }, { -28, 122 },
 462         { -11,  76 }, { -10,  44 }, { -10,  52 }, { -10,  57 },
 463         {  -9,  58 }, { -16,  72 }, {  -7,  69 }, {  -4,  69 },
 464         {  -5,  74 }, {  -9,  86 }, {   2,  66 }, {  -9,  34 },
 465         {   1,  32 }, {  11,  31 }, {   5,  52 }, {  -2,  55 },
 466         {  -2,  67 }, {   0,  73 }, {  -8,  89 }, {   3,  52 },
 467         {   7,   4 }, {  10,   8 }, {  17,   8 }, {  16,  19 },
 468         {   3,  37 }, {  -1,  61 }, {  -5,  73 }, {  -1,  70 },
 469         {  -4,  78 },
 470
 471         /* 276 a bit special (not used, bypass is used instead) */
 472         { 0, 0 },
 473
 474         /* 277 - 337 */
 475         { -21, 126 }, { -23, 124 }, { -20, 110 }, { -26, 126 },
 476         { -25, 124 }, { -17, 105 }, { -27, 121 }, { -27, 117 },
 477         { -17, 102 }, { -26, 117 }, { -27, 116 }, { -33, 122 },
 478         { -10,  95 }, { -14, 100 }, {  -8,  95 }, { -17, 111 },
 479         { -28, 114 }, {  -6,  89 }, {  -2,  80 }, {  -4,  82 },
 480         {  -9,  85 }, {  -8,  81 }, {  -1,  72 }, {   5,  64 },
 481         {   1,  67 }, {   9,  56 }, {   0,  69 }, {   1,  69 },
 482         {   7,  69 }, {  -7,  69 }, {  -6,  67 }, { -16,  77 },
 483         {  -2,  64 }, {   2,  61 }, {  -6,  67 }, {  -3,  64 },
 484         {   2,  57 }, {  -3,  65 }, {  -3,  66 }, {   0,  62 },
 485         {   9,  51 }, {  -1,  66 }, {  -2,  71 }, {  -2,  75 },
 486         {  -1,  70 }, {  -9,  72 }, {  14,  60 }, {  16,  37 },
 487         {   0,  47 }, {  18,  35 }, {  11,  37 }, {  12,  41 },
 488         {  10,  41 }, {   2,  48 }, {  12,  41 }, {  13,  41 },
 489         {   0,  59 }, {   3,  50 }, {  19,  40 }, {   3,  66 },
 490         {  18,  50 },
 491
 492         /* 338 - 398 */
 493         {  19,  -6 }, {  18,  -6 }, {  14,   0 }, {  26, -12 },
 494         {  31, -16 }, {  33, -25 }, {  33, -22 }, {  37, -28 },
 495         {  39, -30 }, {  42, -30 }, {  47, -42 }, {  45, -36 },
 496         {  49, -34 }, {  41, -17 }, {  32,   9 }, {  69, -71 },
 497         {  63, -63 }, {  66, -64 }, {  77, -74 }, {  54, -39 },
 498         {  52, -35 }, {  41, -10 }, {  36,   0 }, {  40,  -1 },
 499         {  30,  14 }, {  28,  26 }, {  23,  37 }, {  12,  55 },
 500         {  11,  65 }, {  37, -33 }, {  39, -36 }, {  40, -37 },
 501         {  38, -30 }, {  46, -33 }, {  42, -30 }, {  40, -24 },
 502         {  49, -29 }, {  38, -12 }, {  40, -10 }, {  38,  -3 },
 503         {  46,  -5 }, {  31,  20 }, {  29,  30 }, {  25,  44 },
 504         {  12,  48 }, {  11,  49 }, {  26,  45 }, {  22,  22 },
 505         {  23,  22 }, {  27,  21 }, {  33,  20 }, {  26,  28 },
 506         {  30,  24 }, {  27,  34 }, {  18,  42 }, {  25,  39 },
 507         {  18,  50 }, {  12,  70 }, {  21,  54 }, {  14,  71 },
 508         {  11,  83 },
 509
 510         /* 399 - 435 */
 511         {  25,  32 }, {  21,  49 }, {  21,  54 },
 512         {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },
 513         { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },
 514         {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },
 515         { -14,  66 }, {   0,  59 }, {   2,  59 }, {  17, -10 },
 516         {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },
 517         {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },
 518         {  -5,  71 }, {   0,  24 }, {  -1,  36 }, {  -2,  42 },
 519         {  -2,  52 }, {  -9,  57 }, {  -6,  63 }, {  -4,  65 },
 520         {  -4,  67 }, {  -7,  82 },
 521
 522         /* 436 - 459 */
 523         {  -3,  81 }, {  -3,  76 }, {  -7,  72 }, {  -6,  78 },
 524         { -12,  72 }, { -14,  68 }, {  -3,  70 }, {  -6,  76 },
 525         {  -5,  66 }, {  -5,  62 }, {   0,  57 }, {  -4,  61 },
 526         {  -9,  60 }, {   1,  54 }, {   2,  58 }, {  17, -10 },
 527         {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },
 528         {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },
 529     },
 530
 531     /* i_cabac_init_idc == 2 */
 532     {
 533         /* 0 - 10 */
 534         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
 535         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
 536         {  -6,  53 }, {  -1,  54 }, {   7,  51 },
 537
 538         /* 11 - 23 */
 539         {  29,  16 }, {  25,   0 }, {  14,   0 }, { -10,  51 },
 540         {  -3,  62 }, { -27,  99 }, {  26,  16 }, {  -4,  85 },
 541         { -24, 102 }, {   5,  57 }, {   6,  57 }, { -17,  73 },
 542         {  14,  57 },
 543
 544         /* 24 - 39 */
 545         {  20,  40 }, {  20,  10 }, {  29,   0 }, {  54,   0 },
 546         {  37,  42 }, {  12,  97 }, { -32, 127 }, { -22, 117 },
 547         {  -2,  74 }, {  -4,  85 }, { -24, 102 }, {   5,  57 },
 548         {  -6,  93 }, { -14,  88 }, {  -6,  44 }, {   4,  55 },
 549
 550         /* 40 - 53 */
 551         { -11,  89 },{ -15,  103 },{ -21,  116 },{  19,  57 },
 552         {  20,  58 },{   4,  84 },{   6,  96 },{   1,  63 },
 553         {  -5,  85 },{ -13,  106 },{   5,  63 },{   6,  75 },
 554         {  -3,  90 },{  -1,  101 },
 555
 556         /* 54 - 59 */
 557         {   3,  55 },{  -4,  79 },{  -2,  75 },{ -12,  97 },
 558         {  -7,  50 },{   1,  60 },
 559
 560         /* 60 - 69 */
 561         { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
 562         { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
 563         { 13, 41 },  { 3, 62 },
 564
 565         /* 70 - 104 */
 566         {   7,  34 }, {  -9,  88 }, { -20, 127 }, { -36, 127 },
 567         { -17,  91 }, { -14,  95 }, { -25,  84 }, { -25,  86 },
 568         { -12,  89 }, { -17,  91 }, { -31, 127 }, { -14,  76 },
 569         { -18, 103 }, { -13,  90 }, { -37, 127 }, {  11,  80 },
 570         {   5,  76 }, {   2,  84 }, {   5,  78 }, {  -6,  55 },
 571         {   4,  61 }, { -14,  83 }, { -37, 127 }, {  -5,  79 },
 572         { -11, 104 }, { -11,  91 }, { -30, 127 }, {   0,  65 },
 573         {  -2,  79 }, {   0,  72 }, {  -4,  92 }, {  -6,  56 },
 574         {   3,  68 }, {  -8,  71 }, { -13,  98 },
 575
 576         /* 105 -> 165 */
 577         {  -4,  86 }, { -12,  88 }, {  -5,  82 }, {  -3,  72 },
 578         {  -4,  67 }, {  -8,  72 }, { -16,  89 }, {  -9,  69 },
 579         {  -1,  59 }, {   5,  66 }, {   4,  57 }, {  -4,  71 },
 580         {  -2,  71 }, {   2,  58 }, {  -1,  74 }, {  -4,  44 },
 581         {  -1,  69 }, {   0,  62 }, {  -7,  51 }, {  -4,  47 },
 582         {  -6,  42 }, {  -3,  41 }, {  -6,  53 }, {   8,  76 },
 583         {  -9,  78 }, { -11,  83 }, {   9,  52 }, {   0,  67 },
 584         {  -5,  90 }, {   1,  67 }, { -15,  72 }, {  -5,  75 },
 585         {  -8,  80 }, { -21,  83 }, { -21,  64 }, { -13,  31 },
 586         { -25,  64 }, { -29,  94 }, {   9,  75 }, {  17,  63 },
 587         {  -8,  74 }, {  -5,  35 }, {  -2,  27 }, {  13,  91 },
 588         {   3,  65 }, {  -7,  69 }, {   8,  77 }, { -10,  66 },
 589         {   3,  62 }, {  -3,  68 }, { -20,  81 }, {   0,  30 },
 590         {   1,   7 }, {  -3,  23 }, { -21,  74 }, {  16,  66 },
 591         { -23, 124 }, {  17,  37 }, {  44, -18 }, {  50, -34 },
 592         { -22, 127 },
 593
 594         /* 166 - 226 */
 595         {   4,  39 }, {   0,  42 }, {   7,  34 }, {  11,  29 },
 596         {   8,  31 }, {   6,  37 }, {   7,  42 }, {   3,  40 },
 597         {   8,  33 }, {  13,  43 }, {  13,  36 }, {   4,  47 },
 598         {   3,  55 }, {   2,  58 }, {   6,  60 }, {   8,  44 },
 599         {  11,  44 }, {  14,  42 }, {   7,  48 }, {   4,  56 },
 600         {   4,  52 }, {  13,  37 }, {   9,  49 }, {  19,  58 },
 601         {  10,  48 }, {  12,  45 }, {   0,  69 }, {  20,  33 },
 602         {   8,  63 }, {  35, -18 }, {  33, -25 }, {  28,  -3 },
 603         {  24,  10 }, {  27,   0 }, {  34, -14 }, {  52, -44 },
 604         {  39, -24 }, {  19,  17 }, {  31,  25 }, {  36,  29 },
 605         {  24,  33 }, {  34,  15 }, {  30,  20 }, {  22,  73 },
 606         {  20,  34 }, {  19,  31 }, {  27,  44 }, {  19,  16 },
 607         {  15,  36 }, {  15,  36 }, {  21,  28 }, {  25,  21 },
 608         {  30,  20 }, {  31,  12 }, {  27,  16 }, {  24,  42 },
 609         {   0,  93 }, {  14,  56 }, {  15,  57 }, {  26,  38 },
 610         { -24, 127 },
 611
 612         /* 227 - 275 */
 613         { -24, 115 }, { -22,  82 }, {  -9,  62 }, {   0,  53 },
 614         {   0,  59 }, { -14,  85 }, { -13,  89 }, { -13,  94 },
 615         { -11,  92 }, { -29, 127 }, { -21, 100 }, { -14,  57 },
 616         { -12,  67 }, { -11,  71 }, { -10,  77 }, { -21,  85 },
 617         { -16,  88 }, { -23, 104 }, { -15,  98 }, { -37, 127 },
 618         { -10,  82 }, {  -8,  48 }, {  -8,  61 }, {  -8,  66 },
 619         {  -7,  70 }, { -14,  75 }, { -10,  79 }, {  -9,  83 },
 620         { -12,  92 }, { -18, 108 }, {  -4,  79 }, { -22,  69 },
 621         { -16,  75 }, {  -2,  58 }, {   1,  58 }, { -13,  78 },
 622         {  -9,  83 }, {  -4,  81 }, { -13,  99 }, { -13,  81 },
 623         {  -6,  38 }, { -13,  62 }, {  -6,  58 }, {  -2,  59 },
 624         { -16,  73 }, { -10,  76 }, { -13,  86 }, {  -9,  83 },
 625         { -10,  87 },
 626
 627         /* 276 a bit special (not used, bypass is used instead) */
 628         { 0, 0 },
 629
 630         /* 277 - 337 */
 631         { -22, 127 }, { -25, 127 }, { -25, 120 }, { -27, 127 },
 632         { -19, 114 }, { -23, 117 }, { -25, 118 }, { -26, 117 },
 633         { -24, 113 }, { -28, 118 }, { -31, 120 }, { -37, 124 },
 634         { -10,  94 }, { -15, 102 }, { -10,  99 }, { -13, 106 },
 635         { -50, 127 }, {  -5,  92 }, {  17,  57 }, {  -5,  86 },
 636         { -13,  94 }, { -12,  91 }, {  -2,  77 }, {   0,  71 },
 637         {  -1,  73 }, {   4,  64 }, {  -7,  81 }, {   5,  64 },
 638         {  15,  57 }, {   1,  67 }, {   0,  68 }, { -10,  67 },
 639         {   1,  68 }, {   0,  77 }, {   2,  64 }, {   0,  68 },
 640         {  -5,  78 }, {   7,  55 }, {   5,  59 }, {   2,  65 },
 641         {  14,  54 }, {  15,  44 }, {   5,  60 }, {   2,  70 },
 642         {  -2,  76 }, { -18,  86 }, {  12,  70 }, {   5,  64 },
 643         { -12,  70 }, {  11,  55 }, {   5,  56 }, {   0,  69 },
 644         {   2,  65 }, {  -6,  74 }, {   5,  54 }, {   7,  54 },
 645         {  -6,  76 }, { -11,  82 }, {  -2,  77 }, {  -2,  77 },
 646         {  25,  42 },
 647
 648         /* 338 - 398 */
 649         {  17, -13 }, {  16,  -9 }, {  17, -12 }, {  27, -21 },
 650         {  37, -30 }, {  41, -40 }, {  42, -41 }, {  48, -47 },
 651         {  39, -32 }, {  46, -40 }, {  52, -51 }, {  46, -41 },
 652         {  52, -39 }, {  43, -19 }, {  32,  11 }, {  61, -55 },
 653         {  56, -46 }, {  62, -50 }, {  81, -67 }, {  45, -20 },
 654         {  35,  -2 }, {  28,  15 }, {  34,   1 }, {  39,   1 },
 655         {  30,  17 }, {  20,  38 }, {  18,  45 }, {  15,  54 },
 656         {   0,  79 }, {  36, -16 }, {  37, -14 }, {  37, -17 },
 657         {  32,   1 }, {  34,  15 }, {  29,  15 }, {  24,  25 },
 658         {  34,  22 }, {  31,  16 }, {  35,  18 }, {  31,  28 },
 659         {  33,  41 }, {  36,  28 }, {  27,  47 }, {  21,  62 },
 660         {  18,  31 }, {  19,  26 }, {  36,  24 }, {  24,  23 },
 661         {  27,  16 }, {  24,  30 }, {  31,  29 }, {  22,  41 },
 662         {  22,  42 }, {  16,  60 }, {  15,  52 }, {  14,  60 },
 663         {   3,  78 }, { -16, 123 }, {  21,  53 }, {  22,  56 },
 664         {  25,  61 },
 665
 666         /* 399 - 435 */
 667         {  21,  33 }, {  19,  50 }, {  17,  61 },
 668         {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },
 669         { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },
 670         { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },
 671         { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },
 672         {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },
 673         {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },
 674         {  -9,  71 }, {  -7,  37 }, {  -8,  44 }, { -11,  49 },
 675         { -10,  56 }, { -12,  59 }, {  -8,  63 }, {  -9,  67 },
 676         {  -6,  68 }, { -10,  79 },
 677
 678         /* 436 - 459 */
 679         {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },
 680         { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },
 681         { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },
 682         { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },
 683         {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },
 684         {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },
 685     }
 686 };
 687
 688 void ff_h264_init_cabac_states(H264Context *h) {
 689     MpegEncContext * const s = &h->s;
 690     int i;
 691     const int8_t (*tab)[2];
 692
 693     if( h->slice_type_nos == FF_I_TYPE ) tab = cabac_context_init_I;
 694     else                                 tab = cabac_context_init_PB[h->cabac_init_idc];
 695
 696     /* calculate pre-state */
 697     for( i= 0; i < 460; i++ ) {
 698         int pre = 2*(((tab[i][0] * s->qscale) >>4 ) + tab[i][1]) - 127;
 699
 700         pre^= pre>>31;
 701         if(pre > 124)
 702             pre= 124 + (pre&1);
 703
 704         h->cabac_state[i] =  pre;
 705     }
 706 }
 707
 708 static int decode_cabac_field_decoding_flag(H264Context *h) {
 709     MpegEncContext * const s = &h->s;
 710     const long mbb_xy = h->mb_xy - 2L*s->mb_stride;
 711
 712     unsigned long ctx = 0;
 713
 714     ctx += h->mb_field_decoding_flag & !!s->mb_x; //for FMO:(s->current_picture.mb_type[mba_xy]>>7)&(h->slice_table[mba_xy] == h->slice_num);
 715     ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num);
 716
 717     return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
 718 }
 719
 720 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
 721     uint8_t *state= &h->cabac_state[ctx_base];
 722     int mb_type;
 723
 724     if(intra_slice){
 725         int ctx=0;
 726         if( h->left_type[0] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
 727             ctx++;
 728         if( h->top_type     & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
 729             ctx++;
 730         if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
 731             return 0;   /* I4x4 */
 732         state += 2;
 733     }else{
 734         if( get_cabac_noinline( &h->cabac, state ) == 0 )
 735             return 0;   /* I4x4 */
 736     }
 737
 738     if( get_cabac_terminate( &h->cabac ) )
 739         return 25;  /* PCM */
 740
 741     mb_type = 1; /* I16x16 */
 742     mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
 743     if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
 744         mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
 745     mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
 746     mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
 747     return mb_type;
 748 }
 749
 750 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
 751     MpegEncContext * const s = &h->s;
 752     int mba_xy, mbb_xy;
 753     int ctx = 0;
 754
 755     if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
 756         int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
 757         mba_xy = mb_xy - 1;
 758         if( (mb_y&1)
 759             && h->slice_table[mba_xy] == h->slice_num
 760             && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
 761             mba_xy += s->mb_stride;
 762         if( MB_FIELD ){
 763             mbb_xy = mb_xy - s->mb_stride;
 764             if( !(mb_y&1)
 765                 && h->slice_table[mbb_xy] == h->slice_num
 766                 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
 767                 mbb_xy -= s->mb_stride;
 768         }else
 769             mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
 770     }else{
 771         int mb_xy = h->mb_xy;
 772         mba_xy = mb_xy - 1;
 773         mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
 774     }
 775
 776     if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
 777         ctx++;
 778     if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
 779         ctx++;
 780
 781     if( h->slice_type_nos == FF_B_TYPE )
 782         ctx += 13;
 783     return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
 784 }
 785
 786 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
 787     int mode = 0;
 788
 789     if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
 790         return pred_mode;
 791
 792     mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
 793     mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
 794     mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
 795
 796     return mode + ( mode >= pred_mode );
 797 }
 798
 799 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
 800     const int mba_xy = h->left_mb_xy[0];
 801     const int mbb_xy = h->top_mb_xy;
 802
 803     int ctx = 0;
 804
 805     /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
 806     if( h->left_type[0] && h->chroma_pred_mode_table[mba_xy] != 0 )
 807         ctx++;
 808
 809     if( h->top_type     && h->chroma_pred_mode_table[mbb_xy] != 0 )
 810         ctx++;
 811
 812     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
 813         return 0;
 814
 815     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
 816         return 1;
 817     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
 818         return 2;
 819     else
 820         return 3;
 821 }
 822
 823 static int decode_cabac_mb_cbp_luma( H264Context *h) {
 824     int cbp_b, cbp_a, ctx, cbp = 0;
 825
 826     cbp_a = h->left_cbp;
 827     cbp_b = h->top_cbp;
 828
 829     ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
 830     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
 831     ctx = !(cbp   & 0x01) + 2 * !(cbp_b & 0x08);
 832     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
 833     ctx = !(cbp_a & 0x08) + 2 * !(cbp   & 0x01);
 834     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
 835     ctx = !(cbp   & 0x04) + 2 * !(cbp   & 0x02);
 836     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
 837     return cbp;
 838 }
 839 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
 840     int ctx;
 841     int cbp_a, cbp_b;
 842
 843     cbp_a = (h->left_cbp>>4)&0x03;
 844     cbp_b = (h-> top_cbp>>4)&0x03;
 845
 846     ctx = 0;
 847     if( cbp_a > 0 ) ctx++;
 848     if( cbp_b > 0 ) ctx += 2;
 849     if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
 850         return 0;
 851
 852     ctx = 4;
 853     if( cbp_a == 2 ) ctx++;
 854     if( cbp_b == 2 ) ctx += 2;
 855     return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
 856 }
 857
 858 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
 859     if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
 860         return 0;   /* 8x8 */
 861     if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
 862         return 1;   /* 8x4 */
 863     if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
 864         return 2;   /* 4x8 */
 865     return 3;       /* 4x4 */
 866 }
 867 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
 868     int type;
 869     if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
 870         return 0;   /* B_Direct_8x8 */
 871     if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
 872         return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
 873     type = 3;
 874     if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
 875         if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
 876             return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
 877         type += 4;
 878     }
 879     type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
 880     type +=   get_cabac( &h->cabac, &h->cabac_state[39] );
 881     return type;
 882 }
 883
 884 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
 885     int refa = h->ref_cache[list][scan8[n] - 1];
 886     int refb = h->ref_cache[list][scan8[n] - 8];
 887     int ref  = 0;
 888     int ctx  = 0;
 889
 890     if( h->slice_type_nos == FF_B_TYPE) {
 891         if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
 892             ctx++;
 893         if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
 894             ctx += 2;
 895     } else {
 896         if( refa > 0 )
 897             ctx++;
 898         if( refb > 0 )
 899             ctx += 2;
 900     }
 901
 902     while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
 903         ref++;
 904         ctx = (ctx>>2)+4;
 905         if(ref >= 32 /*h->ref_list[list]*/){
 906             return -1;
 907         }
 908     }
 909     return ref;
 910 }
 911
 912 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
 913     int amvd = h->mvd_cache[list][scan8[n] - 1][l] +
 914                h->mvd_cache[list][scan8[n] - 8][l];
 915     int ctxbase = (l == 0) ? 40 : 47;
 916     int mvd;
 917
 918     if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2) + (amvd>32)]))
 919         return 0;
 920
 921     mvd= 1;
 922     ctxbase+= 3;
 923     while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) {
 924         if( mvd < 4 )
 925             ctxbase++;
 926         mvd++;
 927     }
 928
 929     if( mvd >= 9 ) {
 930         int k = 3;
 931         while( get_cabac_bypass( &h->cabac ) ) {
 932             mvd += 1 << k;
 933             k++;
 934             if(k>24){
 935                 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
 936                 return INT_MIN;
 937             }
 938         }
 939         while( k-- ) {
 940             mvd += get_cabac_bypass( &h->cabac )<<k;
 941         }
 942     }
 943     return get_cabac_bypass_sign( &h->cabac, -mvd );
 944 }
 945
 946 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
 947     int nza, nzb;
 948     int ctx = 0;
 949
 950     if( is_dc ) {
 951         if( cat == 0 ) {
 952             nza = h->left_cbp&0x100;
 953             nzb = h-> top_cbp&0x100;
 954         } else {
 955             nza = (h->left_cbp>>(6+idx))&0x01;
 956             nzb = (h-> top_cbp>>(6+idx))&0x01;
 957         }
 958     } else {
 959         assert(cat == 1 || cat == 2 || cat == 4);
 960         nza = h->non_zero_count_cache[scan8[idx] - 1];
 961         nzb = h->non_zero_count_cache[scan8[idx] - 8];
 962     }
 963
 964     if( nza > 0 )
 965         ctx++;
 966
 967     if( nzb > 0 )
 968         ctx += 2;
 969
 970     return ctx + 4 * cat;
 971 }
 972
 973 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
 974     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 975     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 976     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
 977     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
 978 };
 979
 980 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 ) {
 981     static const int significant_coeff_flag_offset[2][6] = {
 982       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
 983       { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
 984     };
 985     static const int last_coeff_flag_offset[2][6] = {
 986       { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
 987       { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
 988     };
 989     static const int coeff_abs_level_m1_offset[6] = {
 990         227+0, 227+10, 227+20, 227+30, 227+39, 426
 991     };
 992     static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
 993       { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
 994         4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
 995         7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
 996        12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
 997       { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
 998         6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
 999         9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1000         9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1001     };
1002     /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1003      * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1004      * map node ctx => cabac ctx for level=1 */
1005     static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1006     /* map node ctx => cabac ctx for level>1 */
1007     static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1008     static const uint8_t coeff_abs_level_transition[2][8] = {
1009     /* update node ctx after decoding a level=1 */
1010         { 1, 2, 3, 3, 4, 5, 6, 7 },
1011     /* update node ctx after decoding a level>1 */
1012         { 4, 4, 4, 4, 5, 6, 7, 7 }
1013     };
1014
1015     int index[64];
1016
1017     int av_unused last;
1018     int coeff_count = 0;
1019     int node_ctx = 0;
1020
1021     uint8_t *significant_coeff_ctx_base;
1022     uint8_t *last_coeff_ctx_base;
1023     uint8_t *abs_level_m1_ctx_base;
1024
1025 #if !ARCH_X86
1026 #define CABAC_ON_STACK
1027 #endif
1028 #ifdef CABAC_ON_STACK
1029 #define CC &cc
1030     CABACContext cc;
1031     cc.range     = h->cabac.range;
1032     cc.low       = h->cabac.low;
1033     cc.bytestream= h->cabac.bytestream;
1034 #else
1035 #define CC &h->cabac
1036 #endif
1037
1038
1039     /* cat: 0-> DC 16x16  n = 0
1040      *      1-> AC 16x16  n = luma4x4idx
1041      *      2-> Luma4x4   n = luma4x4idx
1042      *      3-> DC Chroma n = iCbCr
1043      *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1044      *      5-> Luma8x8   n = 4 * luma8x8idx
1045      */
1046
1047     /* read coded block flag */
1048     if( is_dc || cat != 5 ) {
1049         if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1050             if( !is_dc )
1051                 h->non_zero_count_cache[scan8[n]] = 0;
1052
1053 #ifdef CABAC_ON_STACK
1054             h->cabac.range     = cc.range     ;
1055             h->cabac.low       = cc.low       ;
1056             h->cabac.bytestream= cc.bytestream;
1057 #endif
1058             return;
1059         }
1060     }
1061
1062     significant_coeff_ctx_base = h->cabac_state
1063         + significant_coeff_flag_offset[MB_FIELD][cat];
1064     last_coeff_ctx_base = h->cabac_state
1065         + last_coeff_flag_offset[MB_FIELD][cat];
1066     abs_level_m1_ctx_base = h->cabac_state
1067         + coeff_abs_level_m1_offset[cat];
1068
1069     if( !is_dc && cat == 5 ) {
1070 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1071         for(last= 0; last < coefs; last++) { \
1072             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1073             if( get_cabac( CC, sig_ctx )) { \
1074                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1075                 index[coeff_count++] = last; \
1076                 if( get_cabac( CC, last_ctx ) ) { \
1077                     last= max_coeff; \
1078                     break; \
1079                 } \
1080             } \
1081         }\
1082         if( last == max_coeff -1 ) {\
1083             index[coeff_count++] = last;\
1084         }
1085         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1086 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1087         coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1088     } else {
1089         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1090 #else
1091         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1092     } else {
1093         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1094 #endif
1095     }
1096     assert(coeff_count > 0);
1097
1098     if( is_dc ) {
1099         if( cat == 0 )
1100             h->cbp_table[h->mb_xy] |= 0x100;
1101         else
1102             h->cbp_table[h->mb_xy] |= 0x40 << n;
1103     } else {
1104         if( cat == 5 )
1105             fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1106         else {
1107             assert( cat == 1 || cat == 2 || cat == 4 );
1108             h->non_zero_count_cache[scan8[n]] = coeff_count;
1109         }
1110     }
1111
1112     do {
1113         uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1114
1115         int j= scantable[index[--coeff_count]];
1116
1117         if( get_cabac( CC, ctx ) == 0 ) {
1118             node_ctx = coeff_abs_level_transition[0][node_ctx];
1119             if( is_dc ) {
1120                 block[j] = get_cabac_bypass_sign( CC, -1);
1121             }else{
1122                 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1123             }
1124         } else {
1125             int coeff_abs = 2;
1126             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1127             node_ctx = coeff_abs_level_transition[1][node_ctx];
1128
1129             while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1130                 coeff_abs++;
1131             }
1132
1133             if( coeff_abs >= 15 ) {
1134                 int j = 0;
1135                 while( get_cabac_bypass( CC ) ) {
1136                     j++;
1137                 }
1138
1139                 coeff_abs=1;
1140                 while( j-- ) {
1141                     coeff_abs += coeff_abs + get_cabac_bypass( CC );
1142                 }
1143                 coeff_abs+= 14;
1144             }
1145
1146             if( is_dc ) {
1147                 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1148             }else{
1149                 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1150             }
1151         }
1152     } while( coeff_count );
1153 #ifdef CABAC_ON_STACK
1154             h->cabac.range     = cc.range     ;
1155             h->cabac.low       = cc.low       ;
1156             h->cabac.bytestream= cc.bytestream;
1157 #endif
1158
1159 }
1160
1161 #if !CONFIG_SMALL
1162 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 ) {
1163     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1164 }
1165
1166 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 ) {
1167     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1168 }
1169 #endif
1170
1171 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1172 #if CONFIG_SMALL
1173     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1174 #else
1175     if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1176     else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1177 #endif
1178 }
1179
1180 /**
1181  * decodes a macroblock
1182  * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1183  */
1184 int ff_h264_decode_mb_cabac(H264Context *h) {
1185     MpegEncContext * const s = &h->s;
1186     int mb_xy;
1187     int mb_type, partition_count, cbp = 0;
1188     int dct8x8_allowed= h->pps.transform_8x8_mode;
1189
1190     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1191
1192     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1193     if( h->slice_type_nos != FF_I_TYPE ) {
1194         int skip;
1195         /* a skipped mb needs the aff flag from the following mb */
1196         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1197             skip = h->next_mb_skipped;
1198         else
1199             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1200         /* read skip flags */
1201         if( skip ) {
1202             if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1203                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1204                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1205                 if(!h->next_mb_skipped)
1206                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1207             }
1208
1209             decode_mb_skip(h);
1210
1211             h->cbp_table[mb_xy] = 0;
1212             h->chroma_pred_mode_table[mb_xy] = 0;
1213             h->last_qscale_diff = 0;
1214
1215             return 0;
1216
1217         }
1218     }
1219     if(FRAME_MBAFF){
1220         if( (s->mb_y&1) == 0 )
1221             h->mb_mbaff =
1222             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1223     }
1224
1225     h->prev_mb_skipped = 0;
1226
1227     fill_decode_neighbors(h, -(MB_FIELD));
1228
1229     if( h->slice_type_nos == FF_B_TYPE ) {
1230         int ctx = 0;
1231         assert(h->slice_type_nos == FF_B_TYPE);
1232
1233         if( !IS_DIRECT( h->left_type[0]-1 ) )
1234             ctx++;
1235         if( !IS_DIRECT( h->top_type-1 ) )
1236             ctx++;
1237
1238         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1239             mb_type= 0; /* B_Direct_16x16 */
1240         }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1241             mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1242         }else{
1243             int bits;
1244             bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1245             bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1246             bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1247             bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1248             if( bits < 8 ){
1249                 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1250             }else if( bits == 13 ){
1251                 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1252                 goto decode_intra_mb;
1253             }else if( bits == 14 ){
1254                 mb_type= 11; /* B_L1_L0_8x16 */
1255             }else if( bits == 15 ){
1256                 mb_type= 22; /* B_8x8 */
1257             }else{
1258                 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1259                 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1260             }
1261         }
1262             partition_count= b_mb_type_info[mb_type].partition_count;
1263             mb_type=         b_mb_type_info[mb_type].type;
1264     } else if( h->slice_type_nos == FF_P_TYPE ) {
1265         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1266             /* P-type */
1267             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1268                 /* P_L0_D16x16, P_8x8 */
1269                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1270             } else {
1271                 /* P_L0_D8x16, P_L0_D16x8 */
1272                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1273             }
1274             partition_count= p_mb_type_info[mb_type].partition_count;
1275             mb_type=         p_mb_type_info[mb_type].type;
1276         } else {
1277             mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1278             goto decode_intra_mb;
1279         }
1280     } else {
1281         mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1282         if(h->slice_type == FF_SI_TYPE && mb_type)
1283             mb_type--;
1284         assert(h->slice_type_nos == FF_I_TYPE);
1285 decode_intra_mb:
1286         partition_count = 0;
1287         cbp= i_mb_type_info[mb_type].cbp;
1288         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1289         mb_type= i_mb_type_info[mb_type].type;
1290     }
1291     if(MB_FIELD)
1292         mb_type |= MB_TYPE_INTERLACED;
1293
1294     h->slice_table[ mb_xy ]= h->slice_num;
1295
1296     if(IS_INTRA_PCM(mb_type)) {
1297         const uint8_t *ptr;
1298
1299         // We assume these blocks are very rare so we do not optimize it.
1300         // FIXME The two following lines get the bitstream position in the cabac
1301         // decode, I think it should be done by a function in cabac.h (or cabac.c).
1302         ptr= h->cabac.bytestream;
1303         if(h->cabac.low&0x1) ptr--;
1304         if(CABAC_BITS==16){
1305             if(h->cabac.low&0x1FF) ptr--;
1306         }
1307
1308         // The pixels are stored in the same order as levels in h->mb array.
1309         memcpy(h->mb, ptr, 256); ptr+=256;
1310         if(CHROMA){
1311             memcpy(h->mb+128, ptr, 128); ptr+=128;
1312         }
1313
1314         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1315
1316         // All blocks are present
1317         h->cbp_table[mb_xy] = 0x1ef;
1318         h->chroma_pred_mode_table[mb_xy] = 0;
1319         // In deblocking, the quantizer is 0
1320         s->current_picture.qscale_table[mb_xy]= 0;
1321         // All coeffs are present
1322         memset(h->non_zero_count[mb_xy], 16, 32);
1323         s->current_picture.mb_type[mb_xy]= mb_type;
1324         h->last_qscale_diff = 0;
1325         return 0;
1326     }
1327
1328     if(MB_MBAFF){
1329         h->ref_count[0] <<= 1;
1330         h->ref_count[1] <<= 1;
1331     }
1332
1333     fill_decode_caches(h, mb_type);
1334
1335     if( IS_INTRA( mb_type ) ) {
1336         int i, pred_mode;
1337         if( IS_INTRA4x4( mb_type ) ) {
1338             if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1339                 mb_type |= MB_TYPE_8x8DCT;
1340                 for( i = 0; i < 16; i+=4 ) {
1341                     int pred = pred_intra_mode( h, i );
1342                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1343                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1344                 }
1345             } else {
1346                 for( i = 0; i < 16; i++ ) {
1347                     int pred = pred_intra_mode( h, i );
1348                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1349
1350                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1351                 }
1352             }
1353             ff_h264_write_back_intra_pred_mode(h);
1354             if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1355         } else {
1356             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1357             if( h->intra16x16_pred_mode < 0 ) return -1;
1358         }
1359         if(CHROMA){
1360             h->chroma_pred_mode_table[mb_xy] =
1361             pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1362
1363             pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1364             if( pred_mode < 0 ) return -1;
1365             h->chroma_pred_mode= pred_mode;
1366         }
1367     } else if( partition_count == 4 ) {
1368         int i, j, sub_partition_count[4], list, ref[2][4];
1369
1370         if( h->slice_type_nos == FF_B_TYPE ) {
1371             for( i = 0; i < 4; i++ ) {
1372                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1373                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1374                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1375             }
1376             if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1377                           h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1378                 ff_h264_pred_direct_motion(h, &mb_type);
1379                 h->ref_cache[0][scan8[4]] =
1380                 h->ref_cache[1][scan8[4]] =
1381                 h->ref_cache[0][scan8[12]] =
1382                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1383                     for( i = 0; i < 4; i++ )
1384                         fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1385             }
1386         } else {
1387             for( i = 0; i < 4; i++ ) {
1388                 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1389                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1390                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1391             }
1392         }
1393
1394         for( list = 0; list < h->list_count; list++ ) {
1395                 for( i = 0; i < 4; i++ ) {
1396                     if(IS_DIRECT(h->sub_mb_type[i])) continue;
1397                     if(IS_DIR(h->sub_mb_type[i], 0, list)){
1398                         if( h->ref_count[list] > 1 ){
1399                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1400                             if(ref[list][i] >= (unsigned)h->ref_count[list]){
1401                                 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1402                                 return -1;
1403                             }
1404                         }else
1405                             ref[list][i] = 0;
1406                     } else {
1407                         ref[list][i] = -1;
1408                     }
1409                                                        h->ref_cache[list][ scan8[4*i]+1 ]=
1410                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1411                 }
1412         }
1413
1414         if(dct8x8_allowed)
1415             dct8x8_allowed = get_dct8x8_allowed(h);
1416
1417         for(list=0; list<h->list_count; list++){
1418             for(i=0; i<4; i++){
1419                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1420                 if(IS_DIRECT(h->sub_mb_type[i])){
1421                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
1422                     continue;
1423                 }
1424
1425                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1426                     const int sub_mb_type= h->sub_mb_type[i];
1427                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1428                     for(j=0; j<sub_partition_count[i]; j++){
1429                         int mpx, mpy;
1430                         int mx, my;
1431                         const int index= 4*i + block_width*j;
1432                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1433                         int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1434                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
1435
1436                         mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
1437                         my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
1438                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1439
1440                         mpx= abs(mpx-mx);
1441                         mpy= abs(mpy-my);
1442                         if(IS_SUB_8X8(sub_mb_type)){
1443                             mv_cache[ 1 ][0]=
1444                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1445                             mv_cache[ 1 ][1]=
1446                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1447
1448                             mvd_cache[ 1 ][0]=
1449                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
1450                             mvd_cache[ 1 ][1]=
1451                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
1452                         }else if(IS_SUB_8X4(sub_mb_type)){
1453                             mv_cache[ 1 ][0]= mx;
1454                             mv_cache[ 1 ][1]= my;
1455
1456                             mvd_cache[ 1 ][0]=  mpx;
1457                             mvd_cache[ 1 ][1]= mpy;
1458                         }else if(IS_SUB_4X8(sub_mb_type)){
1459                             mv_cache[ 8 ][0]= mx;
1460                             mv_cache[ 8 ][1]= my;
1461
1462                             mvd_cache[ 8 ][0]= mpx;
1463                             mvd_cache[ 8 ][1]= mpy;
1464                         }
1465                         mv_cache[ 0 ][0]= mx;
1466                         mv_cache[ 0 ][1]= my;
1467
1468                         mvd_cache[ 0 ][0]= mpx;
1469                         mvd_cache[ 0 ][1]= mpy;
1470                     }
1471                 }else{
1472                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
1473                     uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
1474                     p[0] = p[1] = p[8] = p[9] = 0;
1475                     pd[0]= pd[1]= pd[8]= pd[9]= 0;
1476                 }
1477             }
1478         }
1479     } else if( IS_DIRECT(mb_type) ) {
1480         ff_h264_pred_direct_motion(h, &mb_type);
1481         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1482         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1483         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1484     } else {
1485         int list, mx, my, i, mpx, mpy;
1486         if(IS_16X16(mb_type)){
1487             for(list=0; list<h->list_count; list++){
1488                 if(IS_DIR(mb_type, 0, list)){
1489                     int ref;
1490                     if(h->ref_count[list] > 1){
1491                         ref= decode_cabac_mb_ref(h, list, 0);
1492                         if(ref >= (unsigned)h->ref_count[list]){
1493                             av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1494                             return -1;
1495                         }
1496                     }else
1497                         ref=0;
1498                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1499                 }else
1500                     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
1501             }
1502             for(list=0; list<h->list_count; list++){
1503                 if(IS_DIR(mb_type, 0, list)){
1504                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
1505
1506                     mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
1507                     my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
1508                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1509
1510                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(abs(mx-mpx),abs(my-mpy)), 4);
1511                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1512                 }else
1513                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
1514             }
1515         }
1516         else if(IS_16X8(mb_type)){
1517             for(list=0; list<h->list_count; list++){
1518                     for(i=0; i<2; i++){
1519                         if(IS_DIR(mb_type, i, list)){
1520                             int ref;
1521                             if(h->ref_count[list] > 1){
1522                                 ref= decode_cabac_mb_ref( h, list, 8*i );
1523                                 if(ref >= (unsigned)h->ref_count[list]){
1524                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1525                                     return -1;
1526                                 }
1527                             }else
1528                                 ref=0;
1529                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1530                         }else
1531                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1532                     }
1533             }
1534             for(list=0; list<h->list_count; list++){
1535                 for(i=0; i<2; i++){
1536                     if(IS_DIR(mb_type, i, list)){
1537                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
1538                         mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
1539                         my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
1540                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1541
1542                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(abs(mx-mpx),abs(my-mpy)), 4);
1543                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1544                     }else{
1545                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1546                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1547                     }
1548                 }
1549             }
1550         }else{
1551             assert(IS_8X16(mb_type));
1552             for(list=0; list<h->list_count; list++){
1553                     for(i=0; i<2; i++){
1554                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1555                             int ref;
1556                             if(h->ref_count[list] > 1){
1557                                 ref= decode_cabac_mb_ref( h, list, 4*i );
1558                                 if(ref >= (unsigned)h->ref_count[list]){
1559                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1560                                     return -1;
1561                                 }
1562                             }else
1563                                 ref=0;
1564                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1565                         }else
1566                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1567                     }
1568             }
1569             for(list=0; list<h->list_count; list++){
1570                 for(i=0; i<2; i++){
1571                     if(IS_DIR(mb_type, i, list)){
1572                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
1573                         mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
1574                         my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
1575
1576                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1577                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(abs(mx-mpx),abs(my-mpy)), 4);
1578                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1579                     }else{
1580                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1581                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1582                     }
1583                 }
1584             }
1585         }
1586     }
1587
1588    if( IS_INTER( mb_type ) ) {
1589         h->chroma_pred_mode_table[mb_xy] = 0;
1590         write_back_motion( h, mb_type );
1591    }
1592
1593     if( !IS_INTRA16x16( mb_type ) ) {
1594         cbp  = decode_cabac_mb_cbp_luma( h );
1595         if(CHROMA)
1596             cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1597     }
1598
1599     h->cbp_table[mb_xy] = h->cbp = cbp;
1600
1601     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1602         mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1603     }
1604     s->current_picture.mb_type[mb_xy]= mb_type;
1605
1606     if( cbp || IS_INTRA16x16( mb_type ) ) {
1607         const uint8_t *scan, *scan8x8, *dc_scan;
1608         const uint32_t *qmul;
1609
1610         if(IS_INTERLACED(mb_type)){
1611             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1612             scan= s->qscale ? h->field_scan : h->field_scan_q0;
1613             dc_scan= luma_dc_field_scan;
1614         }else{
1615             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1616             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1617             dc_scan= luma_dc_zigzag_scan;
1618         }
1619
1620         // decode_cabac_mb_dqp
1621         if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1622             int val = 1;
1623             int ctx= 2;
1624
1625             while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1626                 ctx= 3;
1627                 val++;
1628                 if(val > 102){ //prevent infinite loop
1629                     av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1630                     return -1;
1631                 }
1632             }
1633
1634             if( val&0x01 )
1635                 val=   (val + 1)>>1 ;
1636             else
1637                 val= -((val + 1)>>1);
1638             h->last_qscale_diff = val;
1639             s->qscale += val;
1640             if(((unsigned)s->qscale) > 51){
1641                 if(s->qscale<0) s->qscale+= 52;
1642                 else            s->qscale-= 52;
1643             }
1644             h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1645             h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1646         }else
1647             h->last_qscale_diff=0;
1648
1649         if( IS_INTRA16x16( mb_type ) ) {
1650             int i;
1651             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1652             decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1653
1654             if( cbp&15 ) {
1655                 qmul = h->dequant4_coeff[0][s->qscale];
1656                 for( i = 0; i < 16; i++ ) {
1657                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1658                     decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1659                 }
1660             } else {
1661                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1662             }
1663         } else {
1664             int i8x8, i4x4;
1665             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1666                 if( cbp & (1<<i8x8) ) {
1667                     if( IS_8x8DCT(mb_type) ) {
1668                         decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1669                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1670                     } else {
1671                         qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1672                         for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1673                             const int index = 4*i8x8 + i4x4;
1674                             //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1675 //START_TIMER
1676                             decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1677 //STOP_TIMER("decode_residual")
1678                         }
1679                     }
1680                 } else {
1681                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1682                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1683                 }
1684             }
1685         }
1686
1687         if( cbp&0x30 ){
1688             int c;
1689             for( c = 0; c < 2; c++ ) {
1690                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1691                 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1692             }
1693         }
1694
1695         if( cbp&0x20 ) {
1696             int c, i;
1697             for( c = 0; c < 2; c++ ) {
1698                 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1699                 for( i = 0; i < 4; i++ ) {
1700                     const int index = 16 + 4 * c + i;
1701                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1702                     decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1703                 }
1704             }
1705         } else {
1706             uint8_t * const nnz= &h->non_zero_count_cache[0];
1707             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1708             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1709         }
1710     } else {
1711         uint8_t * const nnz= &h->non_zero_count_cache[0];
1712         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1713         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1714         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1715         h->last_qscale_diff = 0;
1716     }
1717
1718     s->current_picture.qscale_table[mb_xy]= s->qscale;
1719     write_back_non_zero_count(h);
1720
1721     if(MB_MBAFF){
1722         h->ref_count[0] >>= 1;
1723         h->ref_count[1] >>= 1;
1724     }
1725
1726     return 0;
1727 }