FFmpeg: libavcodec/h264_cabac.c Source File

00001 /*
00002  * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding
00003  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00028 #define CABAC 1
00029 
00030 #include "internal.h"
00031 #include "dsputil.h"
00032 #include "avcodec.h"
00033 #include "h264.h"
00034 #include "h264data.h"
00035 #include "h264_mvpred.h"
00036 #include "golomb.h"
00037 
00038 #include "cabac.h"
00039 #if ARCH_X86
00040 #include "x86/h264_i386.h"
00041 #endif
00042 
00043 //#undef NDEBUG
00044 #include <assert.h>
00045 
00046 /* Cabac pre state table */
00047 
00048 static const int8_t cabac_context_init_I[460][2] =
00049 {
00050     /* 0 - 10 */
00051     { 20, -15 }, {  2, 54 },  {  3,  74 }, { 20, -15 },
00052     {  2,  54 }, {  3, 74 },  { -28,127 }, { -23, 104 },
00053     { -6,  53 }, { -1, 54 },  {  7,  51 },
00054 
00055     /* 11 - 23 unsused for I */
00056     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
00057     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
00058     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
00059     { 0, 0 },
00060 
00061     /* 24- 39 */
00062     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
00063     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
00064     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
00065     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
00066 
00067     /* 40 - 53 */
00068     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
00069     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
00070     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
00071     { 0, 0 },    { 0, 0 },
00072 
00073     /* 54 - 59 */
00074     { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
00075     { 0, 0 },    { 0, 0 },
00076 
00077     /* 60 - 69 */
00078     { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
00079     { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
00080     { 13, 41 },  { 3, 62 },
00081 
00082     /* 70 -> 87 */
00083     { 0, 11 },   { 1, 55 },   { 0, 69 },     { -17, 127 },
00084     { -13, 102 },{ 0, 82 },   { -7, 74 },    { -21, 107 },
00085     { -27, 127 },{ -31, 127 },{ -24, 127 },  { -18, 95 },
00086     { -27, 127 },{ -21, 114 },{ -30, 127 },  { -17, 123 },
00087     { -12, 115 },{ -16, 122 },
00088 
00089     /* 88 -> 104 */
00090     { -11, 115 },{ -12, 63 }, { -2, 68 },    { -15, 84 },
00091     { -13, 104 },{ -3, 70 },  { -8, 93 },    { -10, 90 },
00092     { -30, 127 },{ -1, 74 },  { -6, 97 },    { -7, 91 },
00093     { -20, 127 },{ -4, 56 },  { -5, 82 },    { -7, 76 },
00094     { -22, 125 },
00095 
00096     /* 105 -> 135 */
00097     { -7, 93 },  { -11, 87 }, { -3, 77 },    { -5, 71 },
00098     { -4, 63 },  { -4, 68 },  { -12, 84 },   { -7, 62 },
00099     { -7, 65 },  { 8, 61 },   { 5, 56 },     { -2, 66 },
00100     { 1, 64 },   { 0, 61 },   { -2, 78 },    { 1, 50 },
00101     { 7, 52 },   { 10, 35 },  { 0, 44 },     { 11, 38 },
00102     { 1, 45 },   { 0, 46 },   { 5, 44 },     { 31, 17 },
00103     { 1, 51 },   { 7, 50 },   { 28, 19 },    { 16, 33 },
00104     { 14, 62 },  { -13, 108 },{ -15, 100 },
00105 
00106     /* 136 -> 165 */
00107     { -13, 101 },{ -13, 91 }, { -12, 94 },   { -10, 88 },
00108     { -16, 84 }, { -10, 86 }, { -7, 83 },    { -13, 87 },
00109     { -19, 94 }, { 1, 70 },   { 0, 72 },     { -5, 74 },
00110     { 18, 59 },  { -8, 102 }, { -15, 100 },  { 0, 95 },
00111     { -4, 75 },  { 2, 72 },   { -11, 75 },   { -3, 71 },
00112     { 15, 46 },  { -13, 69 }, { 0, 62 },     { 0, 65 },
00113     { 21, 37 },  { -15, 72 }, { 9, 57 },     { 16, 54 },
00114     { 0, 62 },   { 12, 72 },
00115 
00116     /* 166 -> 196 */
00117     { 24, 0 },   { 15, 9 },   { 8, 25 },     { 13, 18 },
00118     { 15, 9 },   { 13, 19 },  { 10, 37 },    { 12, 18 },
00119     { 6, 29 },   { 20, 33 },  { 15, 30 },    { 4, 45 },
00120     { 1, 58 },   { 0, 62 },   { 7, 61 },     { 12, 38 },
00121     { 11, 45 },  { 15, 39 },  { 11, 42 },    { 13, 44 },
00122     { 16, 45 },  { 12, 41 },  { 10, 49 },    { 30, 34 },
00123     { 18, 42 },  { 10, 55 },  { 17, 51 },    { 17, 46 },
00124     { 0, 89 },   { 26, -19 }, { 22, -17 },
00125 
00126     /* 197 -> 226 */
00127     { 26, -17 }, { 30, -25 }, { 28, -20 },   { 33, -23 },
00128     { 37, -27 }, { 33, -23 }, { 40, -28 },   { 38, -17 },
00129     { 33, -11 }, { 40, -15 }, { 41, -6 },    { 38, 1 },
00130     { 41, 17 },  { 30, -6 },  { 27, 3 },     { 26, 22 },
00131     { 37, -16 }, { 35, -4 },  { 38, -8 },    { 38, -3 },
00132     { 37, 3 },   { 38, 5 },   { 42, 0 },     { 35, 16 },
00133     { 39, 22 },  { 14, 48 },  { 27, 37 },    { 21, 60 },
00134     { 12, 68 },  { 2, 97 },
00135 
00136     /* 227 -> 251 */
00137     { -3, 71 },  { -6, 42 },  { -5, 50 },    { -3, 54 },
00138     { -2, 62 },  { 0, 58 },   { 1, 63 },     { -2, 72 },
00139     { -1, 74 },  { -9, 91 },  { -5, 67 },    { -5, 27 },
00140     { -3, 39 },  { -2, 44 },  { 0, 46 },     { -16, 64 },
00141     { -8, 68 },  { -10, 78 }, { -6, 77 },    { -10, 86 },
00142     { -12, 92 }, { -15, 55 }, { -10, 60 },   { -6, 62 },
00143     { -4, 65 },
00144 
00145     /* 252 -> 275 */
00146     { -12, 73 }, { -8, 76 },  { -7, 80 },    { -9, 88 },
00147     { -17, 110 },{ -11, 97 }, { -20, 84 },   { -11, 79 },
00148     { -6, 73 },  { -4, 74 },  { -13, 86 },   { -13, 96 },
00149     { -11, 97 }, { -19, 117 },{ -8, 78 },    { -5, 33 },
00150     { -4, 48 },  { -2, 53 },  { -3, 62 },    { -13, 71 },
00151     { -10, 79 }, { -12, 86 }, { -13, 90 },   { -14, 97 },
00152 
00153     /* 276 a bit special (not used, bypass is used instead) */
00154     { 0, 0 },
00155 
00156     /* 277 -> 307 */
00157     { -6, 93 },  { -6, 84 },  { -8, 79 },    { 0, 66 },
00158     { -1, 71 },  { 0, 62 },   { -2, 60 },    { -2, 59 },
00159     { -5, 75 },  { -3, 62 },  { -4, 58 },    { -9, 66 },
00160     { -1, 79 },  { 0, 71 },   { 3, 68 },     { 10, 44 },
00161     { -7, 62 },  { 15, 36 },  { 14, 40 },    { 16, 27 },
00162     { 12, 29 },  { 1, 44 },   { 20, 36 },    { 18, 32 },
00163     { 5, 42 },   { 1, 48 },   { 10, 62 },    { 17, 46 },
00164     { 9, 64 },   { -12, 104 },{ -11, 97 },
00165 
00166     /* 308 -> 337 */
00167     { -16, 96 }, { -7, 88 },  { -8, 85 },    { -7, 85 },
00168     { -9, 85 },  { -13, 88 }, { 4, 66 },     { -3, 77 },
00169     { -3, 76 },  { -6, 76 },  { 10, 58 },    { -1, 76 },
00170     { -1, 83 },  { -7, 99 },  { -14, 95 },   { 2, 95 },
00171     { 0, 76 },   { -5, 74 },  { 0, 70 },     { -11, 75 },
00172     { 1, 68 },   { 0, 65 },   { -14, 73 },   { 3, 62 },
00173     { 4, 62 },   { -1, 68 },  { -13, 75 },   { 11, 55 },
00174     { 5, 64 },   { 12, 70 },
00175 
00176     /* 338 -> 368 */
00177     { 15, 6 },   { 6, 19 },   { 7, 16 },     { 12, 14 },
00178     { 18, 13 },  { 13, 11 },  { 13, 15 },    { 15, 16 },
00179     { 12, 23 },  { 13, 23 },  { 15, 20 },    { 14, 26 },
00180     { 14, 44 },  { 17, 40 },  { 17, 47 },    { 24, 17 },
00181     { 21, 21 },  { 25, 22 },  { 31, 27 },    { 22, 29 },
00182     { 19, 35 },  { 14, 50 },  { 10, 57 },    { 7, 63 },
00183     { -2, 77 },  { -4, 82 },  { -3, 94 },    { 9, 69 },
00184     { -12, 109 },{ 36, -35 }, { 36, -34 },
00185 
00186     /* 369 -> 398 */
00187     { 32, -26 }, { 37, -30 }, { 44, -32 },   { 34, -18 },
00188     { 34, -15 }, { 40, -15 }, { 33, -7 },    { 35, -5 },
00189     { 33, 0 },   { 38, 2 },   { 33, 13 },    { 23, 35 },
00190     { 13, 58 },  { 29, -3 },  { 26, 0 },     { 22, 30 },
00191     { 31, -7 },  { 35, -15 }, { 34, -3 },    { 34, 3 },
00192     { 36, -1 },  { 34, 5 },   { 32, 11 },    { 35, 5 },
00193     { 34, 12 },  { 39, 11 },  { 30, 29 },    { 34, 26 },
00194     { 29, 39 },  { 19, 66 },
00195 
00196     /* 399 -> 435 */
00197     {  31,  21 }, {  31,  31 }, {  25,  50 },
00198     { -17, 120 }, { -20, 112 }, { -18, 114 }, { -11,  85 },
00199     { -15,  92 }, { -14,  89 }, { -26,  71 }, { -15,  81 },
00200     { -14,  80 }, {   0,  68 }, { -14,  70 }, { -24,  56 },
00201     { -23,  68 }, { -24,  50 }, { -11,  74 }, {  23, -13 },
00202     {  26, -13 }, {  40, -15 }, {  49, -14 }, {  44,   3 },
00203     {  45,   6 }, {  44,  34 }, {  33,  54 }, {  19,  82 },
00204     {  -3,  75 }, {  -1,  23 }, {   1,  34 }, {   1,  43 },
00205     {   0,  54 }, {  -2,  55 }, {   0,  61 }, {   1,  64 },
00206     {   0,  68 }, {  -9,  92 },
00207 
00208     /* 436 -> 459 */
00209     { -14, 106 }, { -13,  97 }, { -15,  90 }, { -12,  90 },
00210     { -18,  88 }, { -10,  73 }, {  -9,  79 }, { -14,  86 },
00211     { -10,  73 }, { -10,  70 }, { -10,  69 }, {  -5,  66 },
00212     {  -9,  64 }, {  -5,  58 }, {   2,  59 }, {  21, -10 },
00213     {  24, -11 }, {  28,  -8 }, {  28,  -1 }, {  29,   3 },
00214     {  29,   9 }, {  35,  20 }, {  29,  36 }, {  14,  67 }
00215 };
00216 
00217 static const int8_t cabac_context_init_PB[3][460][2] =
00218 {
00219     /* i_cabac_init_idc == 0 */
00220     {
00221         /* 0 - 10 */
00222         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
00223         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
00224         {  -6,  53 }, {  -1,  54 }, {   7,  51 },
00225 
00226         /* 11 - 23 */
00227         {  23,  33 }, {  23,   2 }, {  21,   0 }, {   1,   9 },
00228         {   0,  49 }, { -37, 118 }, {   5,  57 }, { -13,  78 },
00229         { -11,  65 }, {   1,  62 }, {  12,  49 }, {  -4,  73 },
00230         {  17,  50 },
00231 
00232         /* 24 - 39 */
00233         {  18,  64 }, {   9,  43 }, {  29,   0 }, {  26,  67 },
00234         {  16,  90 }, {   9, 104 }, { -46, 127 }, { -20, 104 },
00235         {   1,  67 }, { -13,  78 }, { -11,  65 }, {   1,  62 },
00236         {  -6,  86 }, { -17,  95 }, {  -6,  61 }, {   9,  45 },
00237 
00238         /* 40 - 53 */
00239         {  -3,  69 }, {  -6,  81 }, { -11,  96 }, {   6,  55 },
00240         {   7,  67 }, {  -5,  86 }, {   2,  88 }, {   0,  58 },
00241         {  -3,  76 }, { -10,  94 }, {   5,  54 }, {   4,  69 },
00242         {  -3,  81 }, {   0,  88 },
00243 
00244         /* 54 - 59 */
00245         {  -7,  67 }, {  -5,  74 }, {  -4,  74 }, {  -5,  80 },
00246         {  -7,  72 }, {   1,  58 },
00247 
00248         /* 60 - 69 */
00249         {   0,  41 }, {   0,  63 }, {   0,  63 }, { 0, 63 },
00250         {  -9,  83 }, {   4,  86 }, {   0,  97 }, { -7, 72 },
00251         {  13,  41 }, {   3,  62 },
00252 
00253         /* 70 - 87 */
00254         {   0,  45 }, {  -4,  78 }, {  -3,  96 }, { -27,  126 },
00255         { -28,  98 }, { -25, 101 }, { -23,  67 }, { -28,  82 },
00256         { -20,  94 }, { -16,  83 }, { -22, 110 }, { -21,  91 },
00257         { -18, 102 }, { -13,  93 }, { -29, 127 }, {  -7,  92 },
00258         {  -5,  89 }, {  -7,  96 }, { -13, 108 }, {  -3,  46 },
00259         {  -1,  65 }, {  -1,  57 }, {  -9,  93 }, {  -3,  74 },
00260         {  -9,  92 }, {  -8,  87 }, { -23, 126 }, {   5,  54 },
00261         {   6,  60 }, {   6,  59 }, {   6,  69 }, {  -1,  48 },
00262         {   0,  68 }, {  -4,  69 }, {  -8,  88 },
00263 
00264         /* 105 -> 165 */
00265         {  -2,  85 }, {  -6,  78 }, {  -1,  75 }, {  -7,  77 },
00266         {   2,  54 }, {   5,  50 }, {  -3,  68 }, {   1,  50 },
00267         {   6,  42 }, {  -4,  81 }, {   1,  63 }, {  -4,  70 },
00268         {   0,  67 }, {   2,  57 }, {  -2,  76 }, {  11,  35 },
00269         {   4,  64 }, {   1,  61 }, {  11,  35 }, {  18,  25 },
00270         {  12,  24 }, {  13,  29 }, {  13,  36 }, { -10,  93 },
00271         {  -7,  73 }, {  -2,  73 }, {  13,  46 }, {   9,  49 },
00272         {  -7, 100 }, {   9,  53 }, {   2,  53 }, {   5,  53 },
00273         {  -2,  61 }, {   0,  56 }, {   0,  56 }, { -13,  63 },
00274         {  -5,  60 }, {  -1,  62 }, {   4,  57 }, {  -6,  69 },
00275         {   4,  57 }, {  14,  39 }, {   4,  51 }, {  13,  68 },
00276         {   3,  64 }, {   1,  61 }, {   9,  63 }, {   7,  50 },
00277         {  16,  39 }, {   5,  44 }, {   4,  52 }, {  11,  48 },
00278         {  -5,  60 }, {  -1,  59 }, {   0,  59 }, {  22,  33 },
00279         {   5,  44 }, {  14,  43 }, {  -1,  78 }, {   0,  60 },
00280         {   9,  69 },
00281 
00282         /* 166 - 226 */
00283         {  11,  28 }, {   2,  40 }, {   3,  44 }, {   0,  49 },
00284         {   0,  46 }, {   2,  44 }, {   2,  51 }, {   0,  47 },
00285         {   4,  39 }, {   2,  62 }, {   6,  46 }, {   0,  54 },
00286         {   3,  54 }, {   2,  58 }, {   4,  63 }, {   6,  51 },
00287         {   6,  57 }, {   7,  53 }, {   6,  52 }, {   6,  55 },
00288         {  11,  45 }, {  14,  36 }, {   8,  53 }, {  -1,  82 },
00289         {   7,  55 }, {  -3,  78 }, {  15,  46 }, {  22,  31 },
00290         {  -1,  84 }, {  25,   7 }, {  30,  -7 }, {  28,   3 },
00291         {  28,   4 }, {  32,   0 }, {  34,  -1 }, {  30,   6 },
00292         {  30,   6 }, {  32,   9 }, {  31,  19 }, {  26,  27 },
00293         {  26,  30 }, {  37,  20 }, {  28,  34 }, {  17,  70 },
00294         {   1,  67 }, {   5,  59 }, {   9,  67 }, {  16,  30 },
00295         {  18,  32 }, {  18,  35 }, {  22,  29 }, {  24,  31 },
00296         {  23,  38 }, {  18,  43 }, {  20,  41 }, {  11,  63 },
00297         {   9,  59 }, {   9,  64 }, {  -1,  94 }, {  -2,  89 },
00298         {  -9, 108 },
00299 
00300         /* 227 - 275 */
00301         {  -6,  76 }, {  -2,  44 }, {   0,  45 }, {   0,  52 },
00302         {  -3,  64 }, {  -2,  59 }, {  -4,  70 }, {  -4,  75 },
00303         {  -8,  82 }, { -17, 102 }, {  -9,  77 }, {   3,  24 },
00304         {   0,  42 }, {   0,  48 }, {   0,  55 }, {  -6,  59 },
00305         {  -7,  71 }, { -12,  83 }, { -11,  87 }, { -30, 119 },
00306         {   1,  58 }, {  -3,  29 }, {  -1,  36 }, {   1,  38 },
00307         {   2,  43 }, {  -6,  55 }, {   0,  58 }, {   0,  64 },
00308         {  -3,  74 }, { -10,  90 }, {   0,  70 }, {  -4,  29 },
00309         {   5,  31 }, {   7,  42 }, {   1,  59 }, {  -2,  58 },
00310         {  -3,  72 }, {  -3,  81 }, { -11,  97 }, {   0,  58 },
00311         {   8,   5 }, {  10,  14 }, {  14,  18 }, {  13,  27 },
00312         {   2,  40 }, {   0,  58 }, {  -3,  70 }, {  -6,  79 },
00313         {  -8,  85 },
00314 
00315         /* 276 a bit special (not used, bypass is used instead) */
00316         { 0, 0 },
00317 
00318         /* 277 - 337 */
00319         { -13, 106 }, { -16, 106 }, { -10,  87 }, { -21, 114 },
00320         { -18, 110 }, { -14,  98 }, { -22, 110 }, { -21, 106 },
00321         { -18, 103 }, { -21, 107 }, { -23, 108 }, { -26, 112 },
00322         { -10,  96 }, { -12,  95 }, {  -5,  91 }, {  -9,  93 },
00323         { -22,  94 }, {  -5,  86 }, {   9,  67 }, {  -4,  80 },
00324         { -10,  85 }, {  -1,  70 }, {   7,  60 }, {   9,  58 },
00325         {   5,  61 }, {  12,  50 }, {  15,  50 }, {  18,  49 },
00326         {  17,  54 }, {  10,  41 }, {   7,  46 }, {  -1,  51 },
00327         {   7,  49 }, {   8,  52 }, {   9,  41 }, {   6,  47 },
00328         {   2,  55 }, {  13,  41 }, {  10,  44 }, {   6,  50 },
00329         {   5,  53 }, {  13,  49 }, {   4,  63 }, {   6,  64 },
00330         {  -2,  69 }, {  -2,  59 }, {   6,  70 }, {  10,  44 },
00331         {   9,  31 }, {  12,  43 }, {   3,  53 }, {  14,  34 },
00332         {  10,  38 }, {  -3,  52 }, {  13,  40 }, {  17,  32 },
00333         {   7,  44 }, {   7,  38 }, {  13,  50 }, {  10,  57 },
00334         {  26,  43 },
00335 
00336         /* 338 - 398 */
00337         {  14,  11 }, {  11,  14 }, {   9,  11 }, {  18,  11 },
00338         {  21,   9 }, {  23,  -2 }, {  32, -15 }, {  32, -15 },
00339         {  34, -21 }, {  39, -23 }, {  42, -33 }, {  41, -31 },
00340         {  46, -28 }, {  38, -12 }, {  21,  29 }, {  45, -24 },
00341         {  53, -45 }, {  48, -26 }, {  65, -43 }, {  43, -19 },
00342         {  39, -10 }, {  30,   9 }, {  18,  26 }, {  20,  27 },
00343         {   0,  57 }, { -14,  82 }, {  -5,  75 }, { -19,  97 },
00344         { -35, 125 }, {  27,   0 }, {  28,   0 }, {  31,  -4 },
00345         {  27,   6 }, {  34,   8 }, {  30,  10 }, {  24,  22 },
00346         {  33,  19 }, {  22,  32 }, {  26,  31 }, {  21,  41 },
00347         {  26,  44 }, {  23,  47 }, {  16,  65 }, {  14,  71 },
00348         {   8,  60 }, {   6,  63 }, {  17,  65 }, {  21,  24 },
00349         {  23,  20 }, {  26,  23 }, {  27,  32 }, {  28,  23 },
00350         {  28,  24 }, {  23,  40 }, {  24,  32 }, {  28,  29 },
00351         {  23,  42 }, {  19,  57 }, {  22,  53 }, {  22,  61 },
00352         {  11,  86 },
00353 
00354         /* 399 - 435 */
00355         {  12,  40 }, {  11,  51 }, {  14,  59 },
00356         {  -4,  79 }, {  -7,  71 }, {  -5,  69 }, {  -9,  70 },
00357         {  -8,  66 }, { -10,  68 }, { -19,  73 }, { -12,  69 },
00358         { -16,  70 }, { -15,  67 }, { -20,  62 }, { -19,  70 },
00359         { -16,  66 }, { -22,  65 }, { -20,  63 }, {   9,  -2 },
00360         {  26,  -9 }, {  33,  -9 }, {  39,  -7 }, {  41,  -2 },
00361         {  45,   3 }, {  49,   9 }, {  45,  27 }, {  36,  59 },
00362         {  -6,  66 }, {  -7,  35 }, {  -7,  42 }, {  -8,  45 },
00363         {  -5,  48 }, { -12,  56 }, {  -6,  60 }, {  -5,  62 },
00364         {  -8,  66 }, {  -8,  76 },
00365 
00366         /* 436 - 459 */
00367         {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },
00368         { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },
00369         {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },
00370         { -14,  66 }, {   0,  59 }, {   2,  59 }, {  21, -13 },
00371         {  33, -14 }, {  39,  -7 }, {  46,  -2 }, {  51,   2 },
00372         {  60,   6 }, {  61,  17 }, {  55,  34 }, {  42,  62 },
00373     },
00374 
00375     /* i_cabac_init_idc == 1 */
00376     {
00377         /* 0 - 10 */
00378         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
00379         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
00380         {  -6,  53 }, {  -1,  54 }, {   7,  51 },
00381 
00382         /* 11 - 23 */
00383         {  22,  25 }, {  34,   0 }, {  16,   0 }, {  -2,   9 },
00384         {   4,  41 }, { -29, 118 }, {   2,  65 }, {  -6,  71 },
00385         { -13,  79 }, {   5,  52 }, {   9,  50 }, {  -3,  70 },
00386         {  10,  54 },
00387 
00388         /* 24 - 39 */
00389         {  26,  34 }, {  19,  22 }, {  40,   0 }, {  57,   2 },
00390         {  41,  36 }, {  26,  69 }, { -45, 127 }, { -15, 101 },
00391         {  -4,  76 }, {  -6,  71 }, { -13,  79 }, {   5,  52 },
00392         {   6,  69 }, { -13,  90 }, {   0,  52 }, {   8,  43 },
00393 
00394         /* 40 - 53 */
00395         {  -2,  69 },{  -5,  82 },{ -10,  96 },{   2,  59 },
00396         {   2,  75 },{  -3,  87 },{  -3,  100 },{   1,  56 },
00397         {  -3,  74 },{  -6,  85 },{   0,  59 },{  -3,  81 },
00398         {  -7,  86 },{  -5,  95 },
00399 
00400         /* 54 - 59 */
00401         {  -1,  66 },{  -1,  77 },{   1,  70 },{  -2,  86 },
00402         {  -5,  72 },{   0,  61 },
00403 
00404         /* 60 - 69 */
00405         { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
00406         { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
00407         { 13, 41 },  { 3, 62 },
00408 
00409         /* 70 - 104 */
00410         {  13,  15 }, {   7,  51 }, {   2,  80 }, { -39, 127 },
00411         { -18,  91 }, { -17,  96 }, { -26,  81 }, { -35,  98 },
00412         { -24, 102 }, { -23,  97 }, { -27, 119 }, { -24,  99 },
00413         { -21, 110 }, { -18, 102 }, { -36, 127 }, {   0,  80 },
00414         {  -5,  89 }, {  -7,  94 }, {  -4,  92 }, {   0,  39 },
00415         {   0,  65 }, { -15,  84 }, { -35, 127 }, {  -2,  73 },
00416         { -12, 104 }, {  -9,  91 }, { -31, 127 }, {   3,  55 },
00417         {   7,  56 }, {   7,  55 }, {   8,  61 }, {  -3,  53 },
00418         {   0,  68 }, {  -7,  74 }, {  -9,  88 },
00419 
00420         /* 105 -> 165 */
00421         { -13, 103 }, { -13,  91 }, {  -9,  89 }, { -14,  92 },
00422         {  -8,  76 }, { -12,  87 }, { -23, 110 }, { -24, 105 },
00423         { -10,  78 }, { -20, 112 }, { -17,  99 }, { -78, 127 },
00424         { -70, 127 }, { -50, 127 }, { -46, 127 }, {  -4,  66 },
00425         {  -5,  78 }, {  -4,  71 }, {  -8,  72 }, {   2,  59 },
00426         {  -1,  55 }, {  -7,  70 }, {  -6,  75 }, {  -8,  89 },
00427         { -34, 119 }, {  -3,  75 }, {  32,  20 }, {  30,  22 },
00428         { -44, 127 }, {   0,  54 }, {  -5,  61 }, {   0,  58 },
00429         {  -1,  60 }, {  -3,  61 }, {  -8,  67 }, { -25,  84 },
00430         { -14,  74 }, {  -5,  65 }, {   5,  52 }, {   2,  57 },
00431         {   0,  61 }, {  -9,  69 }, { -11,  70 }, {  18,  55 },
00432         {  -4,  71 }, {   0,  58 }, {   7,  61 }, {   9,  41 },
00433         {  18,  25 }, {   9,  32 }, {   5,  43 }, {   9,  47 },
00434         {   0,  44 }, {   0,  51 }, {   2,  46 }, {  19,  38 },
00435         {  -4,  66 }, {  15,  38 }, {  12,  42 }, {   9,  34 },
00436         {   0,  89 },
00437 
00438         /* 166 - 226 */
00439         {   4,  45 }, {  10,  28 }, {  10,  31 }, {  33, -11 },
00440         {  52, -43 }, {  18,  15 }, {  28,   0 }, {  35, -22 },
00441         {  38, -25 }, {  34,   0 }, {  39, -18 }, {  32, -12 },
00442         { 102, -94 }, {   0,   0 }, {  56, -15 }, {  33,  -4 },
00443         {  29,  10 }, {  37,  -5 }, {  51, -29 }, {  39,  -9 },
00444         {  52, -34 }, {  69, -58 }, {  67, -63 }, {  44,  -5 },
00445         {  32,   7 }, {  55, -29 }, {  32,   1 }, {   0,   0 },
00446         {  27,  36 }, {  33, -25 }, {  34, -30 }, {  36, -28 },
00447         {  38, -28 }, {  38, -27 }, {  34, -18 }, {  35, -16 },
00448         {  34, -14 }, {  32,  -8 }, {  37,  -6 }, {  35,   0 },
00449         {  30,  10 }, {  28,  18 }, {  26,  25 }, {  29,  41 },
00450         {   0,  75 }, {   2,  72 }, {   8,  77 }, {  14,  35 },
00451         {  18,  31 }, {  17,  35 }, {  21,  30 }, {  17,  45 },
00452         {  20,  42 }, {  18,  45 }, {  27,  26 }, {  16,  54 },
00453         {   7,  66 }, {  16,  56 }, {  11,  73 }, {  10,  67 },
00454         { -10, 116 },
00455 
00456         /* 227 - 275 */
00457         { -23, 112 }, { -15,  71 }, {  -7,  61 }, {   0,  53 },
00458         {  -5,  66 }, { -11,  77 }, {  -9,  80 }, {  -9,  84 },
00459         { -10,  87 }, { -34, 127 }, { -21, 101 }, {  -3,  39 },
00460         {  -5,  53 }, {  -7,  61 }, { -11,  75 }, { -15,  77 },
00461         { -17,  91 }, { -25, 107 }, { -25, 111 }, { -28, 122 },
00462         { -11,  76 }, { -10,  44 }, { -10,  52 }, { -10,  57 },
00463         {  -9,  58 }, { -16,  72 }, {  -7,  69 }, {  -4,  69 },
00464         {  -5,  74 }, {  -9,  86 }, {   2,  66 }, {  -9,  34 },
00465         {   1,  32 }, {  11,  31 }, {   5,  52 }, {  -2,  55 },
00466         {  -2,  67 }, {   0,  73 }, {  -8,  89 }, {   3,  52 },
00467         {   7,   4 }, {  10,   8 }, {  17,   8 }, {  16,  19 },
00468         {   3,  37 }, {  -1,  61 }, {  -5,  73 }, {  -1,  70 },
00469         {  -4,  78 },
00470 
00471         /* 276 a bit special (not used, bypass is used instead) */
00472         { 0, 0 },
00473 
00474         /* 277 - 337 */
00475         { -21, 126 }, { -23, 124 }, { -20, 110 }, { -26, 126 },
00476         { -25, 124 }, { -17, 105 }, { -27, 121 }, { -27, 117 },
00477         { -17, 102 }, { -26, 117 }, { -27, 116 }, { -33, 122 },
00478         { -10,  95 }, { -14, 100 }, {  -8,  95 }, { -17, 111 },
00479         { -28, 114 }, {  -6,  89 }, {  -2,  80 }, {  -4,  82 },
00480         {  -9,  85 }, {  -8,  81 }, {  -1,  72 }, {   5,  64 },
00481         {   1,  67 }, {   9,  56 }, {   0,  69 }, {   1,  69 },
00482         {   7,  69 }, {  -7,  69 }, {  -6,  67 }, { -16,  77 },
00483         {  -2,  64 }, {   2,  61 }, {  -6,  67 }, {  -3,  64 },
00484         {   2,  57 }, {  -3,  65 }, {  -3,  66 }, {   0,  62 },
00485         {   9,  51 }, {  -1,  66 }, {  -2,  71 }, {  -2,  75 },
00486         {  -1,  70 }, {  -9,  72 }, {  14,  60 }, {  16,  37 },
00487         {   0,  47 }, {  18,  35 }, {  11,  37 }, {  12,  41 },
00488         {  10,  41 }, {   2,  48 }, {  12,  41 }, {  13,  41 },
00489         {   0,  59 }, {   3,  50 }, {  19,  40 }, {   3,  66 },
00490         {  18,  50 },
00491 
00492         /* 338 - 398 */
00493         {  19,  -6 }, {  18,  -6 }, {  14,   0 }, {  26, -12 },
00494         {  31, -16 }, {  33, -25 }, {  33, -22 }, {  37, -28 },
00495         {  39, -30 }, {  42, -30 }, {  47, -42 }, {  45, -36 },
00496         {  49, -34 }, {  41, -17 }, {  32,   9 }, {  69, -71 },
00497         {  63, -63 }, {  66, -64 }, {  77, -74 }, {  54, -39 },
00498         {  52, -35 }, {  41, -10 }, {  36,   0 }, {  40,  -1 },
00499         {  30,  14 }, {  28,  26 }, {  23,  37 }, {  12,  55 },
00500         {  11,  65 }, {  37, -33 }, {  39, -36 }, {  40, -37 },
00501         {  38, -30 }, {  46, -33 }, {  42, -30 }, {  40, -24 },
00502         {  49, -29 }, {  38, -12 }, {  40, -10 }, {  38,  -3 },
00503         {  46,  -5 }, {  31,  20 }, {  29,  30 }, {  25,  44 },
00504         {  12,  48 }, {  11,  49 }, {  26,  45 }, {  22,  22 },
00505         {  23,  22 }, {  27,  21 }, {  33,  20 }, {  26,  28 },
00506         {  30,  24 }, {  27,  34 }, {  18,  42 }, {  25,  39 },
00507         {  18,  50 }, {  12,  70 }, {  21,  54 }, {  14,  71 },
00508         {  11,  83 },
00509 
00510         /* 399 - 435 */
00511         {  25,  32 }, {  21,  49 }, {  21,  54 },
00512         {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },
00513         { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },
00514         {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },
00515         { -14,  66 }, {   0,  59 }, {   2,  59 }, {  17, -10 },
00516         {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },
00517         {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },
00518         {  -5,  71 }, {   0,  24 }, {  -1,  36 }, {  -2,  42 },
00519         {  -2,  52 }, {  -9,  57 }, {  -6,  63 }, {  -4,  65 },
00520         {  -4,  67 }, {  -7,  82 },
00521 
00522         /* 436 - 459 */
00523         {  -3,  81 }, {  -3,  76 }, {  -7,  72 }, {  -6,  78 },
00524         { -12,  72 }, { -14,  68 }, {  -3,  70 }, {  -6,  76 },
00525         {  -5,  66 }, {  -5,  62 }, {   0,  57 }, {  -4,  61 },
00526         {  -9,  60 }, {   1,  54 }, {   2,  58 }, {  17, -10 },
00527         {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },
00528         {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },
00529     },
00530 
00531     /* i_cabac_init_idc == 2 */
00532     {
00533         /* 0 - 10 */
00534         {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
00535         {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
00536         {  -6,  53 }, {  -1,  54 }, {   7,  51 },
00537 
00538         /* 11 - 23 */
00539         {  29,  16 }, {  25,   0 }, {  14,   0 }, { -10,  51 },
00540         {  -3,  62 }, { -27,  99 }, {  26,  16 }, {  -4,  85 },
00541         { -24, 102 }, {   5,  57 }, {   6,  57 }, { -17,  73 },
00542         {  14,  57 },
00543 
00544         /* 24 - 39 */
00545         {  20,  40 }, {  20,  10 }, {  29,   0 }, {  54,   0 },
00546         {  37,  42 }, {  12,  97 }, { -32, 127 }, { -22, 117 },
00547         {  -2,  74 }, {  -4,  85 }, { -24, 102 }, {   5,  57 },
00548         {  -6,  93 }, { -14,  88 }, {  -6,  44 }, {   4,  55 },
00549 
00550         /* 40 - 53 */
00551         { -11,  89 },{ -15,  103 },{ -21,  116 },{  19,  57 },
00552         {  20,  58 },{   4,  84 },{   6,  96 },{   1,  63 },
00553         {  -5,  85 },{ -13,  106 },{   5,  63 },{   6,  75 },
00554         {  -3,  90 },{  -1,  101 },
00555 
00556         /* 54 - 59 */
00557         {   3,  55 },{  -4,  79 },{  -2,  75 },{ -12,  97 },
00558         {  -7,  50 },{   1,  60 },
00559 
00560         /* 60 - 69 */
00561         { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
00562         { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
00563         { 13, 41 },  { 3, 62 },
00564 
00565         /* 70 - 104 */
00566         {   7,  34 }, {  -9,  88 }, { -20, 127 }, { -36, 127 },
00567         { -17,  91 }, { -14,  95 }, { -25,  84 }, { -25,  86 },
00568         { -12,  89 }, { -17,  91 }, { -31, 127 }, { -14,  76 },
00569         { -18, 103 }, { -13,  90 }, { -37, 127 }, {  11,  80 },
00570         {   5,  76 }, {   2,  84 }, {   5,  78 }, {  -6,  55 },
00571         {   4,  61 }, { -14,  83 }, { -37, 127 }, {  -5,  79 },
00572         { -11, 104 }, { -11,  91 }, { -30, 127 }, {   0,  65 },
00573         {  -2,  79 }, {   0,  72 }, {  -4,  92 }, {  -6,  56 },
00574         {   3,  68 }, {  -8,  71 }, { -13,  98 },
00575 
00576         /* 105 -> 165 */
00577         {  -4,  86 }, { -12,  88 }, {  -5,  82 }, {  -3,  72 },
00578         {  -4,  67 }, {  -8,  72 }, { -16,  89 }, {  -9,  69 },
00579         {  -1,  59 }, {   5,  66 }, {   4,  57 }, {  -4,  71 },
00580         {  -2,  71 }, {   2,  58 }, {  -1,  74 }, {  -4,  44 },
00581         {  -1,  69 }, {   0,  62 }, {  -7,  51 }, {  -4,  47 },
00582         {  -6,  42 }, {  -3,  41 }, {  -6,  53 }, {   8,  76 },
00583         {  -9,  78 }, { -11,  83 }, {   9,  52 }, {   0,  67 },
00584         {  -5,  90 }, {   1,  67 }, { -15,  72 }, {  -5,  75 },
00585         {  -8,  80 }, { -21,  83 }, { -21,  64 }, { -13,  31 },
00586         { -25,  64 }, { -29,  94 }, {   9,  75 }, {  17,  63 },
00587         {  -8,  74 }, {  -5,  35 }, {  -2,  27 }, {  13,  91 },
00588         {   3,  65 }, {  -7,  69 }, {   8,  77 }, { -10,  66 },
00589         {   3,  62 }, {  -3,  68 }, { -20,  81 }, {   0,  30 },
00590         {   1,   7 }, {  -3,  23 }, { -21,  74 }, {  16,  66 },
00591         { -23, 124 }, {  17,  37 }, {  44, -18 }, {  50, -34 },
00592         { -22, 127 },
00593 
00594         /* 166 - 226 */
00595         {   4,  39 }, {   0,  42 }, {   7,  34 }, {  11,  29 },
00596         {   8,  31 }, {   6,  37 }, {   7,  42 }, {   3,  40 },
00597         {   8,  33 }, {  13,  43 }, {  13,  36 }, {   4,  47 },
00598         {   3,  55 }, {   2,  58 }, {   6,  60 }, {   8,  44 },
00599         {  11,  44 }, {  14,  42 }, {   7,  48 }, {   4,  56 },
00600         {   4,  52 }, {  13,  37 }, {   9,  49 }, {  19,  58 },
00601         {  10,  48 }, {  12,  45 }, {   0,  69 }, {  20,  33 },
00602         {   8,  63 }, {  35, -18 }, {  33, -25 }, {  28,  -3 },
00603         {  24,  10 }, {  27,   0 }, {  34, -14 }, {  52, -44 },
00604         {  39, -24 }, {  19,  17 }, {  31,  25 }, {  36,  29 },
00605         {  24,  33 }, {  34,  15 }, {  30,  20 }, {  22,  73 },
00606         {  20,  34 }, {  19,  31 }, {  27,  44 }, {  19,  16 },
00607         {  15,  36 }, {  15,  36 }, {  21,  28 }, {  25,  21 },
00608         {  30,  20 }, {  31,  12 }, {  27,  16 }, {  24,  42 },
00609         {   0,  93 }, {  14,  56 }, {  15,  57 }, {  26,  38 },
00610         { -24, 127 },
00611 
00612         /* 227 - 275 */
00613         { -24, 115 }, { -22,  82 }, {  -9,  62 }, {   0,  53 },
00614         {   0,  59 }, { -14,  85 }, { -13,  89 }, { -13,  94 },
00615         { -11,  92 }, { -29, 127 }, { -21, 100 }, { -14,  57 },
00616         { -12,  67 }, { -11,  71 }, { -10,  77 }, { -21,  85 },
00617         { -16,  88 }, { -23, 104 }, { -15,  98 }, { -37, 127 },
00618         { -10,  82 }, {  -8,  48 }, {  -8,  61 }, {  -8,  66 },
00619         {  -7,  70 }, { -14,  75 }, { -10,  79 }, {  -9,  83 },
00620         { -12,  92 }, { -18, 108 }, {  -4,  79 }, { -22,  69 },
00621         { -16,  75 }, {  -2,  58 }, {   1,  58 }, { -13,  78 },
00622         {  -9,  83 }, {  -4,  81 }, { -13,  99 }, { -13,  81 },
00623         {  -6,  38 }, { -13,  62 }, {  -6,  58 }, {  -2,  59 },
00624         { -16,  73 }, { -10,  76 }, { -13,  86 }, {  -9,  83 },
00625         { -10,  87 },
00626 
00627         /* 276 a bit special (not used, bypass is used instead) */
00628         { 0, 0 },
00629 
00630         /* 277 - 337 */
00631         { -22, 127 }, { -25, 127 }, { -25, 120 }, { -27, 127 },
00632         { -19, 114 }, { -23, 117 }, { -25, 118 }, { -26, 117 },
00633         { -24, 113 }, { -28, 118 }, { -31, 120 }, { -37, 124 },
00634         { -10,  94 }, { -15, 102 }, { -10,  99 }, { -13, 106 },
00635         { -50, 127 }, {  -5,  92 }, {  17,  57 }, {  -5,  86 },
00636         { -13,  94 }, { -12,  91 }, {  -2,  77 }, {   0,  71 },
00637         {  -1,  73 }, {   4,  64 }, {  -7,  81 }, {   5,  64 },
00638         {  15,  57 }, {   1,  67 }, {   0,  68 }, { -10,  67 },
00639         {   1,  68 }, {   0,  77 }, {   2,  64 }, {   0,  68 },
00640         {  -5,  78 }, {   7,  55 }, {   5,  59 }, {   2,  65 },
00641         {  14,  54 }, {  15,  44 }, {   5,  60 }, {   2,  70 },
00642         {  -2,  76 }, { -18,  86 }, {  12,  70 }, {   5,  64 },
00643         { -12,  70 }, {  11,  55 }, {   5,  56 }, {   0,  69 },
00644         {   2,  65 }, {  -6,  74 }, {   5,  54 }, {   7,  54 },
00645         {  -6,  76 }, { -11,  82 }, {  -2,  77 }, {  -2,  77 },
00646         {  25,  42 },
00647 
00648         /* 338 - 398 */
00649         {  17, -13 }, {  16,  -9 }, {  17, -12 }, {  27, -21 },
00650         {  37, -30 }, {  41, -40 }, {  42, -41 }, {  48, -47 },
00651         {  39, -32 }, {  46, -40 }, {  52, -51 }, {  46, -41 },
00652         {  52, -39 }, {  43, -19 }, {  32,  11 }, {  61, -55 },
00653         {  56, -46 }, {  62, -50 }, {  81, -67 }, {  45, -20 },
00654         {  35,  -2 }, {  28,  15 }, {  34,   1 }, {  39,   1 },
00655         {  30,  17 }, {  20,  38 }, {  18,  45 }, {  15,  54 },
00656         {   0,  79 }, {  36, -16 }, {  37, -14 }, {  37, -17 },
00657         {  32,   1 }, {  34,  15 }, {  29,  15 }, {  24,  25 },
00658         {  34,  22 }, {  31,  16 }, {  35,  18 }, {  31,  28 },
00659         {  33,  41 }, {  36,  28 }, {  27,  47 }, {  21,  62 },
00660         {  18,  31 }, {  19,  26 }, {  36,  24 }, {  24,  23 },
00661         {  27,  16 }, {  24,  30 }, {  31,  29 }, {  22,  41 },
00662         {  22,  42 }, {  16,  60 }, {  15,  52 }, {  14,  60 },
00663         {   3,  78 }, { -16, 123 }, {  21,  53 }, {  22,  56 },
00664         {  25,  61 },
00665 
00666         /* 399 - 435 */
00667         {  21,  33 }, {  19,  50 }, {  17,  61 },
00668         {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },
00669         { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },
00670         { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },
00671         { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },
00672         {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },
00673         {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },
00674         {  -9,  71 }, {  -7,  37 }, {  -8,  44 }, { -11,  49 },
00675         { -10,  56 }, { -12,  59 }, {  -8,  63 }, {  -9,  67 },
00676         {  -6,  68 }, { -10,  79 },
00677 
00678         /* 436 - 459 */
00679         {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },
00680         { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },
00681         { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },
00682         { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },
00683         {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },
00684         {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },
00685     }
00686 };
00687 
00688 void ff_h264_init_cabac_states(H264Context *h) {
00689     MpegEncContext * const s = &h->s;
00690     int i;
00691     const int8_t (*tab)[2];
00692 
00693     if( h->slice_type_nos == FF_I_TYPE ) tab = cabac_context_init_I;
00694     else                                 tab = cabac_context_init_PB[h->cabac_init_idc];
00695 
00696     /* calculate pre-state */
00697     for( i= 0; i < 460; i++ ) {
00698         int pre = 2*(((tab[i][0] * s->qscale) >>4 ) + tab[i][1]) - 127;
00699 
00700         pre^= pre>>31;
00701         if(pre > 124)
00702             pre= 124 + (pre&1);
00703 
00704         h->cabac_state[i] =  pre;
00705     }
00706 }
00707 
00708 static int decode_cabac_field_decoding_flag(H264Context *h) {
00709     MpegEncContext * const s = &h->s;
00710     const long mbb_xy = h->mb_xy - 2L*s->mb_stride;
00711 
00712     unsigned long ctx = 0;
00713 
00714     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);
00715     ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num);
00716 
00717     return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
00718 }
00719 
00720 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
00721     uint8_t *state= &h->cabac_state[ctx_base];
00722     int mb_type;
00723 
00724     if(intra_slice){
00725         int ctx=0;
00726         if( h->left_type[0] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
00727             ctx++;
00728         if( h->top_type     & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
00729             ctx++;
00730         if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
00731             return 0;   /* I4x4 */
00732         state += 2;
00733     }else{
00734         if( get_cabac_noinline( &h->cabac, state ) == 0 )
00735             return 0;   /* I4x4 */
00736     }
00737 
00738     if( get_cabac_terminate( &h->cabac ) )
00739         return 25;  /* PCM */
00740 
00741     mb_type = 1; /* I16x16 */
00742     mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
00743     if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
00744         mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
00745     mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
00746     mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
00747     return mb_type;
00748 }
00749 
00750 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
00751     MpegEncContext * const s = &h->s;
00752     int mba_xy, mbb_xy;
00753     int ctx = 0;
00754 
00755     if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
00756         int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
00757         mba_xy = mb_xy - 1;
00758         if( (mb_y&1)
00759             && h->slice_table[mba_xy] == h->slice_num
00760             && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
00761             mba_xy += s->mb_stride;
00762         if( MB_FIELD ){
00763             mbb_xy = mb_xy - s->mb_stride;
00764             if( !(mb_y&1)
00765                 && h->slice_table[mbb_xy] == h->slice_num
00766                 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
00767                 mbb_xy -= s->mb_stride;
00768         }else
00769             mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
00770     }else{
00771         int mb_xy = h->mb_xy;
00772         mba_xy = mb_xy - 1;
00773         mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
00774     }
00775 
00776     if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
00777         ctx++;
00778     if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
00779         ctx++;
00780 
00781     if( h->slice_type_nos == FF_B_TYPE )
00782         ctx += 13;
00783     return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
00784 }
00785 
00786 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
00787     int mode = 0;
00788 
00789     if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
00790         return pred_mode;
00791 
00792     mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
00793     mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
00794     mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
00795 
00796     return mode + ( mode >= pred_mode );
00797 }
00798 
00799 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
00800     const int mba_xy = h->left_mb_xy[0];
00801     const int mbb_xy = h->top_mb_xy;
00802 
00803     int ctx = 0;
00804 
00805     /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
00806     if( h->left_type[0] && h->chroma_pred_mode_table[mba_xy] != 0 )
00807         ctx++;
00808 
00809     if( h->top_type     && h->chroma_pred_mode_table[mbb_xy] != 0 )
00810         ctx++;
00811 
00812     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
00813         return 0;
00814 
00815     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
00816         return 1;
00817     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
00818         return 2;
00819     else
00820         return 3;
00821 }
00822 
00823 static int decode_cabac_mb_cbp_luma( H264Context *h) {
00824     int cbp_b, cbp_a, ctx, cbp = 0;
00825 
00826     cbp_a = h->left_cbp;
00827     cbp_b = h->top_cbp;
00828 
00829     ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
00830     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
00831     ctx = !(cbp   & 0x01) + 2 * !(cbp_b & 0x08);
00832     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
00833     ctx = !(cbp_a & 0x08) + 2 * !(cbp   & 0x01);
00834     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
00835     ctx = !(cbp   & 0x04) + 2 * !(cbp   & 0x02);
00836     cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
00837     return cbp;
00838 }
00839 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
00840     int ctx;
00841     int cbp_a, cbp_b;
00842 
00843     cbp_a = (h->left_cbp>>4)&0x03;
00844     cbp_b = (h-> top_cbp>>4)&0x03;
00845 
00846     ctx = 0;
00847     if( cbp_a > 0 ) ctx++;
00848     if( cbp_b > 0 ) ctx += 2;
00849     if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
00850         return 0;
00851 
00852     ctx = 4;
00853     if( cbp_a == 2 ) ctx++;
00854     if( cbp_b == 2 ) ctx += 2;
00855     return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
00856 }
00857 
00858 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
00859     if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
00860         return 0;   /* 8x8 */
00861     if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
00862         return 1;   /* 8x4 */
00863     if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
00864         return 2;   /* 4x8 */
00865     return 3;       /* 4x4 */
00866 }
00867 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
00868     int type;
00869     if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
00870         return 0;   /* B_Direct_8x8 */
00871     if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
00872         return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
00873     type = 3;
00874     if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
00875         if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
00876             return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
00877         type += 4;
00878     }
00879     type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
00880     type +=   get_cabac( &h->cabac, &h->cabac_state[39] );
00881     return type;
00882 }
00883 
00884 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
00885     int refa = h->ref_cache[list][scan8[n] - 1];
00886     int refb = h->ref_cache[list][scan8[n] - 8];
00887     int ref  = 0;
00888     int ctx  = 0;
00889 
00890     if( h->slice_type_nos == FF_B_TYPE) {
00891         if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
00892             ctx++;
00893         if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
00894             ctx += 2;
00895     } else {
00896         if( refa > 0 )
00897             ctx++;
00898         if( refb > 0 )
00899             ctx += 2;
00900     }
00901 
00902     while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
00903         ref++;
00904         ctx = (ctx>>2)+4;
00905         if(ref >= 32 /*h->ref_list[list]*/){
00906             return -1;
00907         }
00908     }
00909     return ref;
00910 }
00911 
00912 static int decode_cabac_mb_mvd( H264Context *h, int ctxbase, int amvd, int *mvda) {
00913     int mvd;
00914 
00915     if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+((amvd-3)>>(INT_BIT-1))+((amvd-33)>>(INT_BIT-1))+2])){
00916 //    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){
00917         *mvda= 0;
00918         return 0;
00919     }
00920 
00921     mvd= 1;
00922     ctxbase+= 3;
00923     while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) {
00924         if( mvd < 4 )
00925             ctxbase++;
00926         mvd++;
00927     }
00928 
00929     if( mvd >= 9 ) {
00930         int k = 3;
00931         while( get_cabac_bypass( &h->cabac ) ) {
00932             mvd += 1 << k;
00933             k++;
00934             if(k>24){
00935                 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
00936                 return INT_MIN;
00937             }
00938         }
00939         while( k-- ) {
00940             mvd += get_cabac_bypass( &h->cabac )<<k;
00941         }
00942         *mvda=mvd < 70 ? mvd : 70;
00943     }else
00944         *mvda=mvd;
00945     return get_cabac_bypass_sign( &h->cabac, -mvd );
00946 }
00947 
00948 #define DECODE_CABAC_MB_MVD( h,  list,  n )\
00949 {\
00950     int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\
00951                 h->mvd_cache[list][scan8[n] - 8][0];\
00952     int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\
00953                 h->mvd_cache[list][scan8[n] - 8][1];\
00954 \
00955     mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\
00956     my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\
00957 }
00958 
00959 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
00960     int nza, nzb;
00961     int ctx = 0;
00962 
00963     if( is_dc ) {
00964         if( cat == 0 ) {
00965             nza = h->left_cbp&0x100;
00966             nzb = h-> top_cbp&0x100;
00967         } else {
00968             idx -= CHROMA_DC_BLOCK_INDEX;
00969             nza = (h->left_cbp>>(6+idx))&0x01;
00970             nzb = (h-> top_cbp>>(6+idx))&0x01;
00971         }
00972     } else {
00973         assert(cat == 1 || cat == 2 || cat == 4);
00974         nza = h->non_zero_count_cache[scan8[idx] - 1];
00975         nzb = h->non_zero_count_cache[scan8[idx] - 8];
00976     }
00977 
00978     if( nza > 0 )
00979         ctx++;
00980 
00981     if( nzb > 0 )
00982         ctx += 2;
00983 
00984     return ctx + 4 * cat;
00985 }
00986 
00987 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
00988     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00989     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00990     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
00991     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
00992 };
00993 
00994 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 ) {
00995     static const int significant_coeff_flag_offset[2][6] = {
00996       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
00997       { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
00998     };
00999     static const int last_coeff_flag_offset[2][6] = {
01000       { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
01001       { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
01002     };
01003     static const int coeff_abs_level_m1_offset[6] = {
01004         227+0, 227+10, 227+20, 227+30, 227+39, 426
01005     };
01006     static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
01007       { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
01008         4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
01009         7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
01010        12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
01011       { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
01012         6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
01013         9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
01014         9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
01015     };
01016     /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
01017      * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
01018      * map node ctx => cabac ctx for level=1 */
01019     static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
01020     /* map node ctx => cabac ctx for level>1 */
01021     static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
01022     static const uint8_t coeff_abs_level_transition[2][8] = {
01023     /* update node ctx after decoding a level=1 */
01024         { 1, 2, 3, 3, 4, 5, 6, 7 },
01025     /* update node ctx after decoding a level>1 */
01026         { 4, 4, 4, 4, 5, 6, 7, 7 }
01027     };
01028 
01029     int index[64];
01030 
01031     int av_unused last;
01032     int coeff_count = 0;
01033     int node_ctx = 0;
01034 
01035     uint8_t *significant_coeff_ctx_base;
01036     uint8_t *last_coeff_ctx_base;
01037     uint8_t *abs_level_m1_ctx_base;
01038 
01039 #if !ARCH_X86
01040 #define CABAC_ON_STACK
01041 #endif
01042 #ifdef CABAC_ON_STACK
01043 #define CC &cc
01044     CABACContext cc;
01045     cc.range     = h->cabac.range;
01046     cc.low       = h->cabac.low;
01047     cc.bytestream= h->cabac.bytestream;
01048 #else
01049 #define CC &h->cabac
01050 #endif
01051 
01052     significant_coeff_ctx_base = h->cabac_state
01053         + significant_coeff_flag_offset[MB_FIELD][cat];
01054     last_coeff_ctx_base = h->cabac_state
01055         + last_coeff_flag_offset[MB_FIELD][cat];
01056     abs_level_m1_ctx_base = h->cabac_state
01057         + coeff_abs_level_m1_offset[cat];
01058 
01059     if( !is_dc && cat == 5 ) {
01060 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
01061         for(last= 0; last < coefs; last++) { \
01062             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
01063             if( get_cabac( CC, sig_ctx )) { \
01064                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
01065                 index[coeff_count++] = last; \
01066                 if( get_cabac( CC, last_ctx ) ) { \
01067                     last= max_coeff; \
01068                     break; \
01069                 } \
01070             } \
01071         }\
01072         if( last == max_coeff -1 ) {\
01073             index[coeff_count++] = last;\
01074         }
01075         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
01076 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
01077         coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
01078     } else {
01079         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
01080 #else
01081         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
01082     } else {
01083         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
01084 #endif
01085     }
01086     assert(coeff_count > 0);
01087 
01088     if( is_dc ) {
01089         if( cat == 0 )
01090             h->cbp_table[h->mb_xy] |= 0x100;
01091         else
01092             h->cbp_table[h->mb_xy] |= 0x40 << (n - CHROMA_DC_BLOCK_INDEX);
01093         h->non_zero_count_cache[scan8[n]] = coeff_count;
01094     } else {
01095         if( cat == 5 )
01096             fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
01097         else {
01098             assert( cat == 1 || cat == 2 || cat == 4 );
01099             h->non_zero_count_cache[scan8[n]] = coeff_count;
01100         }
01101     }
01102 
01103     do {
01104         uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
01105 
01106         int j= scantable[index[--coeff_count]];
01107 
01108         if( get_cabac( CC, ctx ) == 0 ) {
01109             node_ctx = coeff_abs_level_transition[0][node_ctx];
01110             if( is_dc ) {
01111                 block[j] = get_cabac_bypass_sign( CC, -1);
01112             }else{
01113                 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
01114             }
01115         } else {
01116             int coeff_abs = 2;
01117             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
01118             node_ctx = coeff_abs_level_transition[1][node_ctx];
01119 
01120             while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
01121                 coeff_abs++;
01122             }
01123 
01124             if( coeff_abs >= 15 ) {
01125                 int j = 0;
01126                 while( get_cabac_bypass( CC ) ) {
01127                     j++;
01128                 }
01129 
01130                 coeff_abs=1;
01131                 while( j-- ) {
01132                     coeff_abs += coeff_abs + get_cabac_bypass( CC );
01133                 }
01134                 coeff_abs+= 14;
01135             }
01136 
01137             if( is_dc ) {
01138                 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
01139             }else{
01140                 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
01141             }
01142         }
01143     } while( coeff_count );
01144 #ifdef CABAC_ON_STACK
01145             h->cabac.range     = cc.range     ;
01146             h->cabac.low       = cc.low       ;
01147             h->cabac.bytestream= cc.bytestream;
01148 #endif
01149 
01150 }
01151 
01152 static void decode_cabac_residual_dc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
01153     decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1);
01154 }
01155 
01156 static void decode_cabac_residual_nondc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
01157     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
01158 }
01159 
01160 /* cat: 0-> DC 16x16  n = 0
01161  *      1-> AC 16x16  n = luma4x4idx
01162  *      2-> Luma4x4   n = luma4x4idx
01163  *      3-> DC Chroma n = iCbCr
01164  *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
01165  *      5-> Luma8x8   n = 4 * luma8x8idx */
01166 
01167 /* Partially inline the CABAC residual decode: inline the coded block flag.
01168  * This has very little impact on binary size and improves performance
01169  * because it allows improved constant propagation into get_cabac_cbf_ctx,
01170  * as well as because most blocks have zero CBFs. */
01171 
01172 static av_always_inline void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
01173     /* read coded block flag */
01174     if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 1 ) ] ) == 0 ) {
01175         h->non_zero_count_cache[scan8[n]] = 0;
01176         return;
01177     }
01178     decode_cabac_residual_dc_internal( h, block, cat, n, scantable, max_coeff );
01179 }
01180 
01181 static av_always_inline void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
01182     /* read coded block flag */
01183     if( cat != 5 && get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 0 ) ] ) == 0 ) {
01184         h->non_zero_count_cache[scan8[n]] = 0;
01185         return;
01186     }
01187     decode_cabac_residual_nondc_internal( h, block, cat, n, scantable, qmul, max_coeff );
01188 }
01189 
01194 int ff_h264_decode_mb_cabac(H264Context *h) {
01195     MpegEncContext * const s = &h->s;
01196     int mb_xy;
01197     int mb_type, partition_count, cbp = 0;
01198     int dct8x8_allowed= h->pps.transform_8x8_mode;
01199 
01200     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
01201 
01202     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
01203     if( h->slice_type_nos != FF_I_TYPE ) {
01204         int skip;
01205         /* a skipped mb needs the aff flag from the following mb */
01206         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
01207             skip = h->next_mb_skipped;
01208         else
01209             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
01210         /* read skip flags */
01211         if( skip ) {
01212             if( FRAME_MBAFF && (s->mb_y&1)==0 ){
01213                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
01214                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
01215                 if(!h->next_mb_skipped)
01216                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
01217             }
01218 
01219             decode_mb_skip(h);
01220 
01221             h->cbp_table[mb_xy] = 0;
01222             h->chroma_pred_mode_table[mb_xy] = 0;
01223             h->last_qscale_diff = 0;
01224 
01225             return 0;
01226 
01227         }
01228     }
01229     if(FRAME_MBAFF){
01230         if( (s->mb_y&1) == 0 )
01231             h->mb_mbaff =
01232             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
01233     }
01234 
01235     h->prev_mb_skipped = 0;
01236 
01237     fill_decode_neighbors(h, -(MB_FIELD));
01238 
01239     if( h->slice_type_nos == FF_B_TYPE ) {
01240         int ctx = 0;
01241         assert(h->slice_type_nos == FF_B_TYPE);
01242 
01243         if( !IS_DIRECT( h->left_type[0]-1 ) )
01244             ctx++;
01245         if( !IS_DIRECT( h->top_type-1 ) )
01246             ctx++;
01247 
01248         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
01249             mb_type= 0; /* B_Direct_16x16 */
01250         }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
01251             mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
01252         }else{
01253             int bits;
01254             bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
01255             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
01256             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
01257             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
01258             if( bits < 8 ){
01259                 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
01260             }else if( bits == 13 ){
01261                 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
01262                 goto decode_intra_mb;
01263             }else if( bits == 14 ){
01264                 mb_type= 11; /* B_L1_L0_8x16 */
01265             }else if( bits == 15 ){
01266                 mb_type= 22; /* B_8x8 */
01267             }else{
01268                 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
01269                 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
01270             }
01271         }
01272             partition_count= b_mb_type_info[mb_type].partition_count;
01273             mb_type=         b_mb_type_info[mb_type].type;
01274     } else if( h->slice_type_nos == FF_P_TYPE ) {
01275         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
01276             /* P-type */
01277             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
01278                 /* P_L0_D16x16, P_8x8 */
01279                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
01280             } else {
01281                 /* P_L0_D8x16, P_L0_D16x8 */
01282                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
01283             }
01284             partition_count= p_mb_type_info[mb_type].partition_count;
01285             mb_type=         p_mb_type_info[mb_type].type;
01286         } else {
01287             mb_type= decode_cabac_intra_mb_type(h, 17, 0);
01288             goto decode_intra_mb;
01289         }
01290     } else {
01291         mb_type= decode_cabac_intra_mb_type(h, 3, 1);
01292         if(h->slice_type == FF_SI_TYPE && mb_type)
01293             mb_type--;
01294         assert(h->slice_type_nos == FF_I_TYPE);
01295 decode_intra_mb:
01296         partition_count = 0;
01297         cbp= i_mb_type_info[mb_type].cbp;
01298         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
01299         mb_type= i_mb_type_info[mb_type].type;
01300     }
01301     if(MB_FIELD)
01302         mb_type |= MB_TYPE_INTERLACED;
01303 
01304     h->slice_table[ mb_xy ]= h->slice_num;
01305 
01306     if(IS_INTRA_PCM(mb_type)) {
01307         const uint8_t *ptr;
01308 
01309         // We assume these blocks are very rare so we do not optimize it.
01310         // FIXME The two following lines get the bitstream position in the cabac
01311         // decode, I think it should be done by a function in cabac.h (or cabac.c).
01312         ptr= h->cabac.bytestream;
01313         if(h->cabac.low&0x1) ptr--;
01314         if(CABAC_BITS==16){
01315             if(h->cabac.low&0x1FF) ptr--;
01316         }
01317 
01318         // The pixels are stored in the same order as levels in h->mb array.
01319         memcpy(h->mb, ptr, 256); ptr+=256;
01320         if(CHROMA){
01321             memcpy(h->mb+128, ptr, 128); ptr+=128;
01322         }
01323 
01324         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
01325 
01326         // All blocks are present
01327         h->cbp_table[mb_xy] = 0x1ef;
01328         h->chroma_pred_mode_table[mb_xy] = 0;
01329         // In deblocking, the quantizer is 0
01330         s->current_picture.qscale_table[mb_xy]= 0;
01331         // All coeffs are present
01332         memset(h->non_zero_count[mb_xy], 16, 32);
01333         s->current_picture.mb_type[mb_xy]= mb_type;
01334         h->last_qscale_diff = 0;
01335         return 0;
01336     }
01337 
01338     if(MB_MBAFF){
01339         h->ref_count[0] <<= 1;
01340         h->ref_count[1] <<= 1;
01341     }
01342 
01343     fill_decode_caches(h, mb_type);
01344 
01345     if( IS_INTRA( mb_type ) ) {
01346         int i, pred_mode;
01347         if( IS_INTRA4x4( mb_type ) ) {
01348             if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
01349                 mb_type |= MB_TYPE_8x8DCT;
01350                 for( i = 0; i < 16; i+=4 ) {
01351                     int pred = pred_intra_mode( h, i );
01352                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
01353                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
01354                 }
01355             } else {
01356                 for( i = 0; i < 16; i++ ) {
01357                     int pred = pred_intra_mode( h, i );
01358                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
01359 
01360                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
01361                 }
01362             }
01363             ff_h264_write_back_intra_pred_mode(h);
01364             if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
01365         } else {
01366             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
01367             if( h->intra16x16_pred_mode < 0 ) return -1;
01368         }
01369         if(CHROMA){
01370             h->chroma_pred_mode_table[mb_xy] =
01371             pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
01372 
01373             pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
01374             if( pred_mode < 0 ) return -1;
01375             h->chroma_pred_mode= pred_mode;
01376         }
01377     } else if( partition_count == 4 ) {
01378         int i, j, sub_partition_count[4], list, ref[2][4];
01379 
01380         if( h->slice_type_nos == FF_B_TYPE ) {
01381             for( i = 0; i < 4; i++ ) {
01382                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
01383                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
01384                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
01385             }
01386             if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
01387                           h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
01388                 ff_h264_pred_direct_motion(h, &mb_type);
01389                 h->ref_cache[0][scan8[4]] =
01390                 h->ref_cache[1][scan8[4]] =
01391                 h->ref_cache[0][scan8[12]] =
01392                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
01393                     for( i = 0; i < 4; i++ )
01394                         fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
01395             }
01396         } else {
01397             for( i = 0; i < 4; i++ ) {
01398                 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
01399                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
01400                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
01401             }
01402         }
01403 
01404         for( list = 0; list < h->list_count; list++ ) {
01405                 for( i = 0; i < 4; i++ ) {
01406                     if(IS_DIRECT(h->sub_mb_type[i])) continue;
01407                     if(IS_DIR(h->sub_mb_type[i], 0, list)){
01408                         if( h->ref_count[list] > 1 ){
01409                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
01410                             if(ref[list][i] >= (unsigned)h->ref_count[list]){
01411                                 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
01412                                 return -1;
01413                             }
01414                         }else
01415                             ref[list][i] = 0;
01416                     } else {
01417                         ref[list][i] = -1;
01418                     }
01419                                                        h->ref_cache[list][ scan8[4*i]+1 ]=
01420                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
01421                 }
01422         }
01423 
01424         if(dct8x8_allowed)
01425             dct8x8_allowed = get_dct8x8_allowed(h);
01426 
01427         for(list=0; list<h->list_count; list++){
01428             for(i=0; i<4; i++){
01429                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
01430                 if(IS_DIRECT(h->sub_mb_type[i])){
01431                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
01432                     continue;
01433                 }
01434 
01435                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
01436                     const int sub_mb_type= h->sub_mb_type[i];
01437                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
01438                     for(j=0; j<sub_partition_count[i]; j++){
01439                         int mpx, mpy;
01440                         int mx, my;
01441                         const int index= 4*i + block_width*j;
01442                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
01443                         uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
01444                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
01445                         DECODE_CABAC_MB_MVD( h, list, index)
01446                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01447 
01448                         if(IS_SUB_8X8(sub_mb_type)){
01449                             mv_cache[ 1 ][0]=
01450                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
01451                             mv_cache[ 1 ][1]=
01452                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
01453 
01454                             mvd_cache[ 1 ][0]=
01455                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
01456                             mvd_cache[ 1 ][1]=
01457                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
01458                         }else if(IS_SUB_8X4(sub_mb_type)){
01459                             mv_cache[ 1 ][0]= mx;
01460                             mv_cache[ 1 ][1]= my;
01461 
01462                             mvd_cache[ 1 ][0]=  mpx;
01463                             mvd_cache[ 1 ][1]= mpy;
01464                         }else if(IS_SUB_4X8(sub_mb_type)){
01465                             mv_cache[ 8 ][0]= mx;
01466                             mv_cache[ 8 ][1]= my;
01467 
01468                             mvd_cache[ 8 ][0]= mpx;
01469                             mvd_cache[ 8 ][1]= mpy;
01470                         }
01471                         mv_cache[ 0 ][0]= mx;
01472                         mv_cache[ 0 ][1]= my;
01473 
01474                         mvd_cache[ 0 ][0]= mpx;
01475                         mvd_cache[ 0 ][1]= mpy;
01476                     }
01477                 }else{
01478                     fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
01479                     fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
01480                 }
01481             }
01482         }
01483     } else if( IS_DIRECT(mb_type) ) {
01484         ff_h264_pred_direct_motion(h, &mb_type);
01485         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
01486         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
01487         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
01488     } else {
01489         int list, i;
01490         if(IS_16X16(mb_type)){
01491             for(list=0; list<h->list_count; list++){
01492                 if(IS_DIR(mb_type, 0, list)){
01493                     int ref;
01494                     if(h->ref_count[list] > 1){
01495                         ref= decode_cabac_mb_ref(h, list, 0);
01496                         if(ref >= (unsigned)h->ref_count[list]){
01497                             av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
01498                             return -1;
01499                         }
01500                     }else
01501                         ref=0;
01502                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
01503                 }
01504             }
01505             for(list=0; list<h->list_count; list++){
01506                 if(IS_DIR(mb_type, 0, list)){
01507                     int mx,my,mpx,mpy;
01508                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
01509                     DECODE_CABAC_MB_MVD( h, list, 0)
01510                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01511 
01512                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
01513                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
01514                 }
01515             }
01516         }
01517         else if(IS_16X8(mb_type)){
01518             for(list=0; list<h->list_count; list++){
01519                     for(i=0; i<2; i++){
01520                         if(IS_DIR(mb_type, i, list)){
01521                             int ref;
01522                             if(h->ref_count[list] > 1){
01523                                 ref= decode_cabac_mb_ref( h, list, 8*i );
01524                                 if(ref >= (unsigned)h->ref_count[list]){
01525                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
01526                                     return -1;
01527                                 }
01528                             }else
01529                                 ref=0;
01530                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
01531                         }else
01532                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
01533                     }
01534             }
01535             for(list=0; list<h->list_count; list++){
01536                 for(i=0; i<2; i++){
01537                     if(IS_DIR(mb_type, i, list)){
01538                         int mx,my,mpx,mpy;
01539                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
01540                         DECODE_CABAC_MB_MVD( h, list, 8*i)
01541                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01542 
01543                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
01544                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
01545                     }else{
01546                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
01547                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
01548                     }
01549                 }
01550             }
01551         }else{
01552             assert(IS_8X16(mb_type));
01553             for(list=0; list<h->list_count; list++){
01554                     for(i=0; i<2; i++){
01555                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
01556                             int ref;
01557                             if(h->ref_count[list] > 1){
01558                                 ref= decode_cabac_mb_ref( h, list, 4*i );
01559                                 if(ref >= (unsigned)h->ref_count[list]){
01560                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
01561                                     return -1;
01562                                 }
01563                             }else
01564                                 ref=0;
01565                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
01566                         }else
01567                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
01568                     }
01569             }
01570             for(list=0; list<h->list_count; list++){
01571                 for(i=0; i<2; i++){
01572                     if(IS_DIR(mb_type, i, list)){
01573                         int mx,my,mpx,mpy;
01574                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
01575                         DECODE_CABAC_MB_MVD( h, list, 4*i)
01576 
01577                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01578                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
01579                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
01580                     }else{
01581                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
01582                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
01583                     }
01584                 }
01585             }
01586         }
01587     }
01588 
01589    if( IS_INTER( mb_type ) ) {
01590         h->chroma_pred_mode_table[mb_xy] = 0;
01591         write_back_motion( h, mb_type );
01592    }
01593 
01594     if( !IS_INTRA16x16( mb_type ) ) {
01595         cbp  = decode_cabac_mb_cbp_luma( h );
01596         if(CHROMA)
01597             cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
01598     }
01599 
01600     h->cbp_table[mb_xy] = h->cbp = cbp;
01601 
01602     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
01603         mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
01604     }
01605     s->current_picture.mb_type[mb_xy]= mb_type;
01606 
01607     if( cbp || IS_INTRA16x16( mb_type ) ) {
01608         const uint8_t *scan, *scan8x8;
01609         const uint32_t *qmul;
01610 
01611         if(IS_INTERLACED(mb_type)){
01612             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
01613             scan= s->qscale ? h->field_scan : h->field_scan_q0;
01614         }else{
01615             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
01616             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
01617         }
01618 
01619         // decode_cabac_mb_dqp
01620         if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
01621             int val = 1;
01622             int ctx= 2;
01623 
01624             while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
01625                 ctx= 3;
01626                 val++;
01627                 if(val > 102){ //prevent infinite loop
01628                     av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
01629                     return -1;
01630                 }
01631             }
01632 
01633             if( val&0x01 )
01634                 val=   (val + 1)>>1 ;
01635             else
01636                 val= -((val + 1)>>1);
01637             h->last_qscale_diff = val;
01638             s->qscale += val;
01639             if(((unsigned)s->qscale) > 51){
01640                 if(s->qscale<0) s->qscale+= 52;
01641                 else            s->qscale-= 52;
01642             }
01643             h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
01644             h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
01645         }else
01646             h->last_qscale_diff=0;
01647 
01648         if( IS_INTRA16x16( mb_type ) ) {
01649             int i;
01650             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
01651             AV_ZERO128(h->mb_luma_dc+0);
01652             AV_ZERO128(h->mb_luma_dc+8);
01653             decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16);
01654 
01655             if( cbp&15 ) {
01656                 qmul = h->dequant4_coeff[0][s->qscale];
01657                 for( i = 0; i < 16; i++ ) {
01658                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
01659                     decode_cabac_residual_nondc(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
01660                 }
01661             } else {
01662                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
01663             }
01664         } else {
01665             int i8x8, i4x4;
01666             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
01667                 if( cbp & (1<<i8x8) ) {
01668                     if( IS_8x8DCT(mb_type) ) {
01669                         decode_cabac_residual_nondc(h, h->mb + 64*i8x8, 5, 4*i8x8,
01670                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
01671                     } else {
01672                         qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
01673                         for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
01674                             const int index = 4*i8x8 + i4x4;
01675                             //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
01676 //START_TIMER
01677                             decode_cabac_residual_nondc(h, h->mb + 16*index, 2, index, scan, qmul, 16);
01678 //STOP_TIMER("decode_residual")
01679                         }
01680                     }
01681                 } else {
01682                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
01683                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
01684                 }
01685             }
01686         }
01687 
01688         if( cbp&0x30 ){
01689             int c;
01690             AV_ZERO128(h->mb_chroma_dc);
01691             for( c = 0; c < 2; c++ ) {
01692                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
01693                 decode_cabac_residual_dc(h, h->mb_chroma_dc[c], 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
01694             }
01695         }
01696 
01697         if( cbp&0x20 ) {
01698             int c, i;
01699             for( c = 0; c < 2; c++ ) {
01700                 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
01701                 for( i = 0; i < 4; i++ ) {
01702                     const int index = 16 + 4 * c + i;
01703                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
01704                     decode_cabac_residual_nondc(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
01705                 }
01706             }
01707         } else {
01708             uint8_t * const nnz= &h->non_zero_count_cache[0];
01709             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
01710             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
01711         }
01712     } else {
01713         uint8_t * const nnz= &h->non_zero_count_cache[0];
01714         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
01715         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
01716         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
01717         h->last_qscale_diff = 0;
01718     }
01719 
01720     s->current_picture.qscale_table[mb_xy]= s->qscale;
01721     write_back_non_zero_count(h);
01722 
01723     if(MB_MBAFF){
01724         h->ref_count[0] >>= 1;
01725         h->ref_count[1] >>= 1;
01726     }
01727 
01728     return 0;
01729 }