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             nza = (h->left_cbp>>(6+idx))&0x01;
00969             nzb = (h-> top_cbp>>(6+idx))&0x01;
00970         }
00971     } else {
00972         assert(cat == 1 || cat == 2 || cat == 4);
00973         nza = h->non_zero_count_cache[scan8[idx] - 1];
00974         nzb = h->non_zero_count_cache[scan8[idx] - 8];
00975     }
00976 
00977     if( nza > 0 )
00978         ctx++;
00979 
00980     if( nzb > 0 )
00981         ctx += 2;
00982 
00983     return ctx + 4 * cat;
00984 }
00985 
00986 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
00987     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00988     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00989     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
00990     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
00991 };
00992 
00993 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 ) {
00994     static const int significant_coeff_flag_offset[2][6] = {
00995       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
00996       { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
00997     };
00998     static const int last_coeff_flag_offset[2][6] = {
00999       { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
01000       { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
01001     };
01002     static const int coeff_abs_level_m1_offset[6] = {
01003         227+0, 227+10, 227+20, 227+30, 227+39, 426
01004     };
01005     static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
01006       { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
01007         4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
01008         7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
01009        12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
01010       { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
01011         6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
01012         9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
01013         9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
01014     };
01015     /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
01016      * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
01017      * map node ctx => cabac ctx for level=1 */
01018     static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
01019     /* map node ctx => cabac ctx for level>1 */
01020     static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
01021     static const uint8_t coeff_abs_level_transition[2][8] = {
01022     /* update node ctx after decoding a level=1 */
01023         { 1, 2, 3, 3, 4, 5, 6, 7 },
01024     /* update node ctx after decoding a level>1 */
01025         { 4, 4, 4, 4, 5, 6, 7, 7 }
01026     };
01027 
01028     int index[64];
01029 
01030     int av_unused last;
01031     int coeff_count = 0;
01032     int node_ctx = 0;
01033 
01034     uint8_t *significant_coeff_ctx_base;
01035     uint8_t *last_coeff_ctx_base;
01036     uint8_t *abs_level_m1_ctx_base;
01037 
01038 #if !ARCH_X86
01039 #define CABAC_ON_STACK
01040 #endif
01041 #ifdef CABAC_ON_STACK
01042 #define CC &cc
01043     CABACContext cc;
01044     cc.range     = h->cabac.range;
01045     cc.low       = h->cabac.low;
01046     cc.bytestream= h->cabac.bytestream;
01047 #else
01048 #define CC &h->cabac
01049 #endif
01050 
01051 
01052     /* cat: 0-> DC 16x16  n = 0
01053      *      1-> AC 16x16  n = luma4x4idx
01054      *      2-> Luma4x4   n = luma4x4idx
01055      *      3-> DC Chroma n = iCbCr
01056      *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
01057      *      5-> Luma8x8   n = 4 * luma8x8idx
01058      */
01059 
01060     /* read coded block flag */
01061     if( is_dc || cat != 5 ) {
01062         if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
01063             if( !is_dc )
01064                 h->non_zero_count_cache[scan8[n]] = 0;
01065 
01066 #ifdef CABAC_ON_STACK
01067             h->cabac.range     = cc.range     ;
01068             h->cabac.low       = cc.low       ;
01069             h->cabac.bytestream= cc.bytestream;
01070 #endif
01071             return;
01072         }
01073     }
01074 
01075     significant_coeff_ctx_base = h->cabac_state
01076         + significant_coeff_flag_offset[MB_FIELD][cat];
01077     last_coeff_ctx_base = h->cabac_state
01078         + last_coeff_flag_offset[MB_FIELD][cat];
01079     abs_level_m1_ctx_base = h->cabac_state
01080         + coeff_abs_level_m1_offset[cat];
01081 
01082     if( !is_dc && cat == 5 ) {
01083 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
01084         for(last= 0; last < coefs; last++) { \
01085             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
01086             if( get_cabac( CC, sig_ctx )) { \
01087                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
01088                 index[coeff_count++] = last; \
01089                 if( get_cabac( CC, last_ctx ) ) { \
01090                     last= max_coeff; \
01091                     break; \
01092                 } \
01093             } \
01094         }\
01095         if( last == max_coeff -1 ) {\
01096             index[coeff_count++] = last;\
01097         }
01098         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
01099 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
01100         coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
01101     } else {
01102         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
01103 #else
01104         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
01105     } else {
01106         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
01107 #endif
01108     }
01109     assert(coeff_count > 0);
01110 
01111     if( is_dc ) {
01112         if( cat == 0 )
01113             h->cbp_table[h->mb_xy] |= 0x100;
01114         else
01115             h->cbp_table[h->mb_xy] |= 0x40 << n;
01116     } else {
01117         if( cat == 5 )
01118             fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
01119         else {
01120             assert( cat == 1 || cat == 2 || cat == 4 );
01121             h->non_zero_count_cache[scan8[n]] = coeff_count;
01122         }
01123     }
01124 
01125     do {
01126         uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
01127 
01128         int j= scantable[index[--coeff_count]];
01129 
01130         if( get_cabac( CC, ctx ) == 0 ) {
01131             node_ctx = coeff_abs_level_transition[0][node_ctx];
01132             if( is_dc ) {
01133                 block[j] = get_cabac_bypass_sign( CC, -1);
01134             }else{
01135                 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
01136             }
01137         } else {
01138             int coeff_abs = 2;
01139             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
01140             node_ctx = coeff_abs_level_transition[1][node_ctx];
01141 
01142             while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
01143                 coeff_abs++;
01144             }
01145 
01146             if( coeff_abs >= 15 ) {
01147                 int j = 0;
01148                 while( get_cabac_bypass( CC ) ) {
01149                     j++;
01150                 }
01151 
01152                 coeff_abs=1;
01153                 while( j-- ) {
01154                     coeff_abs += coeff_abs + get_cabac_bypass( CC );
01155                 }
01156                 coeff_abs+= 14;
01157             }
01158 
01159             if( is_dc ) {
01160                 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
01161             }else{
01162                 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
01163             }
01164         }
01165     } while( coeff_count );
01166 #ifdef CABAC_ON_STACK
01167             h->cabac.range     = cc.range     ;
01168             h->cabac.low       = cc.low       ;
01169             h->cabac.bytestream= cc.bytestream;
01170 #endif
01171 
01172 }
01173 
01174 static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
01175     decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1);
01176 }
01177 
01178 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 ) {
01179     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
01180 }
01181 
01186 int ff_h264_decode_mb_cabac(H264Context *h) {
01187     MpegEncContext * const s = &h->s;
01188     int mb_xy;
01189     int mb_type, partition_count, cbp = 0;
01190     int dct8x8_allowed= h->pps.transform_8x8_mode;
01191 
01192     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
01193 
01194     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
01195     if( h->slice_type_nos != FF_I_TYPE ) {
01196         int skip;
01197         /* a skipped mb needs the aff flag from the following mb */
01198         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
01199             skip = h->next_mb_skipped;
01200         else
01201             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
01202         /* read skip flags */
01203         if( skip ) {
01204             if( FRAME_MBAFF && (s->mb_y&1)==0 ){
01205                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
01206                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
01207                 if(!h->next_mb_skipped)
01208                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
01209             }
01210 
01211             decode_mb_skip(h);
01212 
01213             h->cbp_table[mb_xy] = 0;
01214             h->chroma_pred_mode_table[mb_xy] = 0;
01215             h->last_qscale_diff = 0;
01216 
01217             return 0;
01218 
01219         }
01220     }
01221     if(FRAME_MBAFF){
01222         if( (s->mb_y&1) == 0 )
01223             h->mb_mbaff =
01224             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
01225     }
01226 
01227     h->prev_mb_skipped = 0;
01228 
01229     fill_decode_neighbors(h, -(MB_FIELD));
01230 
01231     if( h->slice_type_nos == FF_B_TYPE ) {
01232         int ctx = 0;
01233         assert(h->slice_type_nos == FF_B_TYPE);
01234 
01235         if( !IS_DIRECT( h->left_type[0]-1 ) )
01236             ctx++;
01237         if( !IS_DIRECT( h->top_type-1 ) )
01238             ctx++;
01239 
01240         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
01241             mb_type= 0; /* B_Direct_16x16 */
01242         }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
01243             mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
01244         }else{
01245             int bits;
01246             bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
01247             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
01248             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
01249             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
01250             if( bits < 8 ){
01251                 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
01252             }else if( bits == 13 ){
01253                 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
01254                 goto decode_intra_mb;
01255             }else if( bits == 14 ){
01256                 mb_type= 11; /* B_L1_L0_8x16 */
01257             }else if( bits == 15 ){
01258                 mb_type= 22; /* B_8x8 */
01259             }else{
01260                 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
01261                 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
01262             }
01263         }
01264             partition_count= b_mb_type_info[mb_type].partition_count;
01265             mb_type=         b_mb_type_info[mb_type].type;
01266     } else if( h->slice_type_nos == FF_P_TYPE ) {
01267         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
01268             /* P-type */
01269             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
01270                 /* P_L0_D16x16, P_8x8 */
01271                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
01272             } else {
01273                 /* P_L0_D8x16, P_L0_D16x8 */
01274                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
01275             }
01276             partition_count= p_mb_type_info[mb_type].partition_count;
01277             mb_type=         p_mb_type_info[mb_type].type;
01278         } else {
01279             mb_type= decode_cabac_intra_mb_type(h, 17, 0);
01280             goto decode_intra_mb;
01281         }
01282     } else {
01283         mb_type= decode_cabac_intra_mb_type(h, 3, 1);
01284         if(h->slice_type == FF_SI_TYPE && mb_type)
01285             mb_type--;
01286         assert(h->slice_type_nos == FF_I_TYPE);
01287 decode_intra_mb:
01288         partition_count = 0;
01289         cbp= i_mb_type_info[mb_type].cbp;
01290         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
01291         mb_type= i_mb_type_info[mb_type].type;
01292     }
01293     if(MB_FIELD)
01294         mb_type |= MB_TYPE_INTERLACED;
01295 
01296     h->slice_table[ mb_xy ]= h->slice_num;
01297 
01298     if(IS_INTRA_PCM(mb_type)) {
01299         const uint8_t *ptr;
01300 
01301         // We assume these blocks are very rare so we do not optimize it.
01302         // FIXME The two following lines get the bitstream position in the cabac
01303         // decode, I think it should be done by a function in cabac.h (or cabac.c).
01304         ptr= h->cabac.bytestream;
01305         if(h->cabac.low&0x1) ptr--;
01306         if(CABAC_BITS==16){
01307             if(h->cabac.low&0x1FF) ptr--;
01308         }
01309 
01310         // The pixels are stored in the same order as levels in h->mb array.
01311         memcpy(h->mb, ptr, 256); ptr+=256;
01312         if(CHROMA){
01313             memcpy(h->mb+128, ptr, 128); ptr+=128;
01314         }
01315 
01316         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
01317 
01318         // All blocks are present
01319         h->cbp_table[mb_xy] = 0x1ef;
01320         h->chroma_pred_mode_table[mb_xy] = 0;
01321         // In deblocking, the quantizer is 0
01322         s->current_picture.qscale_table[mb_xy]= 0;
01323         // All coeffs are present
01324         memset(h->non_zero_count[mb_xy], 16, 32);
01325         s->current_picture.mb_type[mb_xy]= mb_type;
01326         h->last_qscale_diff = 0;
01327         return 0;
01328     }
01329 
01330     if(MB_MBAFF){
01331         h->ref_count[0] <<= 1;
01332         h->ref_count[1] <<= 1;
01333     }
01334 
01335     fill_decode_caches(h, mb_type);
01336 
01337     if( IS_INTRA( mb_type ) ) {
01338         int i, pred_mode;
01339         if( IS_INTRA4x4( mb_type ) ) {
01340             if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
01341                 mb_type |= MB_TYPE_8x8DCT;
01342                 for( i = 0; i < 16; i+=4 ) {
01343                     int pred = pred_intra_mode( h, i );
01344                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
01345                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
01346                 }
01347             } else {
01348                 for( i = 0; i < 16; i++ ) {
01349                     int pred = pred_intra_mode( h, i );
01350                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
01351 
01352                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
01353                 }
01354             }
01355             ff_h264_write_back_intra_pred_mode(h);
01356             if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
01357         } else {
01358             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
01359             if( h->intra16x16_pred_mode < 0 ) return -1;
01360         }
01361         if(CHROMA){
01362             h->chroma_pred_mode_table[mb_xy] =
01363             pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
01364 
01365             pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
01366             if( pred_mode < 0 ) return -1;
01367             h->chroma_pred_mode= pred_mode;
01368         }
01369     } else if( partition_count == 4 ) {
01370         int i, j, sub_partition_count[4], list, ref[2][4];
01371 
01372         if( h->slice_type_nos == FF_B_TYPE ) {
01373             for( i = 0; i < 4; i++ ) {
01374                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
01375                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
01376                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
01377             }
01378             if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
01379                           h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
01380                 ff_h264_pred_direct_motion(h, &mb_type);
01381                 h->ref_cache[0][scan8[4]] =
01382                 h->ref_cache[1][scan8[4]] =
01383                 h->ref_cache[0][scan8[12]] =
01384                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
01385                     for( i = 0; i < 4; i++ )
01386                         fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
01387             }
01388         } else {
01389             for( i = 0; i < 4; i++ ) {
01390                 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
01391                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
01392                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
01393             }
01394         }
01395 
01396         for( list = 0; list < h->list_count; list++ ) {
01397                 for( i = 0; i < 4; i++ ) {
01398                     if(IS_DIRECT(h->sub_mb_type[i])) continue;
01399                     if(IS_DIR(h->sub_mb_type[i], 0, list)){
01400                         if( h->ref_count[list] > 1 ){
01401                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
01402                             if(ref[list][i] >= (unsigned)h->ref_count[list]){
01403                                 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
01404                                 return -1;
01405                             }
01406                         }else
01407                             ref[list][i] = 0;
01408                     } else {
01409                         ref[list][i] = -1;
01410                     }
01411                                                        h->ref_cache[list][ scan8[4*i]+1 ]=
01412                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
01413                 }
01414         }
01415 
01416         if(dct8x8_allowed)
01417             dct8x8_allowed = get_dct8x8_allowed(h);
01418 
01419         for(list=0; list<h->list_count; list++){
01420             for(i=0; i<4; i++){
01421                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
01422                 if(IS_DIRECT(h->sub_mb_type[i])){
01423                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
01424                     continue;
01425                 }
01426 
01427                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
01428                     const int sub_mb_type= h->sub_mb_type[i];
01429                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
01430                     for(j=0; j<sub_partition_count[i]; j++){
01431                         int mpx, mpy;
01432                         int mx, my;
01433                         const int index= 4*i + block_width*j;
01434                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
01435                         uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
01436                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
01437                         DECODE_CABAC_MB_MVD( h, list, index)
01438                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01439 
01440                         if(IS_SUB_8X8(sub_mb_type)){
01441                             mv_cache[ 1 ][0]=
01442                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
01443                             mv_cache[ 1 ][1]=
01444                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
01445 
01446                             mvd_cache[ 1 ][0]=
01447                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
01448                             mvd_cache[ 1 ][1]=
01449                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
01450                         }else if(IS_SUB_8X4(sub_mb_type)){
01451                             mv_cache[ 1 ][0]= mx;
01452                             mv_cache[ 1 ][1]= my;
01453 
01454                             mvd_cache[ 1 ][0]=  mpx;
01455                             mvd_cache[ 1 ][1]= mpy;
01456                         }else if(IS_SUB_4X8(sub_mb_type)){
01457                             mv_cache[ 8 ][0]= mx;
01458                             mv_cache[ 8 ][1]= my;
01459 
01460                             mvd_cache[ 8 ][0]= mpx;
01461                             mvd_cache[ 8 ][1]= mpy;
01462                         }
01463                         mv_cache[ 0 ][0]= mx;
01464                         mv_cache[ 0 ][1]= my;
01465 
01466                         mvd_cache[ 0 ][0]= mpx;
01467                         mvd_cache[ 0 ][1]= mpy;
01468                     }
01469                 }else{
01470                     fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
01471                     fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
01472                 }
01473             }
01474         }
01475     } else if( IS_DIRECT(mb_type) ) {
01476         ff_h264_pred_direct_motion(h, &mb_type);
01477         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
01478         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
01479         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
01480     } else {
01481         int list, i;
01482         if(IS_16X16(mb_type)){
01483             for(list=0; list<h->list_count; list++){
01484                 if(IS_DIR(mb_type, 0, list)){
01485                     int ref;
01486                     if(h->ref_count[list] > 1){
01487                         ref= decode_cabac_mb_ref(h, list, 0);
01488                         if(ref >= (unsigned)h->ref_count[list]){
01489                             av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
01490                             return -1;
01491                         }
01492                     }else
01493                         ref=0;
01494                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
01495                 }
01496             }
01497             for(list=0; list<h->list_count; list++){
01498                 if(IS_DIR(mb_type, 0, list)){
01499                     int mx,my,mpx,mpy;
01500                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
01501                     DECODE_CABAC_MB_MVD( h, list, 0)
01502                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01503 
01504                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
01505                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
01506                 }
01507             }
01508         }
01509         else if(IS_16X8(mb_type)){
01510             for(list=0; list<h->list_count; list++){
01511                     for(i=0; i<2; i++){
01512                         if(IS_DIR(mb_type, i, list)){
01513                             int ref;
01514                             if(h->ref_count[list] > 1){
01515                                 ref= decode_cabac_mb_ref( h, list, 8*i );
01516                                 if(ref >= (unsigned)h->ref_count[list]){
01517                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
01518                                     return -1;
01519                                 }
01520                             }else
01521                                 ref=0;
01522                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
01523                         }else
01524                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
01525                     }
01526             }
01527             for(list=0; list<h->list_count; list++){
01528                 for(i=0; i<2; i++){
01529                     if(IS_DIR(mb_type, i, list)){
01530                         int mx,my,mpx,mpy;
01531                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
01532                         DECODE_CABAC_MB_MVD( h, list, 8*i)
01533                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01534 
01535                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
01536                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
01537                     }else{
01538                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
01539                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
01540                     }
01541                 }
01542             }
01543         }else{
01544             assert(IS_8X16(mb_type));
01545             for(list=0; list<h->list_count; list++){
01546                     for(i=0; i<2; i++){
01547                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
01548                             int ref;
01549                             if(h->ref_count[list] > 1){
01550                                 ref= decode_cabac_mb_ref( h, list, 4*i );
01551                                 if(ref >= (unsigned)h->ref_count[list]){
01552                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
01553                                     return -1;
01554                                 }
01555                             }else
01556                                 ref=0;
01557                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
01558                         }else
01559                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
01560                     }
01561             }
01562             for(list=0; list<h->list_count; list++){
01563                 for(i=0; i<2; i++){
01564                     if(IS_DIR(mb_type, i, list)){
01565                         int mx,my,mpx,mpy;
01566                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
01567                         DECODE_CABAC_MB_MVD( h, list, 4*i)
01568 
01569                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01570                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
01571                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
01572                     }else{
01573                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
01574                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
01575                     }
01576                 }
01577             }
01578         }
01579     }
01580 
01581    if( IS_INTER( mb_type ) ) {
01582         h->chroma_pred_mode_table[mb_xy] = 0;
01583         write_back_motion( h, mb_type );
01584    }
01585 
01586     if( !IS_INTRA16x16( mb_type ) ) {
01587         cbp  = decode_cabac_mb_cbp_luma( h );
01588         if(CHROMA)
01589             cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
01590     }
01591 
01592     h->cbp_table[mb_xy] = h->cbp = cbp;
01593 
01594     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
01595         mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
01596     }
01597     s->current_picture.mb_type[mb_xy]= mb_type;
01598 
01599     if( cbp || IS_INTRA16x16( mb_type ) ) {
01600         const uint8_t *scan, *scan8x8, *dc_scan;
01601         const uint32_t *qmul;
01602 
01603         if(IS_INTERLACED(mb_type)){
01604             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
01605             scan= s->qscale ? h->field_scan : h->field_scan_q0;
01606             dc_scan= luma_dc_field_scan;
01607         }else{
01608             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
01609             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
01610             dc_scan= luma_dc_zigzag_scan;
01611         }
01612 
01613         // decode_cabac_mb_dqp
01614         if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
01615             int val = 1;
01616             int ctx= 2;
01617 
01618             while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
01619                 ctx= 3;
01620                 val++;
01621                 if(val > 102){ //prevent infinite loop
01622                     av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
01623                     return -1;
01624                 }
01625             }
01626 
01627             if( val&0x01 )
01628                 val=   (val + 1)>>1 ;
01629             else
01630                 val= -((val + 1)>>1);
01631             h->last_qscale_diff = val;
01632             s->qscale += val;
01633             if(((unsigned)s->qscale) > 51){
01634                 if(s->qscale<0) s->qscale+= 52;
01635                 else            s->qscale-= 52;
01636             }
01637             h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
01638             h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
01639         }else
01640             h->last_qscale_diff=0;
01641 
01642         if( IS_INTRA16x16( mb_type ) ) {
01643             int i;
01644             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
01645             decode_cabac_residual_dc( h, h->mb, 0, 0, dc_scan, 16);
01646 
01647             if( cbp&15 ) {
01648                 qmul = h->dequant4_coeff[0][s->qscale];
01649                 for( i = 0; i < 16; i++ ) {
01650                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
01651                     decode_cabac_residual_nondc(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
01652                 }
01653             } else {
01654                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
01655             }
01656         } else {
01657             int i8x8, i4x4;
01658             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
01659                 if( cbp & (1<<i8x8) ) {
01660                     if( IS_8x8DCT(mb_type) ) {
01661                         decode_cabac_residual_nondc(h, h->mb + 64*i8x8, 5, 4*i8x8,
01662                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
01663                     } else {
01664                         qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
01665                         for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
01666                             const int index = 4*i8x8 + i4x4;
01667                             //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
01668 //START_TIMER
01669                             decode_cabac_residual_nondc(h, h->mb + 16*index, 2, index, scan, qmul, 16);
01670 //STOP_TIMER("decode_residual")
01671                         }
01672                     }
01673                 } else {
01674                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
01675                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
01676                 }
01677             }
01678         }
01679 
01680         if( cbp&0x30 ){
01681             int c;
01682             for( c = 0; c < 2; c++ ) {
01683                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
01684                 decode_cabac_residual_dc(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, 4);
01685             }
01686         }
01687 
01688         if( cbp&0x20 ) {
01689             int c, i;
01690             for( c = 0; c < 2; c++ ) {
01691                 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
01692                 for( i = 0; i < 4; i++ ) {
01693                     const int index = 16 + 4 * c + i;
01694                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
01695                     decode_cabac_residual_nondc(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
01696                 }
01697             }
01698         } else {
01699             uint8_t * const nnz= &h->non_zero_count_cache[0];
01700             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
01701             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
01702         }
01703     } else {
01704         uint8_t * const nnz= &h->non_zero_count_cache[0];
01705         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
01706         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
01707         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
01708         h->last_qscale_diff = 0;
01709     }
01710 
01711     s->current_picture.qscale_table[mb_xy]= s->qscale;
01712     write_back_non_zero_count(h);
01713 
01714     if(MB_MBAFF){
01715         h->ref_count[0] >>= 1;
01716         h->ref_count[1] >>= 1;
01717     }
01718 
01719     return 0;
01720 }