1/* 2 * VP9 compatible video decoder 3 * 4 * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com> 5 * Copyright (C) 2013 Clément Bœsch <u pkh me> 6 * 7 * This file is part of FFmpeg. 8 * 9 * FFmpeg is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU Lesser General Public 11 * License as published by the Free Software Foundation; either 12 * version 2.1 of the License, or (at your option) any later version. 13 * 14 * FFmpeg is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * Lesser General Public License for more details. 18 * 19 * You should have received a copy of the GNU Lesser General Public 20 * License along with FFmpeg; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 22 */ 23 24#include "libavutil/avassert.h" 25 26#include "threadframe.h" 27#include "vp56.h" 28#include "vp9.h" 29#include "vp9data.h" 30#include "vp9dec.h" 31 32static av_always_inline void setctx_2d(uint8_t *ptr, int w, int h, 33 ptrdiff_t stride, int v) 34{ 35 switch (w) { 36 case 1: 37 do { 38 *ptr = v; 39 ptr += stride; 40 } while (--h); 41 break; 42 case 2: { 43 int v16 = v * 0x0101; 44 do { 45 AV_WN16A(ptr, v16); 46 ptr += stride; 47 } while (--h); 48 break; 49 } 50 case 4: { 51 uint32_t v32 = v * 0x01010101; 52 do { 53 AV_WN32A(ptr, v32); 54 ptr += stride; 55 } while (--h); 56 break; 57 } 58 case 8: { 59#if HAVE_FAST_64BIT 60 uint64_t v64 = v * 0x0101010101010101ULL; 61 do { 62 AV_WN64A(ptr, v64); 63 ptr += stride; 64 } while (--h); 65#else 66 uint32_t v32 = v * 0x01010101; 67 do { 68 AV_WN32A(ptr, v32); 69 AV_WN32A(ptr + 4, v32); 70 ptr += stride; 71 } while (--h); 72#endif 73 break; 74 } 75 } 76} 77 78static void decode_mode(VP9TileData *td) 79{ 80 static const uint8_t left_ctx[N_BS_SIZES] = { 81 0x0, 0x8, 0x0, 0x8, 0xc, 0x8, 0xc, 0xe, 0xc, 0xe, 0xf, 0xe, 0xf 82 }; 83 static const uint8_t above_ctx[N_BS_SIZES] = { 84 0x0, 0x0, 0x8, 0x8, 0x8, 0xc, 0xc, 0xc, 0xe, 0xe, 0xe, 0xf, 0xf 85 }; 86 static const uint8_t max_tx_for_bl_bp[N_BS_SIZES] = { 87 TX_32X32, TX_32X32, TX_32X32, TX_32X32, TX_16X16, TX_16X16, 88 TX_16X16, TX_8X8, TX_8X8, TX_8X8, TX_4X4, TX_4X4, TX_4X4 89 }; 90 VP9Context *s = td->s; 91 VP9Block *b = td->b; 92 int row = td->row, col = td->col, row7 = td->row7; 93 enum TxfmMode max_tx = max_tx_for_bl_bp[b->bs]; 94 int bw4 = ff_vp9_bwh_tab[1][b->bs][0], w4 = FFMIN(s->cols - col, bw4); 95 int bh4 = ff_vp9_bwh_tab[1][b->bs][1], h4 = FFMIN(s->rows - row, bh4), y; 96 int have_a = row > 0, have_l = col > td->tile_col_start; 97 int vref, filter_id; 98 99 if (!s->s.h.segmentation.enabled) { 100 b->seg_id = 0; 101 } else if (s->s.h.keyframe || s->s.h.intraonly) { 102 b->seg_id = !s->s.h.segmentation.update_map ? 0 : 103 vp8_rac_get_tree(td->c, ff_vp9_segmentation_tree, s->s.h.segmentation.prob); 104 } else if (!s->s.h.segmentation.update_map || 105 (s->s.h.segmentation.temporal && 106 vp56_rac_get_prob_branchy(td->c, 107 s->s.h.segmentation.pred_prob[s->above_segpred_ctx[col] + 108 td->left_segpred_ctx[row7]]))) { 109 if (!s->s.h.errorres && s->s.frames[REF_FRAME_SEGMAP].segmentation_map) { 110 int pred = 8, x; 111 uint8_t *refsegmap = s->s.frames[REF_FRAME_SEGMAP].segmentation_map; 112 113 if (!s->s.frames[REF_FRAME_SEGMAP].uses_2pass) 114 ff_thread_await_progress(&s->s.frames[REF_FRAME_SEGMAP].tf, row >> 3, 0); 115 for (y = 0; y < h4; y++) { 116 int idx_base = (y + row) * 8 * s->sb_cols + col; 117 for (x = 0; x < w4; x++) 118 pred = FFMIN(pred, refsegmap[idx_base + x]); 119 } 120 av_assert1(pred < 8); 121 b->seg_id = pred; 122 } else { 123 b->seg_id = 0; 124 } 125 126 memset(&s->above_segpred_ctx[col], 1, w4); 127 memset(&td->left_segpred_ctx[row7], 1, h4); 128 } else { 129 b->seg_id = vp8_rac_get_tree(td->c, ff_vp9_segmentation_tree, 130 s->s.h.segmentation.prob); 131 132 memset(&s->above_segpred_ctx[col], 0, w4); 133 memset(&td->left_segpred_ctx[row7], 0, h4); 134 } 135 if (s->s.h.segmentation.enabled && 136 (s->s.h.segmentation.update_map || s->s.h.keyframe || s->s.h.intraonly)) { 137 setctx_2d(&s->s.frames[CUR_FRAME].segmentation_map[row * 8 * s->sb_cols + col], 138 bw4, bh4, 8 * s->sb_cols, b->seg_id); 139 } 140 141 b->skip = s->s.h.segmentation.enabled && 142 s->s.h.segmentation.feat[b->seg_id].skip_enabled; 143 if (!b->skip) { 144 int c = td->left_skip_ctx[row7] + s->above_skip_ctx[col]; 145 b->skip = vp56_rac_get_prob(td->c, s->prob.p.skip[c]); 146 td->counts.skip[c][b->skip]++; 147 } 148 149 if (s->s.h.keyframe || s->s.h.intraonly) { 150 b->intra = 1; 151 } else if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].ref_enabled) { 152 b->intra = !s->s.h.segmentation.feat[b->seg_id].ref_val; 153 } else { 154 int c, bit; 155 156 if (have_a && have_l) { 157 c = s->above_intra_ctx[col] + td->left_intra_ctx[row7]; 158 c += (c == 2); 159 } else { 160 c = have_a ? 2 * s->above_intra_ctx[col] : 161 have_l ? 2 * td->left_intra_ctx[row7] : 0; 162 } 163 bit = vp56_rac_get_prob(td->c, s->prob.p.intra[c]); 164 td->counts.intra[c][bit]++; 165 b->intra = !bit; 166 } 167 168 if ((b->intra || !b->skip) && s->s.h.txfmmode == TX_SWITCHABLE) { 169 int c; 170 if (have_a) { 171 if (have_l) { 172 c = (s->above_skip_ctx[col] ? max_tx : 173 s->above_txfm_ctx[col]) + 174 (td->left_skip_ctx[row7] ? max_tx : 175 td->left_txfm_ctx[row7]) > max_tx; 176 } else { 177 c = s->above_skip_ctx[col] ? 1 : 178 (s->above_txfm_ctx[col] * 2 > max_tx); 179 } 180 } else if (have_l) { 181 c = td->left_skip_ctx[row7] ? 1 : 182 (td->left_txfm_ctx[row7] * 2 > max_tx); 183 } else { 184 c = 1; 185 } 186 switch (max_tx) { 187 case TX_32X32: 188 b->tx = vp56_rac_get_prob(td->c, s->prob.p.tx32p[c][0]); 189 if (b->tx) { 190 b->tx += vp56_rac_get_prob(td->c, s->prob.p.tx32p[c][1]); 191 if (b->tx == 2) 192 b->tx += vp56_rac_get_prob(td->c, s->prob.p.tx32p[c][2]); 193 } 194 td->counts.tx32p[c][b->tx]++; 195 break; 196 case TX_16X16: 197 b->tx = vp56_rac_get_prob(td->c, s->prob.p.tx16p[c][0]); 198 if (b->tx) 199 b->tx += vp56_rac_get_prob(td->c, s->prob.p.tx16p[c][1]); 200 td->counts.tx16p[c][b->tx]++; 201 break; 202 case TX_8X8: 203 b->tx = vp56_rac_get_prob(td->c, s->prob.p.tx8p[c]); 204 td->counts.tx8p[c][b->tx]++; 205 break; 206 case TX_4X4: 207 b->tx = TX_4X4; 208 break; 209 } 210 } else { 211 b->tx = FFMIN(max_tx, s->s.h.txfmmode); 212 } 213 214 if (s->s.h.keyframe || s->s.h.intraonly) { 215 uint8_t *a = &s->above_mode_ctx[col * 2]; 216 uint8_t *l = &td->left_mode_ctx[(row7) << 1]; 217 218 b->comp = 0; 219 if (b->bs > BS_8x8) { 220 // FIXME the memory storage intermediates here aren't really 221 // necessary, they're just there to make the code slightly 222 // simpler for now 223 b->mode[0] = 224 a[0] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 225 ff_vp9_default_kf_ymode_probs[a[0]][l[0]]); 226 if (b->bs != BS_8x4) { 227 b->mode[1] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 228 ff_vp9_default_kf_ymode_probs[a[1]][b->mode[0]]); 229 l[0] = 230 a[1] = b->mode[1]; 231 } else { 232 l[0] = 233 a[1] = 234 b->mode[1] = b->mode[0]; 235 } 236 if (b->bs != BS_4x8) { 237 b->mode[2] = 238 a[0] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 239 ff_vp9_default_kf_ymode_probs[a[0]][l[1]]); 240 if (b->bs != BS_8x4) { 241 b->mode[3] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 242 ff_vp9_default_kf_ymode_probs[a[1]][b->mode[2]]); 243 l[1] = 244 a[1] = b->mode[3]; 245 } else { 246 l[1] = 247 a[1] = 248 b->mode[3] = b->mode[2]; 249 } 250 } else { 251 b->mode[2] = b->mode[0]; 252 l[1] = 253 a[1] = 254 b->mode[3] = b->mode[1]; 255 } 256 } else { 257 b->mode[0] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 258 ff_vp9_default_kf_ymode_probs[*a][*l]); 259 b->mode[3] = 260 b->mode[2] = 261 b->mode[1] = b->mode[0]; 262 // FIXME this can probably be optimized 263 memset(a, b->mode[0], ff_vp9_bwh_tab[0][b->bs][0]); 264 memset(l, b->mode[0], ff_vp9_bwh_tab[0][b->bs][1]); 265 } 266 b->uvmode = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 267 ff_vp9_default_kf_uvmode_probs[b->mode[3]]); 268 } else if (b->intra) { 269 b->comp = 0; 270 if (b->bs > BS_8x8) { 271 b->mode[0] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 272 s->prob.p.y_mode[0]); 273 td->counts.y_mode[0][b->mode[0]]++; 274 if (b->bs != BS_8x4) { 275 b->mode[1] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 276 s->prob.p.y_mode[0]); 277 td->counts.y_mode[0][b->mode[1]]++; 278 } else { 279 b->mode[1] = b->mode[0]; 280 } 281 if (b->bs != BS_4x8) { 282 b->mode[2] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 283 s->prob.p.y_mode[0]); 284 td->counts.y_mode[0][b->mode[2]]++; 285 if (b->bs != BS_8x4) { 286 b->mode[3] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 287 s->prob.p.y_mode[0]); 288 td->counts.y_mode[0][b->mode[3]]++; 289 } else { 290 b->mode[3] = b->mode[2]; 291 } 292 } else { 293 b->mode[2] = b->mode[0]; 294 b->mode[3] = b->mode[1]; 295 } 296 } else { 297 static const uint8_t size_group[10] = { 298 3, 3, 3, 3, 2, 2, 2, 1, 1, 1 299 }; 300 int sz = size_group[b->bs]; 301 302 b->mode[0] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 303 s->prob.p.y_mode[sz]); 304 b->mode[1] = 305 b->mode[2] = 306 b->mode[3] = b->mode[0]; 307 td->counts.y_mode[sz][b->mode[3]]++; 308 } 309 b->uvmode = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree, 310 s->prob.p.uv_mode[b->mode[3]]); 311 td->counts.uv_mode[b->mode[3]][b->uvmode]++; 312 } else { 313 static const uint8_t inter_mode_ctx_lut[14][14] = { 314 { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 }, 315 { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 }, 316 { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 }, 317 { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 }, 318 { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 }, 319 { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 }, 320 { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 }, 321 { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 }, 322 { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 }, 323 { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 }, 324 { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 }, 325 { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 }, 326 { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 0, 3 }, 327 { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 3, 3, 4 }, 328 }; 329 330 if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].ref_enabled) { 331 av_assert2(s->s.h.segmentation.feat[b->seg_id].ref_val != 0); 332 b->comp = 0; 333 b->ref[0] = s->s.h.segmentation.feat[b->seg_id].ref_val - 1; 334 } else { 335 // read comp_pred flag 336 if (s->s.h.comppredmode != PRED_SWITCHABLE) { 337 b->comp = s->s.h.comppredmode == PRED_COMPREF; 338 } else { 339 int c; 340 341 // FIXME add intra as ref=0xff (or -1) to make these easier? 342 if (have_a) { 343 if (have_l) { 344 if (s->above_comp_ctx[col] && td->left_comp_ctx[row7]) { 345 c = 4; 346 } else if (s->above_comp_ctx[col]) { 347 c = 2 + (td->left_intra_ctx[row7] || 348 td->left_ref_ctx[row7] == s->s.h.fixcompref); 349 } else if (td->left_comp_ctx[row7]) { 350 c = 2 + (s->above_intra_ctx[col] || 351 s->above_ref_ctx[col] == s->s.h.fixcompref); 352 } else { 353 c = (!s->above_intra_ctx[col] && 354 s->above_ref_ctx[col] == s->s.h.fixcompref) ^ 355 (!td->left_intra_ctx[row7] && 356 td->left_ref_ctx[row & 7] == s->s.h.fixcompref); 357 } 358 } else { 359 c = s->above_comp_ctx[col] ? 3 : 360 (!s->above_intra_ctx[col] && s->above_ref_ctx[col] == s->s.h.fixcompref); 361 } 362 } else if (have_l) { 363 c = td->left_comp_ctx[row7] ? 3 : 364 (!td->left_intra_ctx[row7] && td->left_ref_ctx[row7] == s->s.h.fixcompref); 365 } else { 366 c = 1; 367 } 368 b->comp = vp56_rac_get_prob(td->c, s->prob.p.comp[c]); 369 td->counts.comp[c][b->comp]++; 370 } 371 372 // read actual references 373 // FIXME probably cache a few variables here to prevent repetitive 374 // memory accesses below 375 if (b->comp) { /* two references */ 376 int fix_idx = s->s.h.signbias[s->s.h.fixcompref], var_idx = !fix_idx, c, bit; 377 378 b->ref[fix_idx] = s->s.h.fixcompref; 379 // FIXME can this codeblob be replaced by some sort of LUT? 380 if (have_a) { 381 if (have_l) { 382 if (s->above_intra_ctx[col]) { 383 if (td->left_intra_ctx[row7]) { 384 c = 2; 385 } else { 386 c = 1 + 2 * (td->left_ref_ctx[row7] != s->s.h.varcompref[1]); 387 } 388 } else if (td->left_intra_ctx[row7]) { 389 c = 1 + 2 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]); 390 } else { 391 int refl = td->left_ref_ctx[row7], refa = s->above_ref_ctx[col]; 392 393 if (refl == refa && refa == s->s.h.varcompref[1]) { 394 c = 0; 395 } else if (!td->left_comp_ctx[row7] && !s->above_comp_ctx[col]) { 396 if ((refa == s->s.h.fixcompref && refl == s->s.h.varcompref[0]) || 397 (refl == s->s.h.fixcompref && refa == s->s.h.varcompref[0])) { 398 c = 4; 399 } else { 400 c = (refa == refl) ? 3 : 1; 401 } 402 } else if (!td->left_comp_ctx[row7]) { 403 if (refa == s->s.h.varcompref[1] && refl != s->s.h.varcompref[1]) { 404 c = 1; 405 } else { 406 c = (refl == s->s.h.varcompref[1] && 407 refa != s->s.h.varcompref[1]) ? 2 : 4; 408 } 409 } else if (!s->above_comp_ctx[col]) { 410 if (refl == s->s.h.varcompref[1] && refa != s->s.h.varcompref[1]) { 411 c = 1; 412 } else { 413 c = (refa == s->s.h.varcompref[1] && 414 refl != s->s.h.varcompref[1]) ? 2 : 4; 415 } 416 } else { 417 c = (refl == refa) ? 4 : 2; 418 } 419 } 420 } else { 421 if (s->above_intra_ctx[col]) { 422 c = 2; 423 } else if (s->above_comp_ctx[col]) { 424 c = 4 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]); 425 } else { 426 c = 3 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]); 427 } 428 } 429 } else if (have_l) { 430 if (td->left_intra_ctx[row7]) { 431 c = 2; 432 } else if (td->left_comp_ctx[row7]) { 433 c = 4 * (td->left_ref_ctx[row7] != s->s.h.varcompref[1]); 434 } else { 435 c = 3 * (td->left_ref_ctx[row7] != s->s.h.varcompref[1]); 436 } 437 } else { 438 c = 2; 439 } 440 bit = vp56_rac_get_prob(td->c, s->prob.p.comp_ref[c]); 441 b->ref[var_idx] = s->s.h.varcompref[bit]; 442 td->counts.comp_ref[c][bit]++; 443 } else /* single reference */ { 444 int bit, c; 445 446 if (have_a && !s->above_intra_ctx[col]) { 447 if (have_l && !td->left_intra_ctx[row7]) { 448 if (td->left_comp_ctx[row7]) { 449 if (s->above_comp_ctx[col]) { 450 c = 1 + (!s->s.h.fixcompref || !td->left_ref_ctx[row7] || 451 !s->above_ref_ctx[col]); 452 } else { 453 c = (3 * !s->above_ref_ctx[col]) + 454 (!s->s.h.fixcompref || !td->left_ref_ctx[row7]); 455 } 456 } else if (s->above_comp_ctx[col]) { 457 c = (3 * !td->left_ref_ctx[row7]) + 458 (!s->s.h.fixcompref || !s->above_ref_ctx[col]); 459 } else { 460 c = 2 * !td->left_ref_ctx[row7] + 2 * !s->above_ref_ctx[col]; 461 } 462 } else if (s->above_intra_ctx[col]) { 463 c = 2; 464 } else if (s->above_comp_ctx[col]) { 465 c = 1 + (!s->s.h.fixcompref || !s->above_ref_ctx[col]); 466 } else { 467 c = 4 * (!s->above_ref_ctx[col]); 468 } 469 } else if (have_l && !td->left_intra_ctx[row7]) { 470 if (td->left_intra_ctx[row7]) { 471 c = 2; 472 } else if (td->left_comp_ctx[row7]) { 473 c = 1 + (!s->s.h.fixcompref || !td->left_ref_ctx[row7]); 474 } else { 475 c = 4 * (!td->left_ref_ctx[row7]); 476 } 477 } else { 478 c = 2; 479 } 480 bit = vp56_rac_get_prob(td->c, s->prob.p.single_ref[c][0]); 481 td->counts.single_ref[c][0][bit]++; 482 if (!bit) { 483 b->ref[0] = 0; 484 } else { 485 // FIXME can this codeblob be replaced by some sort of LUT? 486 if (have_a) { 487 if (have_l) { 488 if (td->left_intra_ctx[row7]) { 489 if (s->above_intra_ctx[col]) { 490 c = 2; 491 } else if (s->above_comp_ctx[col]) { 492 c = 1 + 2 * (s->s.h.fixcompref == 1 || 493 s->above_ref_ctx[col] == 1); 494 } else if (!s->above_ref_ctx[col]) { 495 c = 3; 496 } else { 497 c = 4 * (s->above_ref_ctx[col] == 1); 498 } 499 } else if (s->above_intra_ctx[col]) { 500 if (td->left_intra_ctx[row7]) { 501 c = 2; 502 } else if (td->left_comp_ctx[row7]) { 503 c = 1 + 2 * (s->s.h.fixcompref == 1 || 504 td->left_ref_ctx[row7] == 1); 505 } else if (!td->left_ref_ctx[row7]) { 506 c = 3; 507 } else { 508 c = 4 * (td->left_ref_ctx[row7] == 1); 509 } 510 } else if (s->above_comp_ctx[col]) { 511 if (td->left_comp_ctx[row7]) { 512 if (td->left_ref_ctx[row7] == s->above_ref_ctx[col]) { 513 c = 3 * (s->s.h.fixcompref == 1 || 514 td->left_ref_ctx[row7] == 1); 515 } else { 516 c = 2; 517 } 518 } else if (!td->left_ref_ctx[row7]) { 519 c = 1 + 2 * (s->s.h.fixcompref == 1 || 520 s->above_ref_ctx[col] == 1); 521 } else { 522 c = 3 * (td->left_ref_ctx[row7] == 1) + 523 (s->s.h.fixcompref == 1 || s->above_ref_ctx[col] == 1); 524 } 525 } else if (td->left_comp_ctx[row7]) { 526 if (!s->above_ref_ctx[col]) { 527 c = 1 + 2 * (s->s.h.fixcompref == 1 || 528 td->left_ref_ctx[row7] == 1); 529 } else { 530 c = 3 * (s->above_ref_ctx[col] == 1) + 531 (s->s.h.fixcompref == 1 || td->left_ref_ctx[row7] == 1); 532 } 533 } else if (!s->above_ref_ctx[col]) { 534 if (!td->left_ref_ctx[row7]) { 535 c = 3; 536 } else { 537 c = 4 * (td->left_ref_ctx[row7] == 1); 538 } 539 } else if (!td->left_ref_ctx[row7]) { 540 c = 4 * (s->above_ref_ctx[col] == 1); 541 } else { 542 c = 2 * (td->left_ref_ctx[row7] == 1) + 543 2 * (s->above_ref_ctx[col] == 1); 544 } 545 } else { 546 if (s->above_intra_ctx[col] || 547 (!s->above_comp_ctx[col] && !s->above_ref_ctx[col])) { 548 c = 2; 549 } else if (s->above_comp_ctx[col]) { 550 c = 3 * (s->s.h.fixcompref == 1 || s->above_ref_ctx[col] == 1); 551 } else { 552 c = 4 * (s->above_ref_ctx[col] == 1); 553 } 554 } 555 } else if (have_l) { 556 if (td->left_intra_ctx[row7] || 557 (!td->left_comp_ctx[row7] && !td->left_ref_ctx[row7])) { 558 c = 2; 559 } else if (td->left_comp_ctx[row7]) { 560 c = 3 * (s->s.h.fixcompref == 1 || td->left_ref_ctx[row7] == 1); 561 } else { 562 c = 4 * (td->left_ref_ctx[row7] == 1); 563 } 564 } else { 565 c = 2; 566 } 567 bit = vp56_rac_get_prob(td->c, s->prob.p.single_ref[c][1]); 568 td->counts.single_ref[c][1][bit]++; 569 b->ref[0] = 1 + bit; 570 } 571 } 572 } 573 574 if (b->bs <= BS_8x8) { 575 if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].skip_enabled) { 576 b->mode[0] = 577 b->mode[1] = 578 b->mode[2] = 579 b->mode[3] = ZEROMV; 580 } else { 581 static const uint8_t off[10] = { 582 3, 0, 0, 1, 0, 0, 0, 0, 0, 0 583 }; 584 585 // FIXME this needs to use the LUT tables from find_ref_mvs 586 // because not all are -1,0/0,-1 587 int c = inter_mode_ctx_lut[s->above_mode_ctx[col + off[b->bs]]] 588 [td->left_mode_ctx[row7 + off[b->bs]]]; 589 590 b->mode[0] = vp8_rac_get_tree(td->c, ff_vp9_inter_mode_tree, 591 s->prob.p.mv_mode[c]); 592 b->mode[1] = 593 b->mode[2] = 594 b->mode[3] = b->mode[0]; 595 td->counts.mv_mode[c][b->mode[0] - 10]++; 596 } 597 } 598 599 if (s->s.h.filtermode == FILTER_SWITCHABLE) { 600 int c; 601 602 if (have_a && s->above_mode_ctx[col] >= NEARESTMV) { 603 if (have_l && td->left_mode_ctx[row7] >= NEARESTMV) { 604 c = s->above_filter_ctx[col] == td->left_filter_ctx[row7] ? 605 td->left_filter_ctx[row7] : 3; 606 } else { 607 c = s->above_filter_ctx[col]; 608 } 609 } else if (have_l && td->left_mode_ctx[row7] >= NEARESTMV) { 610 c = td->left_filter_ctx[row7]; 611 } else { 612 c = 3; 613 } 614 615 filter_id = vp8_rac_get_tree(td->c, ff_vp9_filter_tree, 616 s->prob.p.filter[c]); 617 td->counts.filter[c][filter_id]++; 618 b->filter = ff_vp9_filter_lut[filter_id]; 619 } else { 620 b->filter = s->s.h.filtermode; 621 } 622 623 if (b->bs > BS_8x8) { 624 int c = inter_mode_ctx_lut[s->above_mode_ctx[col]][td->left_mode_ctx[row7]]; 625 626 b->mode[0] = vp8_rac_get_tree(td->c, ff_vp9_inter_mode_tree, 627 s->prob.p.mv_mode[c]); 628 td->counts.mv_mode[c][b->mode[0] - 10]++; 629 ff_vp9_fill_mv(td, b->mv[0], b->mode[0], 0); 630 631 if (b->bs != BS_8x4) { 632 b->mode[1] = vp8_rac_get_tree(td->c, ff_vp9_inter_mode_tree, 633 s->prob.p.mv_mode[c]); 634 td->counts.mv_mode[c][b->mode[1] - 10]++; 635 ff_vp9_fill_mv(td, b->mv[1], b->mode[1], 1); 636 } else { 637 b->mode[1] = b->mode[0]; 638 AV_COPY32(&b->mv[1][0], &b->mv[0][0]); 639 AV_COPY32(&b->mv[1][1], &b->mv[0][1]); 640 } 641 642 if (b->bs != BS_4x8) { 643 b->mode[2] = vp8_rac_get_tree(td->c, ff_vp9_inter_mode_tree, 644 s->prob.p.mv_mode[c]); 645 td->counts.mv_mode[c][b->mode[2] - 10]++; 646 ff_vp9_fill_mv(td, b->mv[2], b->mode[2], 2); 647 648 if (b->bs != BS_8x4) { 649 b->mode[3] = vp8_rac_get_tree(td->c, ff_vp9_inter_mode_tree, 650 s->prob.p.mv_mode[c]); 651 td->counts.mv_mode[c][b->mode[3] - 10]++; 652 ff_vp9_fill_mv(td, b->mv[3], b->mode[3], 3); 653 } else { 654 b->mode[3] = b->mode[2]; 655 AV_COPY32(&b->mv[3][0], &b->mv[2][0]); 656 AV_COPY32(&b->mv[3][1], &b->mv[2][1]); 657 } 658 } else { 659 b->mode[2] = b->mode[0]; 660 AV_COPY32(&b->mv[2][0], &b->mv[0][0]); 661 AV_COPY32(&b->mv[2][1], &b->mv[0][1]); 662 b->mode[3] = b->mode[1]; 663 AV_COPY32(&b->mv[3][0], &b->mv[1][0]); 664 AV_COPY32(&b->mv[3][1], &b->mv[1][1]); 665 } 666 } else { 667 ff_vp9_fill_mv(td, b->mv[0], b->mode[0], -1); 668 AV_COPY32(&b->mv[1][0], &b->mv[0][0]); 669 AV_COPY32(&b->mv[2][0], &b->mv[0][0]); 670 AV_COPY32(&b->mv[3][0], &b->mv[0][0]); 671 AV_COPY32(&b->mv[1][1], &b->mv[0][1]); 672 AV_COPY32(&b->mv[2][1], &b->mv[0][1]); 673 AV_COPY32(&b->mv[3][1], &b->mv[0][1]); 674 } 675 676 vref = b->ref[b->comp ? s->s.h.signbias[s->s.h.varcompref[0]] : 0]; 677 } 678 679#if HAVE_FAST_64BIT 680#define SPLAT_CTX(var, val, n) \ 681 switch (n) { \ 682 case 1: var = val; break; \ 683 case 2: AV_WN16A(&var, val * 0x0101); break; \ 684 case 4: AV_WN32A(&var, val * 0x01010101); break; \ 685 case 8: AV_WN64A(&var, val * 0x0101010101010101ULL); break; \ 686 case 16: { \ 687 uint64_t v64 = val * 0x0101010101010101ULL; \ 688 AV_WN64A( &var, v64); \ 689 AV_WN64A(&((uint8_t *) &var)[8], v64); \ 690 break; \ 691 } \ 692 } 693#else 694#define SPLAT_CTX(var, val, n) \ 695 switch (n) { \ 696 case 1: var = val; break; \ 697 case 2: AV_WN16A(&var, val * 0x0101); break; \ 698 case 4: AV_WN32A(&var, val * 0x01010101); break; \ 699 case 8: { \ 700 uint32_t v32 = val * 0x01010101; \ 701 AV_WN32A( &var, v32); \ 702 AV_WN32A(&((uint8_t *) &var)[4], v32); \ 703 break; \ 704 } \ 705 case 16: { \ 706 uint32_t v32 = val * 0x01010101; \ 707 AV_WN32A( &var, v32); \ 708 AV_WN32A(&((uint8_t *) &var)[4], v32); \ 709 AV_WN32A(&((uint8_t *) &var)[8], v32); \ 710 AV_WN32A(&((uint8_t *) &var)[12], v32); \ 711 break; \ 712 } \ 713 } 714#endif 715 716 switch (ff_vp9_bwh_tab[1][b->bs][0]) { 717#define SET_CTXS(perf, dir, off, n) \ 718 do { \ 719 SPLAT_CTX(perf->dir##_skip_ctx[off], b->skip, n); \ 720 SPLAT_CTX(perf->dir##_txfm_ctx[off], b->tx, n); \ 721 SPLAT_CTX(perf->dir##_partition_ctx[off], dir##_ctx[b->bs], n); \ 722 if (!s->s.h.keyframe && !s->s.h.intraonly) { \ 723 SPLAT_CTX(perf->dir##_intra_ctx[off], b->intra, n); \ 724 SPLAT_CTX(perf->dir##_comp_ctx[off], b->comp, n); \ 725 SPLAT_CTX(perf->dir##_mode_ctx[off], b->mode[3], n); \ 726 if (!b->intra) { \ 727 SPLAT_CTX(perf->dir##_ref_ctx[off], vref, n); \ 728 if (s->s.h.filtermode == FILTER_SWITCHABLE) { \ 729 SPLAT_CTX(perf->dir##_filter_ctx[off], filter_id, n); \ 730 } \ 731 } \ 732 } \ 733 } while (0) 734 case 1: SET_CTXS(s, above, col, 1); break; 735 case 2: SET_CTXS(s, above, col, 2); break; 736 case 4: SET_CTXS(s, above, col, 4); break; 737 case 8: SET_CTXS(s, above, col, 8); break; 738 } 739 switch (ff_vp9_bwh_tab[1][b->bs][1]) { 740 case 1: SET_CTXS(td, left, row7, 1); break; 741 case 2: SET_CTXS(td, left, row7, 2); break; 742 case 4: SET_CTXS(td, left, row7, 4); break; 743 case 8: SET_CTXS(td, left, row7, 8); break; 744 } 745#undef SPLAT_CTX 746#undef SET_CTXS 747 748 if (!s->s.h.keyframe && !s->s.h.intraonly) { 749 if (b->bs > BS_8x8) { 750 int mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]); 751 752 AV_COPY32(&td->left_mv_ctx[row7 * 2 + 0][0], &b->mv[1][0]); 753 AV_COPY32(&td->left_mv_ctx[row7 * 2 + 0][1], &b->mv[1][1]); 754 AV_WN32A(&td->left_mv_ctx[row7 * 2 + 1][0], mv0); 755 AV_WN32A(&td->left_mv_ctx[row7 * 2 + 1][1], mv1); 756 AV_COPY32(&s->above_mv_ctx[col * 2 + 0][0], &b->mv[2][0]); 757 AV_COPY32(&s->above_mv_ctx[col * 2 + 0][1], &b->mv[2][1]); 758 AV_WN32A(&s->above_mv_ctx[col * 2 + 1][0], mv0); 759 AV_WN32A(&s->above_mv_ctx[col * 2 + 1][1], mv1); 760 } else { 761 int n, mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]); 762 763 for (n = 0; n < w4 * 2; n++) { 764 AV_WN32A(&s->above_mv_ctx[col * 2 + n][0], mv0); 765 AV_WN32A(&s->above_mv_ctx[col * 2 + n][1], mv1); 766 } 767 for (n = 0; n < h4 * 2; n++) { 768 AV_WN32A(&td->left_mv_ctx[row7 * 2 + n][0], mv0); 769 AV_WN32A(&td->left_mv_ctx[row7 * 2 + n][1], mv1); 770 } 771 } 772 } 773 774 // FIXME kinda ugly 775 for (y = 0; y < h4; y++) { 776 int x, o = (row + y) * s->sb_cols * 8 + col; 777 VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[o]; 778 779 if (b->intra) { 780 for (x = 0; x < w4; x++) { 781 mv[x].ref[0] = 782 mv[x].ref[1] = -1; 783 } 784 } else if (b->comp) { 785 for (x = 0; x < w4; x++) { 786 mv[x].ref[0] = b->ref[0]; 787 mv[x].ref[1] = b->ref[1]; 788 AV_COPY32(&mv[x].mv[0], &b->mv[3][0]); 789 AV_COPY32(&mv[x].mv[1], &b->mv[3][1]); 790 } 791 } else { 792 for (x = 0; x < w4; x++) { 793 mv[x].ref[0] = b->ref[0]; 794 mv[x].ref[1] = -1; 795 AV_COPY32(&mv[x].mv[0], &b->mv[3][0]); 796 } 797 } 798 } 799} 800 801// FIXME merge cnt/eob arguments? 802static av_always_inline int 803decode_coeffs_b_generic(VP56RangeCoder *c, int16_t *coef, int n_coeffs, 804 int is_tx32x32, int is8bitsperpixel, int bpp, unsigned (*cnt)[6][3], 805 unsigned (*eob)[6][2], uint8_t (*p)[6][11], 806 int nnz, const int16_t *scan, const int16_t (*nb)[2], 807 const int16_t *band_counts, int16_t *qmul) 808{ 809 int i = 0, band = 0, band_left = band_counts[band]; 810 const uint8_t *tp = p[0][nnz]; 811 uint8_t cache[1024]; 812 813 do { 814 int val, rc; 815 816 val = vp56_rac_get_prob_branchy(c, tp[0]); // eob 817 eob[band][nnz][val]++; 818 if (!val) 819 break; 820 821skip_eob: 822 if (!vp56_rac_get_prob_branchy(c, tp[1])) { // zero 823 cnt[band][nnz][0]++; 824 if (!--band_left) 825 band_left = band_counts[++band]; 826 cache[scan[i]] = 0; 827 nnz = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1; 828 tp = p[band][nnz]; 829 if (++i == n_coeffs) 830 break; //invalid input; blocks should end with EOB 831 goto skip_eob; 832 } 833 834 rc = scan[i]; 835 if (!vp56_rac_get_prob_branchy(c, tp[2])) { // one 836 cnt[band][nnz][1]++; 837 val = 1; 838 cache[rc] = 1; 839 } else { 840 cnt[band][nnz][2]++; 841 if (!vp56_rac_get_prob_branchy(c, tp[3])) { // 2, 3, 4 842 if (!vp56_rac_get_prob_branchy(c, tp[4])) { 843 cache[rc] = val = 2; 844 } else { 845 val = 3 + vp56_rac_get_prob(c, tp[5]); 846 cache[rc] = 3; 847 } 848 } else if (!vp56_rac_get_prob_branchy(c, tp[6])) { // cat1/2 849 cache[rc] = 4; 850 if (!vp56_rac_get_prob_branchy(c, tp[7])) { 851 val = vp56_rac_get_prob(c, 159) + 5; 852 } else { 853 val = (vp56_rac_get_prob(c, 165) << 1) + 7; 854 val += vp56_rac_get_prob(c, 145); 855 } 856 } else { // cat 3-6 857 cache[rc] = 5; 858 if (!vp56_rac_get_prob_branchy(c, tp[8])) { 859 if (!vp56_rac_get_prob_branchy(c, tp[9])) { 860 val = 11 + (vp56_rac_get_prob(c, 173) << 2); 861 val += (vp56_rac_get_prob(c, 148) << 1); 862 val += vp56_rac_get_prob(c, 140); 863 } else { 864 val = 19 + (vp56_rac_get_prob(c, 176) << 3); 865 val += (vp56_rac_get_prob(c, 155) << 2); 866 val += (vp56_rac_get_prob(c, 140) << 1); 867 val += vp56_rac_get_prob(c, 135); 868 } 869 } else if (!vp56_rac_get_prob_branchy(c, tp[10])) { 870 val = (vp56_rac_get_prob(c, 180) << 4) + 35; 871 val += (vp56_rac_get_prob(c, 157) << 3); 872 val += (vp56_rac_get_prob(c, 141) << 2); 873 val += (vp56_rac_get_prob(c, 134) << 1); 874 val += vp56_rac_get_prob(c, 130); 875 } else { 876 val = 67; 877 if (!is8bitsperpixel) { 878 if (bpp == 12) { 879 val += vp56_rac_get_prob(c, 255) << 17; 880 val += vp56_rac_get_prob(c, 255) << 16; 881 } 882 val += (vp56_rac_get_prob(c, 255) << 15); 883 val += (vp56_rac_get_prob(c, 255) << 14); 884 } 885 val += (vp56_rac_get_prob(c, 254) << 13); 886 val += (vp56_rac_get_prob(c, 254) << 12); 887 val += (vp56_rac_get_prob(c, 254) << 11); 888 val += (vp56_rac_get_prob(c, 252) << 10); 889 val += (vp56_rac_get_prob(c, 249) << 9); 890 val += (vp56_rac_get_prob(c, 243) << 8); 891 val += (vp56_rac_get_prob(c, 230) << 7); 892 val += (vp56_rac_get_prob(c, 196) << 6); 893 val += (vp56_rac_get_prob(c, 177) << 5); 894 val += (vp56_rac_get_prob(c, 153) << 4); 895 val += (vp56_rac_get_prob(c, 140) << 3); 896 val += (vp56_rac_get_prob(c, 133) << 2); 897 val += (vp56_rac_get_prob(c, 130) << 1); 898 val += vp56_rac_get_prob(c, 129); 899 } 900 } 901 } 902#define STORE_COEF(c, i, v) do { \ 903 if (is8bitsperpixel) { \ 904 c[i] = v; \ 905 } else { \ 906 AV_WN32A(&c[i * 2], v); \ 907 } \ 908} while (0) 909 if (!--band_left) 910 band_left = band_counts[++band]; 911 if (is_tx32x32) 912 STORE_COEF(coef, rc, (int)((vp8_rac_get(c) ? -val : val) * (unsigned)qmul[!!i]) / 2); 913 else 914 STORE_COEF(coef, rc, (vp8_rac_get(c) ? -val : val) * (unsigned)qmul[!!i]); 915 nnz = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1; 916 tp = p[band][nnz]; 917 } while (++i < n_coeffs); 918 919 return i; 920} 921 922static int decode_coeffs_b_8bpp(VP9TileData *td, int16_t *coef, int n_coeffs, 923 unsigned (*cnt)[6][3], unsigned (*eob)[6][2], 924 uint8_t (*p)[6][11], int nnz, const int16_t *scan, 925 const int16_t (*nb)[2], const int16_t *band_counts, 926 int16_t *qmul) 927{ 928 return decode_coeffs_b_generic(td->c, coef, n_coeffs, 0, 1, 8, cnt, eob, p, 929 nnz, scan, nb, band_counts, qmul); 930} 931 932static int decode_coeffs_b32_8bpp(VP9TileData *td, int16_t *coef, int n_coeffs, 933 unsigned (*cnt)[6][3], unsigned (*eob)[6][2], 934 uint8_t (*p)[6][11], int nnz, const int16_t *scan, 935 const int16_t (*nb)[2], const int16_t *band_counts, 936 int16_t *qmul) 937{ 938 return decode_coeffs_b_generic(td->c, coef, n_coeffs, 1, 1, 8, cnt, eob, p, 939 nnz, scan, nb, band_counts, qmul); 940} 941 942static int decode_coeffs_b_16bpp(VP9TileData *td, int16_t *coef, int n_coeffs, 943 unsigned (*cnt)[6][3], unsigned (*eob)[6][2], 944 uint8_t (*p)[6][11], int nnz, const int16_t *scan, 945 const int16_t (*nb)[2], const int16_t *band_counts, 946 int16_t *qmul) 947{ 948 return decode_coeffs_b_generic(td->c, coef, n_coeffs, 0, 0, td->s->s.h.bpp, cnt, eob, p, 949 nnz, scan, nb, band_counts, qmul); 950} 951 952static int decode_coeffs_b32_16bpp(VP9TileData *td, int16_t *coef, int n_coeffs, 953 unsigned (*cnt)[6][3], unsigned (*eob)[6][2], 954 uint8_t (*p)[6][11], int nnz, const int16_t *scan, 955 const int16_t (*nb)[2], const int16_t *band_counts, 956 int16_t *qmul) 957{ 958 return decode_coeffs_b_generic(td->c, coef, n_coeffs, 1, 0, td->s->s.h.bpp, cnt, eob, p, 959 nnz, scan, nb, band_counts, qmul); 960} 961 962static av_always_inline int decode_coeffs(VP9TileData *td, int is8bitsperpixel) 963{ 964 VP9Context *s = td->s; 965 VP9Block *b = td->b; 966 int row = td->row, col = td->col; 967 uint8_t (*p)[6][11] = s->prob.coef[b->tx][0 /* y */][!b->intra]; 968 unsigned (*c)[6][3] = td->counts.coef[b->tx][0 /* y */][!b->intra]; 969 unsigned (*e)[6][2] = td->counts.eob[b->tx][0 /* y */][!b->intra]; 970 int w4 = ff_vp9_bwh_tab[1][b->bs][0] << 1, h4 = ff_vp9_bwh_tab[1][b->bs][1] << 1; 971 int end_x = FFMIN(2 * (s->cols - col), w4); 972 int end_y = FFMIN(2 * (s->rows - row), h4); 973 int n, pl, x, y, ret; 974 int16_t (*qmul)[2] = s->s.h.segmentation.feat[b->seg_id].qmul; 975 int tx = 4 * s->s.h.lossless + b->tx; 976 const int16_t * const *yscans = ff_vp9_scans[tx]; 977 const int16_t (* const * ynbs)[2] = ff_vp9_scans_nb[tx]; 978 const int16_t *uvscan = ff_vp9_scans[b->uvtx][DCT_DCT]; 979 const int16_t (*uvnb)[2] = ff_vp9_scans_nb[b->uvtx][DCT_DCT]; 980 uint8_t *a = &s->above_y_nnz_ctx[col * 2]; 981 uint8_t *l = &td->left_y_nnz_ctx[(row & 7) << 1]; 982 static const int16_t band_counts[4][8] = { 983 { 1, 2, 3, 4, 3, 16 - 13 }, 984 { 1, 2, 3, 4, 11, 64 - 21 }, 985 { 1, 2, 3, 4, 11, 256 - 21 }, 986 { 1, 2, 3, 4, 11, 1024 - 21 }, 987 }; 988 const int16_t *y_band_counts = band_counts[b->tx]; 989 const int16_t *uv_band_counts = band_counts[b->uvtx]; 990 int bytesperpixel = is8bitsperpixel ? 1 : 2; 991 int total_coeff = 0; 992 993#define MERGE(la, end, step, rd) \ 994 for (n = 0; n < end; n += step) \ 995 la[n] = !!rd(&la[n]) 996#define MERGE_CTX(step, rd) \ 997 do { \ 998 MERGE(l, end_y, step, rd); \ 999 MERGE(a, end_x, step, rd); \ 1000 } while (0) 1001 1002#define DECODE_Y_COEF_LOOP(step, mode_index, v) \ 1003 for (n = 0, y = 0; y < end_y; y += step) { \ 1004 for (x = 0; x < end_x; x += step, n += step * step) { \ 1005 enum TxfmType txtp = ff_vp9_intra_txfm_type[b->mode[mode_index]]; \ 1006 ret = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \ 1007 (td, td->block + 16 * n * bytesperpixel, 16 * step * step, \ 1008 c, e, p, a[x] + l[y], yscans[txtp], \ 1009 ynbs[txtp], y_band_counts, qmul[0]); \ 1010 a[x] = l[y] = !!ret; \ 1011 total_coeff |= !!ret; \ 1012 if (step >= 4) { \ 1013 AV_WN16A(&td->eob[n], ret); \ 1014 } else { \ 1015 td->eob[n] = ret; \ 1016 } \ 1017 } \ 1018 } 1019 1020#define SPLAT(la, end, step, cond) \ 1021 if (step == 2) { \ 1022 for (n = 1; n < end; n += step) \ 1023 la[n] = la[n - 1]; \ 1024 } else if (step == 4) { \ 1025 if (cond) { \ 1026 for (n = 0; n < end; n += step) \ 1027 AV_WN32A(&la[n], la[n] * 0x01010101); \ 1028 } else { \ 1029 for (n = 0; n < end; n += step) \ 1030 memset(&la[n + 1], la[n], FFMIN(end - n - 1, 3)); \ 1031 } \ 1032 } else /* step == 8 */ { \ 1033 if (cond) { \ 1034 if (HAVE_FAST_64BIT) { \ 1035 for (n = 0; n < end; n += step) \ 1036 AV_WN64A(&la[n], la[n] * 0x0101010101010101ULL); \ 1037 } else { \ 1038 for (n = 0; n < end; n += step) { \ 1039 uint32_t v32 = la[n] * 0x01010101; \ 1040 AV_WN32A(&la[n], v32); \ 1041 AV_WN32A(&la[n + 4], v32); \ 1042 } \ 1043 } \ 1044 } else { \ 1045 for (n = 0; n < end; n += step) \ 1046 memset(&la[n + 1], la[n], FFMIN(end - n - 1, 7)); \ 1047 } \ 1048 } 1049#define SPLAT_CTX(step) \ 1050 do { \ 1051 SPLAT(a, end_x, step, end_x == w4); \ 1052 SPLAT(l, end_y, step, end_y == h4); \ 1053 } while (0) 1054 1055 /* y tokens */ 1056 switch (b->tx) { 1057 case TX_4X4: 1058 DECODE_Y_COEF_LOOP(1, b->bs > BS_8x8 ? n : 0,); 1059 break; 1060 case TX_8X8: 1061 MERGE_CTX(2, AV_RN16A); 1062 DECODE_Y_COEF_LOOP(2, 0,); 1063 SPLAT_CTX(2); 1064 break; 1065 case TX_16X16: 1066 MERGE_CTX(4, AV_RN32A); 1067 DECODE_Y_COEF_LOOP(4, 0,); 1068 SPLAT_CTX(4); 1069 break; 1070 case TX_32X32: 1071 MERGE_CTX(8, AV_RN64A); 1072 DECODE_Y_COEF_LOOP(8, 0, 32); 1073 SPLAT_CTX(8); 1074 break; 1075 } 1076 1077#define DECODE_UV_COEF_LOOP(step, v) \ 1078 for (n = 0, y = 0; y < end_y; y += step) { \ 1079 for (x = 0; x < end_x; x += step, n += step * step) { \ 1080 ret = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \ 1081 (td, td->uvblock[pl] + 16 * n * bytesperpixel, \ 1082 16 * step * step, c, e, p, a[x] + l[y], \ 1083 uvscan, uvnb, uv_band_counts, qmul[1]); \ 1084 a[x] = l[y] = !!ret; \ 1085 total_coeff |= !!ret; \ 1086 if (step >= 4) { \ 1087 AV_WN16A(&td->uveob[pl][n], ret); \ 1088 } else { \ 1089 td->uveob[pl][n] = ret; \ 1090 } \ 1091 } \ 1092 } 1093 1094 p = s->prob.coef[b->uvtx][1 /* uv */][!b->intra]; 1095 c = td->counts.coef[b->uvtx][1 /* uv */][!b->intra]; 1096 e = td->counts.eob[b->uvtx][1 /* uv */][!b->intra]; 1097 w4 >>= s->ss_h; 1098 end_x >>= s->ss_h; 1099 h4 >>= s->ss_v; 1100 end_y >>= s->ss_v; 1101 for (pl = 0; pl < 2; pl++) { 1102 a = &s->above_uv_nnz_ctx[pl][col << !s->ss_h]; 1103 l = &td->left_uv_nnz_ctx[pl][(row & 7) << !s->ss_v]; 1104 switch (b->uvtx) { 1105 case TX_4X4: 1106 DECODE_UV_COEF_LOOP(1,); 1107 break; 1108 case TX_8X8: 1109 MERGE_CTX(2, AV_RN16A); 1110 DECODE_UV_COEF_LOOP(2,); 1111 SPLAT_CTX(2); 1112 break; 1113 case TX_16X16: 1114 MERGE_CTX(4, AV_RN32A); 1115 DECODE_UV_COEF_LOOP(4,); 1116 SPLAT_CTX(4); 1117 break; 1118 case TX_32X32: 1119 MERGE_CTX(8, AV_RN64A); 1120 DECODE_UV_COEF_LOOP(8, 32); 1121 SPLAT_CTX(8); 1122 break; 1123 } 1124 } 1125 1126 return total_coeff; 1127} 1128 1129static int decode_coeffs_8bpp(VP9TileData *td) 1130{ 1131 return decode_coeffs(td, 1); 1132} 1133 1134static int decode_coeffs_16bpp(VP9TileData *td) 1135{ 1136 return decode_coeffs(td, 0); 1137} 1138 1139static av_always_inline void mask_edges(uint8_t (*mask)[8][4], int ss_h, int ss_v, 1140 int row_and_7, int col_and_7, 1141 int w, int h, int col_end, int row_end, 1142 enum TxfmMode tx, int skip_inter) 1143{ 1144 static const unsigned wide_filter_col_mask[2] = { 0x11, 0x01 }; 1145 static const unsigned wide_filter_row_mask[2] = { 0x03, 0x07 }; 1146 1147 // FIXME I'm pretty sure all loops can be replaced by a single LUT if 1148 // we make VP9Filter.mask uint64_t (i.e. row/col all single variable) 1149 // and make the LUT 5-indexed (bl, bp, is_uv, tx and row/col), and then 1150 // use row_and_7/col_and_7 as shifts (1*col_and_7+8*row_and_7) 1151 1152 // the intended behaviour of the vp9 loopfilter is to work on 8-pixel 1153 // edges. This means that for UV, we work on two subsampled blocks at 1154 // a time, and we only use the topleft block's mode information to set 1155 // things like block strength. Thus, for any block size smaller than 1156 // 16x16, ignore the odd portion of the block. 1157 if (tx == TX_4X4 && (ss_v | ss_h)) { 1158 if (h == ss_v) { 1159 if (row_and_7 & 1) 1160 return; 1161 if (!row_end) 1162 h += 1; 1163 } 1164 if (w == ss_h) { 1165 if (col_and_7 & 1) 1166 return; 1167 if (!col_end) 1168 w += 1; 1169 } 1170 } 1171 1172 if (tx == TX_4X4 && !skip_inter) { 1173 int t = 1 << col_and_7, m_col = (t << w) - t, y; 1174 // on 32-px edges, use the 8-px wide loopfilter; else, use 4-px wide 1175 int m_row_8 = m_col & wide_filter_col_mask[ss_h], m_row_4 = m_col - m_row_8; 1176 1177 for (y = row_and_7; y < h + row_and_7; y++) { 1178 int col_mask_id = 2 - !(y & wide_filter_row_mask[ss_v]); 1179 1180 mask[0][y][1] |= m_row_8; 1181 mask[0][y][2] |= m_row_4; 1182 // for odd lines, if the odd col is not being filtered, 1183 // skip odd row also: 1184 // .---. <-- a 1185 // | | 1186 // |___| <-- b 1187 // ^ ^ 1188 // c d 1189 // 1190 // if a/c are even row/col and b/d are odd, and d is skipped, 1191 // e.g. right edge of size-66x66.webm, then skip b also (bug) 1192 if ((ss_h & ss_v) && (col_end & 1) && (y & 1)) { 1193 mask[1][y][col_mask_id] |= (t << (w - 1)) - t; 1194 } else { 1195 mask[1][y][col_mask_id] |= m_col; 1196 } 1197 if (!ss_h) 1198 mask[0][y][3] |= m_col; 1199 if (!ss_v) { 1200 if (ss_h && (col_end & 1)) 1201 mask[1][y][3] |= (t << (w - 1)) - t; 1202 else 1203 mask[1][y][3] |= m_col; 1204 } 1205 } 1206 } else { 1207 int y, t = 1 << col_and_7, m_col = (t << w) - t; 1208 1209 if (!skip_inter) { 1210 int mask_id = (tx == TX_8X8); 1211 int l2 = tx + ss_h - 1, step1d; 1212 static const unsigned masks[4] = { 0xff, 0x55, 0x11, 0x01 }; 1213 int m_row = m_col & masks[l2]; 1214 1215 // at odd UV col/row edges tx16/tx32 loopfilter edges, force 1216 // 8wd loopfilter to prevent going off the visible edge. 1217 if (ss_h && tx > TX_8X8 && (w ^ (w - 1)) == 1) { 1218 int m_row_16 = ((t << (w - 1)) - t) & masks[l2]; 1219 int m_row_8 = m_row - m_row_16; 1220 1221 for (y = row_and_7; y < h + row_and_7; y++) { 1222 mask[0][y][0] |= m_row_16; 1223 mask[0][y][1] |= m_row_8; 1224 } 1225 } else { 1226 for (y = row_and_7; y < h + row_and_7; y++) 1227 mask[0][y][mask_id] |= m_row; 1228 } 1229 1230 l2 = tx + ss_v - 1; 1231 step1d = 1 << l2; 1232 if (ss_v && tx > TX_8X8 && (h ^ (h - 1)) == 1) { 1233 for (y = row_and_7; y < h + row_and_7 - 1; y += step1d) 1234 mask[1][y][0] |= m_col; 1235 if (y - row_and_7 == h - 1) 1236 mask[1][y][1] |= m_col; 1237 } else { 1238 for (y = row_and_7; y < h + row_and_7; y += step1d) 1239 mask[1][y][mask_id] |= m_col; 1240 } 1241 } else if (tx != TX_4X4) { 1242 int mask_id; 1243 1244 mask_id = (tx == TX_8X8) || (h == ss_v); 1245 mask[1][row_and_7][mask_id] |= m_col; 1246 mask_id = (tx == TX_8X8) || (w == ss_h); 1247 for (y = row_and_7; y < h + row_and_7; y++) 1248 mask[0][y][mask_id] |= t; 1249 } else { 1250 int t8 = t & wide_filter_col_mask[ss_h], t4 = t - t8; 1251 1252 for (y = row_and_7; y < h + row_and_7; y++) { 1253 mask[0][y][2] |= t4; 1254 mask[0][y][1] |= t8; 1255 } 1256 mask[1][row_and_7][2 - !(row_and_7 & wide_filter_row_mask[ss_v])] |= m_col; 1257 } 1258 } 1259} 1260 1261void ff_vp9_decode_block(VP9TileData *td, int row, int col, 1262 VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff, 1263 enum BlockLevel bl, enum BlockPartition bp) 1264{ 1265 VP9Context *s = td->s; 1266 VP9Block *b = td->b; 1267 enum BlockSize bs = bl * 3 + bp; 1268 int bytesperpixel = s->bytesperpixel; 1269 int w4 = ff_vp9_bwh_tab[1][bs][0], h4 = ff_vp9_bwh_tab[1][bs][1], lvl; 1270 int emu[2]; 1271 AVFrame *f = s->s.frames[CUR_FRAME].tf.f; 1272 1273 td->row = row; 1274 td->row7 = row & 7; 1275 td->col = col; 1276 td->col7 = col & 7; 1277 1278 td->min_mv.x = -(128 + col * 64); 1279 td->min_mv.y = -(128 + row * 64); 1280 td->max_mv.x = 128 + (s->cols - col - w4) * 64; 1281 td->max_mv.y = 128 + (s->rows - row - h4) * 64; 1282 1283 if (s->pass < 2) { 1284 b->bs = bs; 1285 b->bl = bl; 1286 b->bp = bp; 1287 decode_mode(td); 1288 b->uvtx = b->tx - ((s->ss_h && w4 * 2 == (1 << b->tx)) || 1289 (s->ss_v && h4 * 2 == (1 << b->tx))); 1290 1291 if (td->block_structure) { 1292 td->block_structure[td->nb_block_structure].row = row; 1293 td->block_structure[td->nb_block_structure].col = col; 1294 td->block_structure[td->nb_block_structure].block_size_idx_x = av_log2(w4); 1295 td->block_structure[td->nb_block_structure].block_size_idx_y = av_log2(h4); 1296 td->nb_block_structure++; 1297 } 1298 1299 if (!b->skip) { 1300 int has_coeffs; 1301 1302 if (bytesperpixel == 1) { 1303 has_coeffs = decode_coeffs_8bpp(td); 1304 } else { 1305 has_coeffs = decode_coeffs_16bpp(td); 1306 } 1307 if (!has_coeffs && b->bs <= BS_8x8 && !b->intra) { 1308 b->skip = 1; 1309 memset(&s->above_skip_ctx[col], 1, w4); 1310 memset(&td->left_skip_ctx[td->row7], 1, h4); 1311 } 1312 } else { 1313 int row7 = td->row7; 1314 1315#define SPLAT_ZERO_CTX(v, n) \ 1316 switch (n) { \ 1317 case 1: v = 0; break; \ 1318 case 2: AV_ZERO16(&v); break; \ 1319 case 4: AV_ZERO32(&v); break; \ 1320 case 8: AV_ZERO64(&v); break; \ 1321 case 16: AV_ZERO128(&v); break; \ 1322 } 1323#define SPLAT_ZERO_YUV(dir, var, off, n, dir2) \ 1324 do { \ 1325 SPLAT_ZERO_CTX(dir##_y_##var[off * 2], n * 2); \ 1326 if (s->ss_##dir2) { \ 1327 SPLAT_ZERO_CTX(dir##_uv_##var[0][off], n); \ 1328 SPLAT_ZERO_CTX(dir##_uv_##var[1][off], n); \ 1329 } else { \ 1330 SPLAT_ZERO_CTX(dir##_uv_##var[0][off * 2], n * 2); \ 1331 SPLAT_ZERO_CTX(dir##_uv_##var[1][off * 2], n * 2); \ 1332 } \ 1333 } while (0) 1334 1335 switch (w4) { 1336 case 1: SPLAT_ZERO_YUV(s->above, nnz_ctx, col, 1, h); break; 1337 case 2: SPLAT_ZERO_YUV(s->above, nnz_ctx, col, 2, h); break; 1338 case 4: SPLAT_ZERO_YUV(s->above, nnz_ctx, col, 4, h); break; 1339 case 8: SPLAT_ZERO_YUV(s->above, nnz_ctx, col, 8, h); break; 1340 } 1341 switch (h4) { 1342 case 1: SPLAT_ZERO_YUV(td->left, nnz_ctx, row7, 1, v); break; 1343 case 2: SPLAT_ZERO_YUV(td->left, nnz_ctx, row7, 2, v); break; 1344 case 4: SPLAT_ZERO_YUV(td->left, nnz_ctx, row7, 4, v); break; 1345 case 8: SPLAT_ZERO_YUV(td->left, nnz_ctx, row7, 8, v); break; 1346 } 1347 } 1348 1349 if (s->pass == 1) { 1350 s->td[0].b++; 1351 s->td[0].block += w4 * h4 * 64 * bytesperpixel; 1352 s->td[0].uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v); 1353 s->td[0].uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v); 1354 s->td[0].eob += 4 * w4 * h4; 1355 s->td[0].uveob[0] += 4 * w4 * h4 >> (s->ss_h + s->ss_v); 1356 s->td[0].uveob[1] += 4 * w4 * h4 >> (s->ss_h + s->ss_v); 1357 1358 return; 1359 } 1360 } 1361 1362 // emulated overhangs if the stride of the target buffer can't hold. This 1363 // makes it possible to support emu-edge and so on even if we have large block 1364 // overhangs 1365 emu[0] = (col + w4) * 8 * bytesperpixel > f->linesize[0] || 1366 (row + h4) > s->rows; 1367 emu[1] = ((col + w4) * 8 >> s->ss_h) * bytesperpixel > f->linesize[1] || 1368 (row + h4) > s->rows; 1369 if (emu[0]) { 1370 td->dst[0] = td->tmp_y; 1371 td->y_stride = 128; 1372 } else { 1373 td->dst[0] = f->data[0] + yoff; 1374 td->y_stride = f->linesize[0]; 1375 } 1376 if (emu[1]) { 1377 td->dst[1] = td->tmp_uv[0]; 1378 td->dst[2] = td->tmp_uv[1]; 1379 td->uv_stride = 128; 1380 } else { 1381 td->dst[1] = f->data[1] + uvoff; 1382 td->dst[2] = f->data[2] + uvoff; 1383 td->uv_stride = f->linesize[1]; 1384 } 1385 if (b->intra) { 1386 if (s->s.h.bpp > 8) { 1387 ff_vp9_intra_recon_16bpp(td, yoff, uvoff); 1388 } else { 1389 ff_vp9_intra_recon_8bpp(td, yoff, uvoff); 1390 } 1391 } else { 1392 if (s->s.h.bpp > 8) { 1393 ff_vp9_inter_recon_16bpp(td); 1394 } else { 1395 ff_vp9_inter_recon_8bpp(td); 1396 } 1397 } 1398 if (emu[0]) { 1399 int w = FFMIN(s->cols - col, w4) * 8, h = FFMIN(s->rows - row, h4) * 8, n, o = 0; 1400 1401 for (n = 0; o < w; n++) { 1402 int bw = 64 >> n; 1403 1404 av_assert2(n <= 4); 1405 if (w & bw) { 1406 s->dsp.mc[n][0][0][0][0](f->data[0] + yoff + o * bytesperpixel, f->linesize[0], 1407 td->tmp_y + o * bytesperpixel, 128, h, 0, 0); 1408 o += bw; 1409 } 1410 } 1411 } 1412 if (emu[1]) { 1413 int w = FFMIN(s->cols - col, w4) * 8 >> s->ss_h; 1414 int h = FFMIN(s->rows - row, h4) * 8 >> s->ss_v, n, o = 0; 1415 1416 for (n = s->ss_h; o < w; n++) { 1417 int bw = 64 >> n; 1418 1419 av_assert2(n <= 4); 1420 if (w & bw) { 1421 s->dsp.mc[n][0][0][0][0](f->data[1] + uvoff + o * bytesperpixel, f->linesize[1], 1422 td->tmp_uv[0] + o * bytesperpixel, 128, h, 0, 0); 1423 s->dsp.mc[n][0][0][0][0](f->data[2] + uvoff + o * bytesperpixel, f->linesize[2], 1424 td->tmp_uv[1] + o * bytesperpixel, 128, h, 0, 0); 1425 o += bw; 1426 } 1427 } 1428 } 1429 1430 // pick filter level and find edges to apply filter to 1431 if (s->s.h.filter.level && 1432 (lvl = s->s.h.segmentation.feat[b->seg_id].lflvl[b->intra ? 0 : b->ref[0] + 1] 1433 [b->mode[3] != ZEROMV]) > 0) { 1434 int x_end = FFMIN(s->cols - col, w4), y_end = FFMIN(s->rows - row, h4); 1435 int skip_inter = !b->intra && b->skip, col7 = td->col7, row7 = td->row7; 1436 1437 setctx_2d(&lflvl->level[row7 * 8 + col7], w4, h4, 8, lvl); 1438 mask_edges(lflvl->mask[0], 0, 0, row7, col7, x_end, y_end, 0, 0, b->tx, skip_inter); 1439 if (s->ss_h || s->ss_v) 1440 mask_edges(lflvl->mask[1], s->ss_h, s->ss_v, row7, col7, x_end, y_end, 1441 s->cols & 1 && col + w4 >= s->cols ? s->cols & 7 : 0, 1442 s->rows & 1 && row + h4 >= s->rows ? s->rows & 7 : 0, 1443 b->uvtx, skip_inter); 1444 } 1445 1446 if (s->pass == 2) { 1447 s->td[0].b++; 1448 s->td[0].block += w4 * h4 * 64 * bytesperpixel; 1449 s->td[0].uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h); 1450 s->td[0].uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h); 1451 s->td[0].eob += 4 * w4 * h4; 1452 s->td[0].uveob[0] += 4 * w4 * h4 >> (s->ss_v + s->ss_h); 1453 s->td[0].uveob[1] += 4 * w4 * h4 >> (s->ss_v + s->ss_h); 1454 } 1455} 1456