00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
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
00044 #include <assert.h>
00045
00046
00047
00048 static const int8_t cabac_context_init_I[460][2] =
00049 {
00050
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
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
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
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
00074 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
00075 { 0, 0 }, { 0, 0 },
00076
00077
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
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
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
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
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
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
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
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
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
00154 { 0, 0 },
00155
00156
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
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
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
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
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
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
00220 {
00221
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
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
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
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
00245 { -7, 67 }, { -5, 74 }, { -4, 74 }, { -5, 80 },
00246 { -7, 72 }, { 1, 58 },
00247
00248
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
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
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
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
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
00316 { 0, 0 },
00317
00318
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
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
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
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
00376 {
00377
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
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
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
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
00401 { -1, 66 },{ -1, 77 },{ 1, 70 },{ -2, 86 },
00402 { -5, 72 },{ 0, 61 },
00403
00404
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
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
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
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
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
00472 { 0, 0 },
00473
00474
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
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
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
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
00532 {
00533
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
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
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
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
00557 { 3, 55 },{ -4, 79 },{ -2, 75 },{ -12, 97 },
00558 { -7, 50 },{ 1, 60 },
00559
00560
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
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
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
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
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
00628 { 0, 0 },
00629
00630
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
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
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
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
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;
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;
00732 state += 2;
00733 }else{
00734 if( get_cabac_noinline( &h->cabac, state ) == 0 )
00735 return 0;
00736 }
00737
00738 if( get_cabac_terminate( &h->cabac ) )
00739 return 25;
00740
00741 mb_type = 1;
00742 mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] );
00743 if( get_cabac_noinline( &h->cabac, &state[2] ) )
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){
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
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;
00861 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
00862 return 1;
00863 if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
00864 return 2;
00865 return 3;
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;
00871 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
00872 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] );
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] );
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 ){
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
00917 *mvda= 0;
00918 return 0;
00919 }
00920
00921 mvd= 1;
00922 ctxbase+= 3;
00923 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) {
00924 if( mvd < 4 )
00925 ctxbase++;
00926 mvd++;
00927 }
00928
00929 if( mvd >= 9 ) {
00930 int k = 3;
00931 while( get_cabac_bypass( &h->cabac ) ) {
00932 mvd += 1 << k;
00933 k++;
00934 if(k>24){
00935 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
00936 return INT_MIN;
00937 }
00938 }
00939 while( k-- ) {
00940 mvd += get_cabac_bypass( &h->cabac )<<k;
00941 }
00942 *mvda=mvd < 70 ? mvd : 70;
00943 }else
00944 *mvda=mvd;
00945 return get_cabac_bypass_sign( &h->cabac, -mvd );
00946 }
00947
00948 #define DECODE_CABAC_MB_MVD( h, list, n )\
00949 {\
00950 int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\
00951 h->mvd_cache[list][scan8[n] - 8][0];\
00952 int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\
00953 h->mvd_cache[list][scan8[n] - 8][1];\
00954 \
00955 mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\
00956 my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\
00957 }
00958
00959 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
00960 int nza, nzb;
00961 int ctx = 0;
00962
00963 if( is_dc ) {
00964 if( cat == 0 ) {
00965 nza = h->left_cbp&0x100;
00966 nzb = h-> top_cbp&0x100;
00967 } else {
00968 idx -= CHROMA_DC_BLOCK_INDEX;
00969 nza = (h->left_cbp>>(6+idx))&0x01;
00970 nzb = (h-> top_cbp>>(6+idx))&0x01;
00971 }
00972 } else {
00973 assert(cat == 1 || cat == 2 || cat == 4);
00974 nza = h->non_zero_count_cache[scan8[idx] - 1];
00975 nzb = h->non_zero_count_cache[scan8[idx] - 8];
00976 }
00977
00978 if( nza > 0 )
00979 ctx++;
00980
00981 if( nzb > 0 )
00982 ctx += 2;
00983
00984 return ctx + 4 * cat;
00985 }
00986
00987 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
00988 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00989 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00990 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
00991 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
00992 };
00993
00994 static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {
00995 static const int significant_coeff_flag_offset[2][6] = {
00996 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
00997 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
00998 };
00999 static const int last_coeff_flag_offset[2][6] = {
01000 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
01001 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
01002 };
01003 static const int coeff_abs_level_m1_offset[6] = {
01004 227+0, 227+10, 227+20, 227+30, 227+39, 426
01005 };
01006 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
01007 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
01008 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
01009 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
01010 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
01011 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
01012 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
01013 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
01014 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
01015 };
01016
01017
01018
01019 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
01020
01021 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
01022 static const uint8_t coeff_abs_level_transition[2][8] = {
01023
01024 { 1, 2, 3, 3, 4, 5, 6, 7 },
01025
01026 { 4, 4, 4, 4, 5, 6, 7, 7 }
01027 };
01028
01029 int index[64];
01030
01031 int av_unused last;
01032 int coeff_count = 0;
01033 int node_ctx = 0;
01034
01035 uint8_t *significant_coeff_ctx_base;
01036 uint8_t *last_coeff_ctx_base;
01037 uint8_t *abs_level_m1_ctx_base;
01038
01039 #if !ARCH_X86
01040 #define CABAC_ON_STACK
01041 #endif
01042 #ifdef CABAC_ON_STACK
01043 #define CC &cc
01044 CABACContext cc;
01045 cc.range = h->cabac.range;
01046 cc.low = h->cabac.low;
01047 cc.bytestream= h->cabac.bytestream;
01048 #else
01049 #define CC &h->cabac
01050 #endif
01051
01052 significant_coeff_ctx_base = h->cabac_state
01053 + significant_coeff_flag_offset[MB_FIELD][cat];
01054 last_coeff_ctx_base = h->cabac_state
01055 + last_coeff_flag_offset[MB_FIELD][cat];
01056 abs_level_m1_ctx_base = h->cabac_state
01057 + coeff_abs_level_m1_offset[cat];
01058
01059 if( !is_dc && cat == 5 ) {
01060 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
01061 for(last= 0; last < coefs; last++) { \
01062 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
01063 if( get_cabac( CC, sig_ctx )) { \
01064 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
01065 index[coeff_count++] = last; \
01066 if( get_cabac( CC, last_ctx ) ) { \
01067 last= max_coeff; \
01068 break; \
01069 } \
01070 } \
01071 }\
01072 if( last == max_coeff -1 ) {\
01073 index[coeff_count++] = last;\
01074 }
01075 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
01076 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
01077 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
01078 } else {
01079 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
01080 #else
01081 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
01082 } else {
01083 DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
01084 #endif
01085 }
01086 assert(coeff_count > 0);
01087
01088 if( is_dc ) {
01089 if( cat == 0 )
01090 h->cbp_table[h->mb_xy] |= 0x100;
01091 else
01092 h->cbp_table[h->mb_xy] |= 0x40 << (n - CHROMA_DC_BLOCK_INDEX);
01093 h->non_zero_count_cache[scan8[n]] = coeff_count;
01094 } else {
01095 if( cat == 5 )
01096 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
01097 else {
01098 assert( cat == 1 || cat == 2 || cat == 4 );
01099 h->non_zero_count_cache[scan8[n]] = coeff_count;
01100 }
01101 }
01102
01103 do {
01104 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
01105
01106 int j= scantable[index[--coeff_count]];
01107
01108 if( get_cabac( CC, ctx ) == 0 ) {
01109 node_ctx = coeff_abs_level_transition[0][node_ctx];
01110 if( is_dc ) {
01111 block[j] = get_cabac_bypass_sign( CC, -1);
01112 }else{
01113 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
01114 }
01115 } else {
01116 int coeff_abs = 2;
01117 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
01118 node_ctx = coeff_abs_level_transition[1][node_ctx];
01119
01120 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
01121 coeff_abs++;
01122 }
01123
01124 if( coeff_abs >= 15 ) {
01125 int j = 0;
01126 while( get_cabac_bypass( CC ) ) {
01127 j++;
01128 }
01129
01130 coeff_abs=1;
01131 while( j-- ) {
01132 coeff_abs += coeff_abs + get_cabac_bypass( CC );
01133 }
01134 coeff_abs+= 14;
01135 }
01136
01137 if( is_dc ) {
01138 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
01139 }else{
01140 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
01141 }
01142 }
01143 } while( coeff_count );
01144 #ifdef CABAC_ON_STACK
01145 h->cabac.range = cc.range ;
01146 h->cabac.low = cc.low ;
01147 h->cabac.bytestream= cc.bytestream;
01148 #endif
01149
01150 }
01151
01152 static void decode_cabac_residual_dc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
01153 decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1);
01154 }
01155
01156 static void decode_cabac_residual_nondc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
01157 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
01158 }
01159
01160
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170
01171
01172 static av_always_inline void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
01173
01174 if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 1 ) ] ) == 0 ) {
01175 h->non_zero_count_cache[scan8[n]] = 0;
01176 return;
01177 }
01178 decode_cabac_residual_dc_internal( h, block, cat, n, scantable, max_coeff );
01179 }
01180
01181 static av_always_inline void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
01182
01183 if( cat != 5 && get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 0 ) ] ) == 0 ) {
01184 h->non_zero_count_cache[scan8[n]] = 0;
01185 return;
01186 }
01187 decode_cabac_residual_nondc_internal( h, block, cat, n, scantable, qmul, max_coeff );
01188 }
01189
01194 int ff_h264_decode_mb_cabac(H264Context *h) {
01195 MpegEncContext * const s = &h->s;
01196 int mb_xy;
01197 int mb_type, partition_count, cbp = 0;
01198 int dct8x8_allowed= h->pps.transform_8x8_mode;
01199
01200 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
01201
01202 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
01203 if( h->slice_type_nos != FF_I_TYPE ) {
01204 int skip;
01205
01206 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
01207 skip = h->next_mb_skipped;
01208 else
01209 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
01210
01211 if( skip ) {
01212 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
01213 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
01214 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
01215 if(!h->next_mb_skipped)
01216 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
01217 }
01218
01219 decode_mb_skip(h);
01220
01221 h->cbp_table[mb_xy] = 0;
01222 h->chroma_pred_mode_table[mb_xy] = 0;
01223 h->last_qscale_diff = 0;
01224
01225 return 0;
01226
01227 }
01228 }
01229 if(FRAME_MBAFF){
01230 if( (s->mb_y&1) == 0 )
01231 h->mb_mbaff =
01232 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
01233 }
01234
01235 h->prev_mb_skipped = 0;
01236
01237 fill_decode_neighbors(h, -(MB_FIELD));
01238
01239 if( h->slice_type_nos == FF_B_TYPE ) {
01240 int ctx = 0;
01241 assert(h->slice_type_nos == FF_B_TYPE);
01242
01243 if( !IS_DIRECT( h->left_type[0]-1 ) )
01244 ctx++;
01245 if( !IS_DIRECT( h->top_type-1 ) )
01246 ctx++;
01247
01248 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
01249 mb_type= 0;
01250 }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
01251 mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
01252 }else{
01253 int bits;
01254 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
01255 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
01256 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
01257 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
01258 if( bits < 8 ){
01259 mb_type= bits + 3;
01260 }else if( bits == 13 ){
01261 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
01262 goto decode_intra_mb;
01263 }else if( bits == 14 ){
01264 mb_type= 11;
01265 }else if( bits == 15 ){
01266 mb_type= 22;
01267 }else{
01268 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
01269 mb_type= bits - 4;
01270 }
01271 }
01272 partition_count= b_mb_type_info[mb_type].partition_count;
01273 mb_type= b_mb_type_info[mb_type].type;
01274 } else if( h->slice_type_nos == FF_P_TYPE ) {
01275 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
01276
01277 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
01278
01279 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
01280 } else {
01281
01282 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
01283 }
01284 partition_count= p_mb_type_info[mb_type].partition_count;
01285 mb_type= p_mb_type_info[mb_type].type;
01286 } else {
01287 mb_type= decode_cabac_intra_mb_type(h, 17, 0);
01288 goto decode_intra_mb;
01289 }
01290 } else {
01291 mb_type= decode_cabac_intra_mb_type(h, 3, 1);
01292 if(h->slice_type == FF_SI_TYPE && mb_type)
01293 mb_type--;
01294 assert(h->slice_type_nos == FF_I_TYPE);
01295 decode_intra_mb:
01296 partition_count = 0;
01297 cbp= i_mb_type_info[mb_type].cbp;
01298 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
01299 mb_type= i_mb_type_info[mb_type].type;
01300 }
01301 if(MB_FIELD)
01302 mb_type |= MB_TYPE_INTERLACED;
01303
01304 h->slice_table[ mb_xy ]= h->slice_num;
01305
01306 if(IS_INTRA_PCM(mb_type)) {
01307 const uint8_t *ptr;
01308
01309
01310
01311
01312 ptr= h->cabac.bytestream;
01313 if(h->cabac.low&0x1) ptr--;
01314 if(CABAC_BITS==16){
01315 if(h->cabac.low&0x1FF) ptr--;
01316 }
01317
01318
01319 memcpy(h->mb, ptr, 256); ptr+=256;
01320 if(CHROMA){
01321 memcpy(h->mb+128, ptr, 128); ptr+=128;
01322 }
01323
01324 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
01325
01326
01327 h->cbp_table[mb_xy] = 0x1ef;
01328 h->chroma_pred_mode_table[mb_xy] = 0;
01329
01330 s->current_picture.qscale_table[mb_xy]= 0;
01331
01332 memset(h->non_zero_count[mb_xy], 16, 32);
01333 s->current_picture.mb_type[mb_xy]= mb_type;
01334 h->last_qscale_diff = 0;
01335 return 0;
01336 }
01337
01338 if(MB_MBAFF){
01339 h->ref_count[0] <<= 1;
01340 h->ref_count[1] <<= 1;
01341 }
01342
01343 fill_decode_caches(h, mb_type);
01344
01345 if( IS_INTRA( mb_type ) ) {
01346 int i, pred_mode;
01347 if( IS_INTRA4x4( mb_type ) ) {
01348 if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
01349 mb_type |= MB_TYPE_8x8DCT;
01350 for( i = 0; i < 16; i+=4 ) {
01351 int pred = pred_intra_mode( h, i );
01352 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
01353 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
01354 }
01355 } else {
01356 for( i = 0; i < 16; i++ ) {
01357 int pred = pred_intra_mode( h, i );
01358 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
01359
01360
01361 }
01362 }
01363 ff_h264_write_back_intra_pred_mode(h);
01364 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
01365 } else {
01366 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
01367 if( h->intra16x16_pred_mode < 0 ) return -1;
01368 }
01369 if(CHROMA){
01370 h->chroma_pred_mode_table[mb_xy] =
01371 pred_mode = decode_cabac_mb_chroma_pre_mode( h );
01372
01373 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
01374 if( pred_mode < 0 ) return -1;
01375 h->chroma_pred_mode= pred_mode;
01376 } else {
01377 h->chroma_pred_mode= DC_128_PRED8x8;
01378 }
01379 } else if( partition_count == 4 ) {
01380 int i, j, sub_partition_count[4], list, ref[2][4];
01381
01382 if( h->slice_type_nos == FF_B_TYPE ) {
01383 for( i = 0; i < 4; i++ ) {
01384 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
01385 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
01386 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
01387 }
01388 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
01389 h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
01390 ff_h264_pred_direct_motion(h, &mb_type);
01391 h->ref_cache[0][scan8[4]] =
01392 h->ref_cache[1][scan8[4]] =
01393 h->ref_cache[0][scan8[12]] =
01394 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
01395 for( i = 0; i < 4; i++ )
01396 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
01397 }
01398 } else {
01399 for( i = 0; i < 4; i++ ) {
01400 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
01401 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
01402 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
01403 }
01404 }
01405
01406 for( list = 0; list < h->list_count; list++ ) {
01407 for( i = 0; i < 4; i++ ) {
01408 if(IS_DIRECT(h->sub_mb_type[i])) continue;
01409 if(IS_DIR(h->sub_mb_type[i], 0, list)){
01410 if( h->ref_count[list] > 1 ){
01411 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
01412 if(ref[list][i] >= (unsigned)h->ref_count[list]){
01413 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
01414 return -1;
01415 }
01416 }else
01417 ref[list][i] = 0;
01418 } else {
01419 ref[list][i] = -1;
01420 }
01421 h->ref_cache[list][ scan8[4*i]+1 ]=
01422 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
01423 }
01424 }
01425
01426 if(dct8x8_allowed)
01427 dct8x8_allowed = get_dct8x8_allowed(h);
01428
01429 for(list=0; list<h->list_count; list++){
01430 for(i=0; i<4; i++){
01431 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
01432 if(IS_DIRECT(h->sub_mb_type[i])){
01433 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
01434 continue;
01435 }
01436
01437 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
01438 const int sub_mb_type= h->sub_mb_type[i];
01439 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
01440 for(j=0; j<sub_partition_count[i]; j++){
01441 int mpx, mpy;
01442 int mx, my;
01443 const int index= 4*i + block_width*j;
01444 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
01445 uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
01446 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
01447 DECODE_CABAC_MB_MVD( h, list, index)
01448 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01449
01450 if(IS_SUB_8X8(sub_mb_type)){
01451 mv_cache[ 1 ][0]=
01452 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
01453 mv_cache[ 1 ][1]=
01454 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
01455
01456 mvd_cache[ 1 ][0]=
01457 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
01458 mvd_cache[ 1 ][1]=
01459 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
01460 }else if(IS_SUB_8X4(sub_mb_type)){
01461 mv_cache[ 1 ][0]= mx;
01462 mv_cache[ 1 ][1]= my;
01463
01464 mvd_cache[ 1 ][0]= mpx;
01465 mvd_cache[ 1 ][1]= mpy;
01466 }else if(IS_SUB_4X8(sub_mb_type)){
01467 mv_cache[ 8 ][0]= mx;
01468 mv_cache[ 8 ][1]= my;
01469
01470 mvd_cache[ 8 ][0]= mpx;
01471 mvd_cache[ 8 ][1]= mpy;
01472 }
01473 mv_cache[ 0 ][0]= mx;
01474 mv_cache[ 0 ][1]= my;
01475
01476 mvd_cache[ 0 ][0]= mpx;
01477 mvd_cache[ 0 ][1]= mpy;
01478 }
01479 }else{
01480 fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
01481 fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
01482 }
01483 }
01484 }
01485 } else if( IS_DIRECT(mb_type) ) {
01486 ff_h264_pred_direct_motion(h, &mb_type);
01487 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
01488 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
01489 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
01490 } else {
01491 int list, i;
01492 if(IS_16X16(mb_type)){
01493 for(list=0; list<h->list_count; list++){
01494 if(IS_DIR(mb_type, 0, list)){
01495 int ref;
01496 if(h->ref_count[list] > 1){
01497 ref= decode_cabac_mb_ref(h, list, 0);
01498 if(ref >= (unsigned)h->ref_count[list]){
01499 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
01500 return -1;
01501 }
01502 }else
01503 ref=0;
01504 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
01505 }
01506 }
01507 for(list=0; list<h->list_count; list++){
01508 if(IS_DIR(mb_type, 0, list)){
01509 int mx,my,mpx,mpy;
01510 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
01511 DECODE_CABAC_MB_MVD( h, list, 0)
01512 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01513
01514 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
01515 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
01516 }
01517 }
01518 }
01519 else if(IS_16X8(mb_type)){
01520 for(list=0; list<h->list_count; list++){
01521 for(i=0; i<2; i++){
01522 if(IS_DIR(mb_type, i, list)){
01523 int ref;
01524 if(h->ref_count[list] > 1){
01525 ref= decode_cabac_mb_ref( h, list, 8*i );
01526 if(ref >= (unsigned)h->ref_count[list]){
01527 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
01528 return -1;
01529 }
01530 }else
01531 ref=0;
01532 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
01533 }else
01534 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
01535 }
01536 }
01537 for(list=0; list<h->list_count; list++){
01538 for(i=0; i<2; i++){
01539 if(IS_DIR(mb_type, i, list)){
01540 int mx,my,mpx,mpy;
01541 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
01542 DECODE_CABAC_MB_MVD( h, list, 8*i)
01543 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01544
01545 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
01546 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
01547 }else{
01548 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
01549 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
01550 }
01551 }
01552 }
01553 }else{
01554 assert(IS_8X16(mb_type));
01555 for(list=0; list<h->list_count; list++){
01556 for(i=0; i<2; i++){
01557 if(IS_DIR(mb_type, i, list)){
01558 int ref;
01559 if(h->ref_count[list] > 1){
01560 ref= decode_cabac_mb_ref( h, list, 4*i );
01561 if(ref >= (unsigned)h->ref_count[list]){
01562 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
01563 return -1;
01564 }
01565 }else
01566 ref=0;
01567 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
01568 }else
01569 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
01570 }
01571 }
01572 for(list=0; list<h->list_count; list++){
01573 for(i=0; i<2; i++){
01574 if(IS_DIR(mb_type, i, list)){
01575 int mx,my,mpx,mpy;
01576 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
01577 DECODE_CABAC_MB_MVD( h, list, 4*i)
01578
01579 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01580 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
01581 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
01582 }else{
01583 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
01584 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
01585 }
01586 }
01587 }
01588 }
01589 }
01590
01591 if( IS_INTER( mb_type ) ) {
01592 h->chroma_pred_mode_table[mb_xy] = 0;
01593 write_back_motion( h, mb_type );
01594 }
01595
01596 if( !IS_INTRA16x16( mb_type ) ) {
01597 cbp = decode_cabac_mb_cbp_luma( h );
01598 if(CHROMA)
01599 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
01600 }
01601
01602 h->cbp_table[mb_xy] = h->cbp = cbp;
01603
01604 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
01605 mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
01606 }
01607 s->current_picture.mb_type[mb_xy]= mb_type;
01608
01609 if( cbp || IS_INTRA16x16( mb_type ) ) {
01610 const uint8_t *scan, *scan8x8;
01611 const uint32_t *qmul;
01612
01613 if(IS_INTERLACED(mb_type)){
01614 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
01615 scan= s->qscale ? h->field_scan : h->field_scan_q0;
01616 }else{
01617 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
01618 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
01619 }
01620
01621
01622 if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
01623 int val = 1;
01624 int ctx= 2;
01625
01626 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
01627 ctx= 3;
01628 val++;
01629 if(val > 102){
01630 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
01631 return -1;
01632 }
01633 }
01634
01635 if( val&0x01 )
01636 val= (val + 1)>>1 ;
01637 else
01638 val= -((val + 1)>>1);
01639 h->last_qscale_diff = val;
01640 s->qscale += val;
01641 if(((unsigned)s->qscale) > 51){
01642 if(s->qscale<0) s->qscale+= 52;
01643 else s->qscale-= 52;
01644 }
01645 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
01646 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
01647 }else
01648 h->last_qscale_diff=0;
01649
01650 if( IS_INTRA16x16( mb_type ) ) {
01651 int i;
01652
01653 AV_ZERO128(h->mb_luma_dc+0);
01654 AV_ZERO128(h->mb_luma_dc+8);
01655 decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16);
01656
01657 if( cbp&15 ) {
01658 qmul = h->dequant4_coeff[0][s->qscale];
01659 for( i = 0; i < 16; i++ ) {
01660
01661 decode_cabac_residual_nondc(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
01662 }
01663 } else {
01664 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
01665 }
01666 } else {
01667 int i8x8, i4x4;
01668 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
01669 if( cbp & (1<<i8x8) ) {
01670 if( IS_8x8DCT(mb_type) ) {
01671 decode_cabac_residual_nondc(h, h->mb + 64*i8x8, 5, 4*i8x8,
01672 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
01673 } else {
01674 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
01675 for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
01676 const int index = 4*i8x8 + i4x4;
01677
01678
01679 decode_cabac_residual_nondc(h, h->mb + 16*index, 2, index, scan, qmul, 16);
01680
01681 }
01682 }
01683 } else {
01684 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
01685 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
01686 }
01687 }
01688 }
01689
01690 if( cbp&0x30 ){
01691 int c;
01692 for( c = 0; c < 2; c++ ) {
01693
01694 decode_cabac_residual_dc(h, h->mb + 256 + 16*4*c, 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
01695 }
01696 }
01697
01698 if( cbp&0x20 ) {
01699 int c, i;
01700 for( c = 0; c < 2; c++ ) {
01701 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
01702 for( i = 0; i < 4; i++ ) {
01703 const int index = 16 + 4 * c + i;
01704
01705 decode_cabac_residual_nondc(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
01706 }
01707 }
01708 } else {
01709 uint8_t * const nnz= &h->non_zero_count_cache[0];
01710 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
01711 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
01712 }
01713 } else {
01714 uint8_t * const nnz= &h->non_zero_count_cache[0];
01715 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
01716 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
01717 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
01718 h->last_qscale_diff = 0;
01719 }
01720
01721 s->current_picture.qscale_table[mb_xy]= s->qscale;
01722 write_back_non_zero_count(h);
01723
01724 if(MB_MBAFF){
01725 h->ref_count[0] >>= 1;
01726 h->ref_count[1] >>= 1;
01727 }
01728
01729 return 0;
01730 }