Libav
|
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 }