vp9: re-split the decoder/format/dsp interface header files.
[ffmpeg.git] / libavcodec / vp9block.c
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 "avcodec.h"
27 #include "internal.h"
28 #include "videodsp.h"
29 #include "vp56.h"
30 #include "vp9.h"
31 #include "vp9data.h"
32 #include "vp9dec.h"
33
34 static const uint8_t bwh_tab[2][N_BS_SIZES][2] = {
35     {
36         { 16, 16 }, { 16, 8 }, { 8, 16 }, { 8, 8 }, { 8, 4 }, { 4, 8 },
37         {  4,  4 }, {  4, 2 }, { 2,  4 }, { 2, 2 }, { 2, 1 }, { 1, 2 }, { 1, 1 },
38     }, {
39         {  8,  8 }, {  8, 4 }, { 4,  8 }, { 4, 4 }, { 4, 2 }, { 2, 4 },
40         {  2,  2 }, {  2, 1 }, { 1,  2 }, { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 },
41     }
42 };
43
44 static av_always_inline void setctx_2d(uint8_t *ptr, int w, int h,
45                                        ptrdiff_t stride, int v)
46 {
47     switch (w) {
48     case 1:
49         do {
50             *ptr = v;
51             ptr += stride;
52         } while (--h);
53         break;
54     case 2: {
55         int v16 = v * 0x0101;
56         do {
57             AV_WN16A(ptr, v16);
58             ptr += stride;
59         } while (--h);
60         break;
61     }
62     case 4: {
63         uint32_t v32 = v * 0x01010101;
64         do {
65             AV_WN32A(ptr, v32);
66             ptr += stride;
67         } while (--h);
68         break;
69     }
70     case 8: {
71 #if HAVE_FAST_64BIT
72         uint64_t v64 = v * 0x0101010101010101ULL;
73         do {
74             AV_WN64A(ptr, v64);
75             ptr += stride;
76         } while (--h);
77 #else
78         uint32_t v32 = v * 0x01010101;
79         do {
80             AV_WN32A(ptr,     v32);
81             AV_WN32A(ptr + 4, v32);
82             ptr += stride;
83         } while (--h);
84 #endif
85         break;
86     }
87     }
88 }
89
90 static void decode_mode(AVCodecContext *avctx)
91 {
92     static const uint8_t left_ctx[N_BS_SIZES] = {
93         0x0, 0x8, 0x0, 0x8, 0xc, 0x8, 0xc, 0xe, 0xc, 0xe, 0xf, 0xe, 0xf
94     };
95     static const uint8_t above_ctx[N_BS_SIZES] = {
96         0x0, 0x0, 0x8, 0x8, 0x8, 0xc, 0xc, 0xc, 0xe, 0xe, 0xe, 0xf, 0xf
97     };
98     static const uint8_t max_tx_for_bl_bp[N_BS_SIZES] = {
99         TX_32X32, TX_32X32, TX_32X32, TX_32X32, TX_16X16, TX_16X16,
100         TX_16X16, TX_8X8,   TX_8X8,   TX_8X8,   TX_4X4,   TX_4X4,  TX_4X4
101     };
102     VP9Context *s = avctx->priv_data;
103     VP9Block *b = s->b;
104     int row = s->row, col = s->col, row7 = s->row7;
105     enum TxfmMode max_tx = max_tx_for_bl_bp[b->bs];
106     int bw4 = bwh_tab[1][b->bs][0], w4 = FFMIN(s->cols - col, bw4);
107     int bh4 = bwh_tab[1][b->bs][1], h4 = FFMIN(s->rows - row, bh4), y;
108     int have_a = row > 0, have_l = col > s->tile_col_start;
109     int vref, filter_id;
110
111     if (!s->s.h.segmentation.enabled) {
112         b->seg_id = 0;
113     } else if (s->s.h.keyframe || s->s.h.intraonly) {
114         b->seg_id = !s->s.h.segmentation.update_map ? 0 :
115                     vp8_rac_get_tree(&s->c, ff_vp9_segmentation_tree, s->s.h.segmentation.prob);
116     } else if (!s->s.h.segmentation.update_map ||
117                (s->s.h.segmentation.temporal &&
118                 vp56_rac_get_prob_branchy(&s->c,
119                     s->s.h.segmentation.pred_prob[s->above_segpred_ctx[col] +
120                                     s->left_segpred_ctx[row7]]))) {
121         if (!s->s.h.errorres && s->s.frames[REF_FRAME_SEGMAP].segmentation_map) {
122             int pred = 8, x;
123             uint8_t *refsegmap = s->s.frames[REF_FRAME_SEGMAP].segmentation_map;
124
125             if (!s->s.frames[REF_FRAME_SEGMAP].uses_2pass)
126                 ff_thread_await_progress(&s->s.frames[REF_FRAME_SEGMAP].tf, row >> 3, 0);
127             for (y = 0; y < h4; y++) {
128                 int idx_base = (y + row) * 8 * s->sb_cols + col;
129                 for (x = 0; x < w4; x++)
130                     pred = FFMIN(pred, refsegmap[idx_base + x]);
131             }
132             av_assert1(pred < 8);
133             b->seg_id = pred;
134         } else {
135             b->seg_id = 0;
136         }
137
138         memset(&s->above_segpred_ctx[col], 1, w4);
139         memset(&s->left_segpred_ctx[row7], 1, h4);
140     } else {
141         b->seg_id = vp8_rac_get_tree(&s->c, ff_vp9_segmentation_tree,
142                                      s->s.h.segmentation.prob);
143
144         memset(&s->above_segpred_ctx[col], 0, w4);
145         memset(&s->left_segpred_ctx[row7], 0, h4);
146     }
147     if (s->s.h.segmentation.enabled &&
148         (s->s.h.segmentation.update_map || s->s.h.keyframe || s->s.h.intraonly)) {
149         setctx_2d(&s->s.frames[CUR_FRAME].segmentation_map[row * 8 * s->sb_cols + col],
150                   bw4, bh4, 8 * s->sb_cols, b->seg_id);
151     }
152
153     b->skip = s->s.h.segmentation.enabled &&
154         s->s.h.segmentation.feat[b->seg_id].skip_enabled;
155     if (!b->skip) {
156         int c = s->left_skip_ctx[row7] + s->above_skip_ctx[col];
157         b->skip = vp56_rac_get_prob(&s->c, s->prob.p.skip[c]);
158         s->counts.skip[c][b->skip]++;
159     }
160
161     if (s->s.h.keyframe || s->s.h.intraonly) {
162         b->intra = 1;
163     } else if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].ref_enabled) {
164         b->intra = !s->s.h.segmentation.feat[b->seg_id].ref_val;
165     } else {
166         int c, bit;
167
168         if (have_a && have_l) {
169             c = s->above_intra_ctx[col] + s->left_intra_ctx[row7];
170             c += (c == 2);
171         } else {
172             c = have_a ? 2 * s->above_intra_ctx[col] :
173                 have_l ? 2 * s->left_intra_ctx[row7] : 0;
174         }
175         bit = vp56_rac_get_prob(&s->c, s->prob.p.intra[c]);
176         s->counts.intra[c][bit]++;
177         b->intra = !bit;
178     }
179
180     if ((b->intra || !b->skip) && s->s.h.txfmmode == TX_SWITCHABLE) {
181         int c;
182         if (have_a) {
183             if (have_l) {
184                 c = (s->above_skip_ctx[col] ? max_tx :
185                      s->above_txfm_ctx[col]) +
186                     (s->left_skip_ctx[row7] ? max_tx :
187                      s->left_txfm_ctx[row7]) > max_tx;
188             } else {
189                 c = s->above_skip_ctx[col] ? 1 :
190                     (s->above_txfm_ctx[col] * 2 > max_tx);
191             }
192         } else if (have_l) {
193             c = s->left_skip_ctx[row7] ? 1 :
194                 (s->left_txfm_ctx[row7] * 2 > max_tx);
195         } else {
196             c = 1;
197         }
198         switch (max_tx) {
199         case TX_32X32:
200             b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][0]);
201             if (b->tx) {
202                 b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][1]);
203                 if (b->tx == 2)
204                     b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][2]);
205             }
206             s->counts.tx32p[c][b->tx]++;
207             break;
208         case TX_16X16:
209             b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx16p[c][0]);
210             if (b->tx)
211                 b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx16p[c][1]);
212             s->counts.tx16p[c][b->tx]++;
213             break;
214         case TX_8X8:
215             b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx8p[c]);
216             s->counts.tx8p[c][b->tx]++;
217             break;
218         case TX_4X4:
219             b->tx = TX_4X4;
220             break;
221         }
222     } else {
223         b->tx = FFMIN(max_tx, s->s.h.txfmmode);
224     }
225
226     if (s->s.h.keyframe || s->s.h.intraonly) {
227         uint8_t *a = &s->above_mode_ctx[col * 2];
228         uint8_t *l = &s->left_mode_ctx[(row7) << 1];
229
230         b->comp = 0;
231         if (b->bs > BS_8x8) {
232             // FIXME the memory storage intermediates here aren't really
233             // necessary, they're just there to make the code slightly
234             // simpler for now
235             b->mode[0] =
236             a[0]       = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
237                                           ff_vp9_default_kf_ymode_probs[a[0]][l[0]]);
238             if (b->bs != BS_8x4) {
239                 b->mode[1] = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
240                                               ff_vp9_default_kf_ymode_probs[a[1]][b->mode[0]]);
241                 l[0]       =
242                 a[1]       = b->mode[1];
243             } else {
244                 l[0]       =
245                 a[1]       =
246                 b->mode[1] = b->mode[0];
247             }
248             if (b->bs != BS_4x8) {
249                 b->mode[2] =
250                 a[0]       = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
251                                               ff_vp9_default_kf_ymode_probs[a[0]][l[1]]);
252                 if (b->bs != BS_8x4) {
253                     b->mode[3] = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
254                                                   ff_vp9_default_kf_ymode_probs[a[1]][b->mode[2]]);
255                     l[1]       =
256                     a[1]       = b->mode[3];
257                 } else {
258                     l[1]       =
259                     a[1]       =
260                     b->mode[3] = b->mode[2];
261                 }
262             } else {
263                 b->mode[2] = b->mode[0];
264                 l[1]       =
265                 a[1]       =
266                 b->mode[3] = b->mode[1];
267             }
268         } else {
269             b->mode[0] = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
270                                           ff_vp9_default_kf_ymode_probs[*a][*l]);
271             b->mode[3] =
272             b->mode[2] =
273             b->mode[1] = b->mode[0];
274             // FIXME this can probably be optimized
275             memset(a, b->mode[0], bwh_tab[0][b->bs][0]);
276             memset(l, b->mode[0], bwh_tab[0][b->bs][1]);
277         }
278         b->uvmode = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
279                                      ff_vp9_default_kf_uvmode_probs[b->mode[3]]);
280     } else if (b->intra) {
281         b->comp = 0;
282         if (b->bs > BS_8x8) {
283             b->mode[0] = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
284                                           s->prob.p.y_mode[0]);
285             s->counts.y_mode[0][b->mode[0]]++;
286             if (b->bs != BS_8x4) {
287                 b->mode[1] = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
288                                               s->prob.p.y_mode[0]);
289                 s->counts.y_mode[0][b->mode[1]]++;
290             } else {
291                 b->mode[1] = b->mode[0];
292             }
293             if (b->bs != BS_4x8) {
294                 b->mode[2] = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
295                                               s->prob.p.y_mode[0]);
296                 s->counts.y_mode[0][b->mode[2]]++;
297                 if (b->bs != BS_8x4) {
298                     b->mode[3] = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
299                                                   s->prob.p.y_mode[0]);
300                     s->counts.y_mode[0][b->mode[3]]++;
301                 } else {
302                     b->mode[3] = b->mode[2];
303                 }
304             } else {
305                 b->mode[2] = b->mode[0];
306                 b->mode[3] = b->mode[1];
307             }
308         } else {
309             static const uint8_t size_group[10] = {
310                 3, 3, 3, 3, 2, 2, 2, 1, 1, 1
311             };
312             int sz = size_group[b->bs];
313
314             b->mode[0] = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
315                                           s->prob.p.y_mode[sz]);
316             b->mode[1] =
317             b->mode[2] =
318             b->mode[3] = b->mode[0];
319             s->counts.y_mode[sz][b->mode[3]]++;
320         }
321         b->uvmode = vp8_rac_get_tree(&s->c, ff_vp9_intramode_tree,
322                                      s->prob.p.uv_mode[b->mode[3]]);
323         s->counts.uv_mode[b->mode[3]][b->uvmode]++;
324     } else {
325         static const uint8_t inter_mode_ctx_lut[14][14] = {
326             { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
327             { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
328             { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
329             { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
330             { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
331             { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
332             { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
333             { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
334             { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
335             { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
336             { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 },
337             { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 },
338             { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 0, 3 },
339             { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 3, 3, 4 },
340         };
341
342         if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].ref_enabled) {
343             av_assert2(s->s.h.segmentation.feat[b->seg_id].ref_val != 0);
344             b->comp = 0;
345             b->ref[0] = s->s.h.segmentation.feat[b->seg_id].ref_val - 1;
346         } else {
347             // read comp_pred flag
348             if (s->s.h.comppredmode != PRED_SWITCHABLE) {
349                 b->comp = s->s.h.comppredmode == PRED_COMPREF;
350             } else {
351                 int c;
352
353                 // FIXME add intra as ref=0xff (or -1) to make these easier?
354                 if (have_a) {
355                     if (have_l) {
356                         if (s->above_comp_ctx[col] && s->left_comp_ctx[row7]) {
357                             c = 4;
358                         } else if (s->above_comp_ctx[col]) {
359                             c = 2 + (s->left_intra_ctx[row7] ||
360                                      s->left_ref_ctx[row7] == s->s.h.fixcompref);
361                         } else if (s->left_comp_ctx[row7]) {
362                             c = 2 + (s->above_intra_ctx[col] ||
363                                      s->above_ref_ctx[col] == s->s.h.fixcompref);
364                         } else {
365                             c = (!s->above_intra_ctx[col] &&
366                                  s->above_ref_ctx[col] == s->s.h.fixcompref) ^
367                                 (!s->left_intra_ctx[row7] &&
368                                  s->left_ref_ctx[row & 7] == s->s.h.fixcompref);
369                         }
370                     } else {
371                         c = s->above_comp_ctx[col] ? 3 :
372                         (!s->above_intra_ctx[col] && s->above_ref_ctx[col] == s->s.h.fixcompref);
373                     }
374                 } else if (have_l) {
375                     c = s->left_comp_ctx[row7] ? 3 :
376                     (!s->left_intra_ctx[row7] && s->left_ref_ctx[row7] == s->s.h.fixcompref);
377                 } else {
378                     c = 1;
379                 }
380                 b->comp = vp56_rac_get_prob(&s->c, s->prob.p.comp[c]);
381                 s->counts.comp[c][b->comp]++;
382             }
383
384             // read actual references
385             // FIXME probably cache a few variables here to prevent repetitive
386             // memory accesses below
387             if (b->comp) { /* two references */
388                 int fix_idx = s->s.h.signbias[s->s.h.fixcompref], var_idx = !fix_idx, c, bit;
389
390                 b->ref[fix_idx] = s->s.h.fixcompref;
391                 // FIXME can this codeblob be replaced by some sort of LUT?
392                 if (have_a) {
393                     if (have_l) {
394                         if (s->above_intra_ctx[col]) {
395                             if (s->left_intra_ctx[row7]) {
396                                 c = 2;
397                             } else {
398                                 c = 1 + 2 * (s->left_ref_ctx[row7] != s->s.h.varcompref[1]);
399                             }
400                         } else if (s->left_intra_ctx[row7]) {
401                             c = 1 + 2 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]);
402                         } else {
403                             int refl = s->left_ref_ctx[row7], refa = s->above_ref_ctx[col];
404
405                             if (refl == refa && refa == s->s.h.varcompref[1]) {
406                                 c = 0;
407                             } else if (!s->left_comp_ctx[row7] && !s->above_comp_ctx[col]) {
408                                 if ((refa == s->s.h.fixcompref && refl == s->s.h.varcompref[0]) ||
409                                     (refl == s->s.h.fixcompref && refa == s->s.h.varcompref[0])) {
410                                     c = 4;
411                                 } else {
412                                     c = (refa == refl) ? 3 : 1;
413                                 }
414                             } else if (!s->left_comp_ctx[row7]) {
415                                 if (refa == s->s.h.varcompref[1] && refl != s->s.h.varcompref[1]) {
416                                     c = 1;
417                                 } else {
418                                     c = (refl == s->s.h.varcompref[1] &&
419                                          refa != s->s.h.varcompref[1]) ? 2 : 4;
420                                 }
421                             } else if (!s->above_comp_ctx[col]) {
422                                 if (refl == s->s.h.varcompref[1] && refa != s->s.h.varcompref[1]) {
423                                     c = 1;
424                                 } else {
425                                     c = (refa == s->s.h.varcompref[1] &&
426                                          refl != s->s.h.varcompref[1]) ? 2 : 4;
427                                 }
428                             } else {
429                                 c = (refl == refa) ? 4 : 2;
430                             }
431                         }
432                     } else {
433                         if (s->above_intra_ctx[col]) {
434                             c = 2;
435                         } else if (s->above_comp_ctx[col]) {
436                             c = 4 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]);
437                         } else {
438                             c = 3 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]);
439                         }
440                     }
441                 } else if (have_l) {
442                     if (s->left_intra_ctx[row7]) {
443                         c = 2;
444                     } else if (s->left_comp_ctx[row7]) {
445                         c = 4 * (s->left_ref_ctx[row7] != s->s.h.varcompref[1]);
446                     } else {
447                         c = 3 * (s->left_ref_ctx[row7] != s->s.h.varcompref[1]);
448                     }
449                 } else {
450                     c = 2;
451                 }
452                 bit = vp56_rac_get_prob(&s->c, s->prob.p.comp_ref[c]);
453                 b->ref[var_idx] = s->s.h.varcompref[bit];
454                 s->counts.comp_ref[c][bit]++;
455             } else /* single reference */ {
456                 int bit, c;
457
458                 if (have_a && !s->above_intra_ctx[col]) {
459                     if (have_l && !s->left_intra_ctx[row7]) {
460                         if (s->left_comp_ctx[row7]) {
461                             if (s->above_comp_ctx[col]) {
462                                 c = 1 + (!s->s.h.fixcompref || !s->left_ref_ctx[row7] ||
463                                          !s->above_ref_ctx[col]);
464                             } else {
465                                 c = (3 * !s->above_ref_ctx[col]) +
466                                     (!s->s.h.fixcompref || !s->left_ref_ctx[row7]);
467                             }
468                         } else if (s->above_comp_ctx[col]) {
469                             c = (3 * !s->left_ref_ctx[row7]) +
470                                 (!s->s.h.fixcompref || !s->above_ref_ctx[col]);
471                         } else {
472                             c = 2 * !s->left_ref_ctx[row7] + 2 * !s->above_ref_ctx[col];
473                         }
474                     } else if (s->above_intra_ctx[col]) {
475                         c = 2;
476                     } else if (s->above_comp_ctx[col]) {
477                         c = 1 + (!s->s.h.fixcompref || !s->above_ref_ctx[col]);
478                     } else {
479                         c = 4 * (!s->above_ref_ctx[col]);
480                     }
481                 } else if (have_l && !s->left_intra_ctx[row7]) {
482                     if (s->left_intra_ctx[row7]) {
483                         c = 2;
484                     } else if (s->left_comp_ctx[row7]) {
485                         c = 1 + (!s->s.h.fixcompref || !s->left_ref_ctx[row7]);
486                     } else {
487                         c = 4 * (!s->left_ref_ctx[row7]);
488                     }
489                 } else {
490                     c = 2;
491                 }
492                 bit = vp56_rac_get_prob(&s->c, s->prob.p.single_ref[c][0]);
493                 s->counts.single_ref[c][0][bit]++;
494                 if (!bit) {
495                     b->ref[0] = 0;
496                 } else {
497                     // FIXME can this codeblob be replaced by some sort of LUT?
498                     if (have_a) {
499                         if (have_l) {
500                             if (s->left_intra_ctx[row7]) {
501                                 if (s->above_intra_ctx[col]) {
502                                     c = 2;
503                                 } else if (s->above_comp_ctx[col]) {
504                                     c = 1 + 2 * (s->s.h.fixcompref == 1 ||
505                                                  s->above_ref_ctx[col] == 1);
506                                 } else if (!s->above_ref_ctx[col]) {
507                                     c = 3;
508                                 } else {
509                                     c = 4 * (s->above_ref_ctx[col] == 1);
510                                 }
511                             } else if (s->above_intra_ctx[col]) {
512                                 if (s->left_intra_ctx[row7]) {
513                                     c = 2;
514                                 } else if (s->left_comp_ctx[row7]) {
515                                     c = 1 + 2 * (s->s.h.fixcompref == 1 ||
516                                                  s->left_ref_ctx[row7] == 1);
517                                 } else if (!s->left_ref_ctx[row7]) {
518                                     c = 3;
519                                 } else {
520                                     c = 4 * (s->left_ref_ctx[row7] == 1);
521                                 }
522                             } else if (s->above_comp_ctx[col]) {
523                                 if (s->left_comp_ctx[row7]) {
524                                     if (s->left_ref_ctx[row7] == s->above_ref_ctx[col]) {
525                                         c = 3 * (s->s.h.fixcompref == 1 ||
526                                                  s->left_ref_ctx[row7] == 1);
527                                     } else {
528                                         c = 2;
529                                     }
530                                 } else if (!s->left_ref_ctx[row7]) {
531                                     c = 1 + 2 * (s->s.h.fixcompref == 1 ||
532                                                  s->above_ref_ctx[col] == 1);
533                                 } else {
534                                     c = 3 * (s->left_ref_ctx[row7] == 1) +
535                                     (s->s.h.fixcompref == 1 || s->above_ref_ctx[col] == 1);
536                                 }
537                             } else if (s->left_comp_ctx[row7]) {
538                                 if (!s->above_ref_ctx[col]) {
539                                     c = 1 + 2 * (s->s.h.fixcompref == 1 ||
540                                                  s->left_ref_ctx[row7] == 1);
541                                 } else {
542                                     c = 3 * (s->above_ref_ctx[col] == 1) +
543                                     (s->s.h.fixcompref == 1 || s->left_ref_ctx[row7] == 1);
544                                 }
545                             } else if (!s->above_ref_ctx[col]) {
546                                 if (!s->left_ref_ctx[row7]) {
547                                     c = 3;
548                                 } else {
549                                     c = 4 * (s->left_ref_ctx[row7] == 1);
550                                 }
551                             } else if (!s->left_ref_ctx[row7]) {
552                                 c = 4 * (s->above_ref_ctx[col] == 1);
553                             } else {
554                                 c = 2 * (s->left_ref_ctx[row7] == 1) +
555                                     2 * (s->above_ref_ctx[col] == 1);
556                             }
557                         } else {
558                             if (s->above_intra_ctx[col] ||
559                                 (!s->above_comp_ctx[col] && !s->above_ref_ctx[col])) {
560                                 c = 2;
561                             } else if (s->above_comp_ctx[col]) {
562                                 c = 3 * (s->s.h.fixcompref == 1 || s->above_ref_ctx[col] == 1);
563                             } else {
564                                 c = 4 * (s->above_ref_ctx[col] == 1);
565                             }
566                         }
567                     } else if (have_l) {
568                         if (s->left_intra_ctx[row7] ||
569                             (!s->left_comp_ctx[row7] && !s->left_ref_ctx[row7])) {
570                             c = 2;
571                         } else if (s->left_comp_ctx[row7]) {
572                             c = 3 * (s->s.h.fixcompref == 1 || s->left_ref_ctx[row7] == 1);
573                         } else {
574                             c = 4 * (s->left_ref_ctx[row7] == 1);
575                         }
576                     } else {
577                         c = 2;
578                     }
579                     bit = vp56_rac_get_prob(&s->c, s->prob.p.single_ref[c][1]);
580                     s->counts.single_ref[c][1][bit]++;
581                     b->ref[0] = 1 + bit;
582                 }
583             }
584         }
585
586         if (b->bs <= BS_8x8) {
587             if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].skip_enabled) {
588                 b->mode[0] =
589                 b->mode[1] =
590                 b->mode[2] =
591                 b->mode[3] = ZEROMV;
592             } else {
593                 static const uint8_t off[10] = {
594                     3, 0, 0, 1, 0, 0, 0, 0, 0, 0
595                 };
596
597                 // FIXME this needs to use the LUT tables from find_ref_mvs
598                 // because not all are -1,0/0,-1
599                 int c = inter_mode_ctx_lut[s->above_mode_ctx[col + off[b->bs]]]
600                                           [s->left_mode_ctx[row7 + off[b->bs]]];
601
602                 b->mode[0] = vp8_rac_get_tree(&s->c, ff_vp9_inter_mode_tree,
603                                               s->prob.p.mv_mode[c]);
604                 b->mode[1] =
605                 b->mode[2] =
606                 b->mode[3] = b->mode[0];
607                 s->counts.mv_mode[c][b->mode[0] - 10]++;
608             }
609         }
610
611         if (s->s.h.filtermode == FILTER_SWITCHABLE) {
612             int c;
613
614             if (have_a && s->above_mode_ctx[col] >= NEARESTMV) {
615                 if (have_l && s->left_mode_ctx[row7] >= NEARESTMV) {
616                     c = s->above_filter_ctx[col] == s->left_filter_ctx[row7] ?
617                         s->left_filter_ctx[row7] : 3;
618                 } else {
619                     c = s->above_filter_ctx[col];
620                 }
621             } else if (have_l && s->left_mode_ctx[row7] >= NEARESTMV) {
622                 c = s->left_filter_ctx[row7];
623             } else {
624                 c = 3;
625             }
626
627             filter_id = vp8_rac_get_tree(&s->c, ff_vp9_filter_tree,
628                                          s->prob.p.filter[c]);
629             s->counts.filter[c][filter_id]++;
630             b->filter = ff_vp9_filter_lut[filter_id];
631         } else {
632             b->filter = s->s.h.filtermode;
633         }
634
635         if (b->bs > BS_8x8) {
636             int c = inter_mode_ctx_lut[s->above_mode_ctx[col]][s->left_mode_ctx[row7]];
637
638             b->mode[0] = vp8_rac_get_tree(&s->c, ff_vp9_inter_mode_tree,
639                                           s->prob.p.mv_mode[c]);
640             s->counts.mv_mode[c][b->mode[0] - 10]++;
641             ff_vp9_fill_mv(s, b->mv[0], b->mode[0], 0);
642
643             if (b->bs != BS_8x4) {
644                 b->mode[1] = vp8_rac_get_tree(&s->c, ff_vp9_inter_mode_tree,
645                                               s->prob.p.mv_mode[c]);
646                 s->counts.mv_mode[c][b->mode[1] - 10]++;
647                 ff_vp9_fill_mv(s, b->mv[1], b->mode[1], 1);
648             } else {
649                 b->mode[1] = b->mode[0];
650                 AV_COPY32(&b->mv[1][0], &b->mv[0][0]);
651                 AV_COPY32(&b->mv[1][1], &b->mv[0][1]);
652             }
653
654             if (b->bs != BS_4x8) {
655                 b->mode[2] = vp8_rac_get_tree(&s->c, ff_vp9_inter_mode_tree,
656                                               s->prob.p.mv_mode[c]);
657                 s->counts.mv_mode[c][b->mode[2] - 10]++;
658                 ff_vp9_fill_mv(s, b->mv[2], b->mode[2], 2);
659
660                 if (b->bs != BS_8x4) {
661                     b->mode[3] = vp8_rac_get_tree(&s->c, ff_vp9_inter_mode_tree,
662                                                   s->prob.p.mv_mode[c]);
663                     s->counts.mv_mode[c][b->mode[3] - 10]++;
664                     ff_vp9_fill_mv(s, b->mv[3], b->mode[3], 3);
665                 } else {
666                     b->mode[3] = b->mode[2];
667                     AV_COPY32(&b->mv[3][0], &b->mv[2][0]);
668                     AV_COPY32(&b->mv[3][1], &b->mv[2][1]);
669                 }
670             } else {
671                 b->mode[2] = b->mode[0];
672                 AV_COPY32(&b->mv[2][0], &b->mv[0][0]);
673                 AV_COPY32(&b->mv[2][1], &b->mv[0][1]);
674                 b->mode[3] = b->mode[1];
675                 AV_COPY32(&b->mv[3][0], &b->mv[1][0]);
676                 AV_COPY32(&b->mv[3][1], &b->mv[1][1]);
677             }
678         } else {
679             ff_vp9_fill_mv(s, b->mv[0], b->mode[0], -1);
680             AV_COPY32(&b->mv[1][0], &b->mv[0][0]);
681             AV_COPY32(&b->mv[2][0], &b->mv[0][0]);
682             AV_COPY32(&b->mv[3][0], &b->mv[0][0]);
683             AV_COPY32(&b->mv[1][1], &b->mv[0][1]);
684             AV_COPY32(&b->mv[2][1], &b->mv[0][1]);
685             AV_COPY32(&b->mv[3][1], &b->mv[0][1]);
686         }
687
688         vref = b->ref[b->comp ? s->s.h.signbias[s->s.h.varcompref[0]] : 0];
689     }
690
691 #if HAVE_FAST_64BIT
692 #define SPLAT_CTX(var, val, n) \
693     switch (n) { \
694     case 1:  var = val;                                    break; \
695     case 2:  AV_WN16A(&var, val *             0x0101);     break; \
696     case 4:  AV_WN32A(&var, val *         0x01010101);     break; \
697     case 8:  AV_WN64A(&var, val * 0x0101010101010101ULL);  break; \
698     case 16: { \
699         uint64_t v64 = val * 0x0101010101010101ULL; \
700         AV_WN64A(              &var,     v64); \
701         AV_WN64A(&((uint8_t *) &var)[8], v64); \
702         break; \
703     } \
704     }
705 #else
706 #define SPLAT_CTX(var, val, n) \
707     switch (n) { \
708     case 1:  var = val;                         break; \
709     case 2:  AV_WN16A(&var, val *     0x0101);  break; \
710     case 4:  AV_WN32A(&var, val * 0x01010101);  break; \
711     case 8: { \
712         uint32_t v32 = val * 0x01010101; \
713         AV_WN32A(              &var,     v32); \
714         AV_WN32A(&((uint8_t *) &var)[4], v32); \
715         break; \
716     } \
717     case 16: { \
718         uint32_t v32 = val * 0x01010101; \
719         AV_WN32A(              &var,      v32); \
720         AV_WN32A(&((uint8_t *) &var)[4],  v32); \
721         AV_WN32A(&((uint8_t *) &var)[8],  v32); \
722         AV_WN32A(&((uint8_t *) &var)[12], v32); \
723         break; \
724     } \
725     }
726 #endif
727
728     switch (bwh_tab[1][b->bs][0]) {
729 #define SET_CTXS(dir, off, n) \
730     do { \
731         SPLAT_CTX(s->dir##_skip_ctx[off],      b->skip,          n); \
732         SPLAT_CTX(s->dir##_txfm_ctx[off],      b->tx,            n); \
733         SPLAT_CTX(s->dir##_partition_ctx[off], dir##_ctx[b->bs], n); \
734         if (!s->s.h.keyframe && !s->s.h.intraonly) { \
735             SPLAT_CTX(s->dir##_intra_ctx[off], b->intra,   n); \
736             SPLAT_CTX(s->dir##_comp_ctx[off],  b->comp,    n); \
737             SPLAT_CTX(s->dir##_mode_ctx[off],  b->mode[3], n); \
738             if (!b->intra) { \
739                 SPLAT_CTX(s->dir##_ref_ctx[off], vref, n); \
740                 if (s->s.h.filtermode == FILTER_SWITCHABLE) { \
741                     SPLAT_CTX(s->dir##_filter_ctx[off], filter_id, n); \
742                 } \
743             } \
744         } \
745     } while (0)
746     case 1: SET_CTXS(above, col, 1); break;
747     case 2: SET_CTXS(above, col, 2); break;
748     case 4: SET_CTXS(above, col, 4); break;
749     case 8: SET_CTXS(above, col, 8); break;
750     }
751     switch (bwh_tab[1][b->bs][1]) {
752     case 1: SET_CTXS(left, row7, 1); break;
753     case 2: SET_CTXS(left, row7, 2); break;
754     case 4: SET_CTXS(left, row7, 4); break;
755     case 8: SET_CTXS(left, row7, 8); break;
756     }
757 #undef SPLAT_CTX
758 #undef SET_CTXS
759
760     if (!s->s.h.keyframe && !s->s.h.intraonly) {
761         if (b->bs > BS_8x8) {
762             int mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]);
763
764             AV_COPY32(&s->left_mv_ctx[row7 * 2 + 0][0], &b->mv[1][0]);
765             AV_COPY32(&s->left_mv_ctx[row7 * 2 + 0][1], &b->mv[1][1]);
766             AV_WN32A(&s->left_mv_ctx[row7 * 2 + 1][0], mv0);
767             AV_WN32A(&s->left_mv_ctx[row7 * 2 + 1][1], mv1);
768             AV_COPY32(&s->above_mv_ctx[col * 2 + 0][0], &b->mv[2][0]);
769             AV_COPY32(&s->above_mv_ctx[col * 2 + 0][1], &b->mv[2][1]);
770             AV_WN32A(&s->above_mv_ctx[col * 2 + 1][0], mv0);
771             AV_WN32A(&s->above_mv_ctx[col * 2 + 1][1], mv1);
772         } else {
773             int n, mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]);
774
775             for (n = 0; n < w4 * 2; n++) {
776                 AV_WN32A(&s->above_mv_ctx[col * 2 + n][0], mv0);
777                 AV_WN32A(&s->above_mv_ctx[col * 2 + n][1], mv1);
778             }
779             for (n = 0; n < h4 * 2; n++) {
780                 AV_WN32A(&s->left_mv_ctx[row7 * 2 + n][0], mv0);
781                 AV_WN32A(&s->left_mv_ctx[row7 * 2 + n][1], mv1);
782             }
783         }
784     }
785
786     // FIXME kinda ugly
787     for (y = 0; y < h4; y++) {
788         int x, o = (row + y) * s->sb_cols * 8 + col;
789         VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[o];
790
791         if (b->intra) {
792             for (x = 0; x < w4; x++) {
793                 mv[x].ref[0] =
794                 mv[x].ref[1] = -1;
795             }
796         } else if (b->comp) {
797             for (x = 0; x < w4; x++) {
798                 mv[x].ref[0] = b->ref[0];
799                 mv[x].ref[1] = b->ref[1];
800                 AV_COPY32(&mv[x].mv[0], &b->mv[3][0]);
801                 AV_COPY32(&mv[x].mv[1], &b->mv[3][1]);
802             }
803         } else {
804             for (x = 0; x < w4; x++) {
805                 mv[x].ref[0] = b->ref[0];
806                 mv[x].ref[1] = -1;
807                 AV_COPY32(&mv[x].mv[0], &b->mv[3][0]);
808             }
809         }
810     }
811 }
812
813 // FIXME merge cnt/eob arguments?
814 static av_always_inline int
815 decode_coeffs_b_generic(VP56RangeCoder *c, int16_t *coef, int n_coeffs,
816                         int is_tx32x32, int is8bitsperpixel, int bpp, unsigned (*cnt)[6][3],
817                         unsigned (*eob)[6][2], uint8_t (*p)[6][11],
818                         int nnz, const int16_t *scan, const int16_t (*nb)[2],
819                         const int16_t *band_counts, const int16_t *qmul)
820 {
821     int i = 0, band = 0, band_left = band_counts[band];
822     uint8_t *tp = p[0][nnz];
823     uint8_t cache[1024];
824
825     do {
826         int val, rc;
827
828         val = vp56_rac_get_prob_branchy(c, tp[0]); // eob
829         eob[band][nnz][val]++;
830         if (!val)
831             break;
832
833 skip_eob:
834         if (!vp56_rac_get_prob_branchy(c, tp[1])) { // zero
835             cnt[band][nnz][0]++;
836             if (!--band_left)
837                 band_left = band_counts[++band];
838             cache[scan[i]] = 0;
839             nnz            = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1;
840             tp             = p[band][nnz];
841             if (++i == n_coeffs)
842                 break;  //invalid input; blocks should end with EOB
843             goto skip_eob;
844         }
845
846         rc = scan[i];
847         if (!vp56_rac_get_prob_branchy(c, tp[2])) { // one
848             cnt[band][nnz][1]++;
849             val       = 1;
850             cache[rc] = 1;
851         } else {
852             // fill in p[3-10] (model fill) - only once per frame for each pos
853             if (!tp[3])
854                 memcpy(&tp[3], ff_vp9_model_pareto8[tp[2]], 8);
855
856             cnt[band][nnz][2]++;
857             if (!vp56_rac_get_prob_branchy(c, tp[3])) { // 2, 3, 4
858                 if (!vp56_rac_get_prob_branchy(c, tp[4])) {
859                     cache[rc] = val = 2;
860                 } else {
861                     val       = 3 + vp56_rac_get_prob(c, tp[5]);
862                     cache[rc] = 3;
863                 }
864             } else if (!vp56_rac_get_prob_branchy(c, tp[6])) { // cat1/2
865                 cache[rc] = 4;
866                 if (!vp56_rac_get_prob_branchy(c, tp[7])) {
867                     val  =  vp56_rac_get_prob(c, 159) + 5;
868                 } else {
869                     val  = (vp56_rac_get_prob(c, 165) << 1) + 7;
870                     val +=  vp56_rac_get_prob(c, 145);
871                 }
872             } else { // cat 3-6
873                 cache[rc] = 5;
874                 if (!vp56_rac_get_prob_branchy(c, tp[8])) {
875                     if (!vp56_rac_get_prob_branchy(c, tp[9])) {
876                         val  = 11 + (vp56_rac_get_prob(c, 173) << 2);
877                         val +=      (vp56_rac_get_prob(c, 148) << 1);
878                         val +=       vp56_rac_get_prob(c, 140);
879                     } else {
880                         val  = 19 + (vp56_rac_get_prob(c, 176) << 3);
881                         val +=      (vp56_rac_get_prob(c, 155) << 2);
882                         val +=      (vp56_rac_get_prob(c, 140) << 1);
883                         val +=       vp56_rac_get_prob(c, 135);
884                     }
885                 } else if (!vp56_rac_get_prob_branchy(c, tp[10])) {
886                     val  = (vp56_rac_get_prob(c, 180) << 4) + 35;
887                     val += (vp56_rac_get_prob(c, 157) << 3);
888                     val += (vp56_rac_get_prob(c, 141) << 2);
889                     val += (vp56_rac_get_prob(c, 134) << 1);
890                     val +=  vp56_rac_get_prob(c, 130);
891                 } else {
892                     val = 67;
893                     if (!is8bitsperpixel) {
894                         if (bpp == 12) {
895                             val += vp56_rac_get_prob(c, 255) << 17;
896                             val += vp56_rac_get_prob(c, 255) << 16;
897                         }
898                         val +=  (vp56_rac_get_prob(c, 255) << 15);
899                         val +=  (vp56_rac_get_prob(c, 255) << 14);
900                     }
901                     val += (vp56_rac_get_prob(c, 254) << 13);
902                     val += (vp56_rac_get_prob(c, 254) << 12);
903                     val += (vp56_rac_get_prob(c, 254) << 11);
904                     val += (vp56_rac_get_prob(c, 252) << 10);
905                     val += (vp56_rac_get_prob(c, 249) << 9);
906                     val += (vp56_rac_get_prob(c, 243) << 8);
907                     val += (vp56_rac_get_prob(c, 230) << 7);
908                     val += (vp56_rac_get_prob(c, 196) << 6);
909                     val += (vp56_rac_get_prob(c, 177) << 5);
910                     val += (vp56_rac_get_prob(c, 153) << 4);
911                     val += (vp56_rac_get_prob(c, 140) << 3);
912                     val += (vp56_rac_get_prob(c, 133) << 2);
913                     val += (vp56_rac_get_prob(c, 130) << 1);
914                     val +=  vp56_rac_get_prob(c, 129);
915                 }
916             }
917         }
918 #define STORE_COEF(c, i, v) do { \
919     if (is8bitsperpixel) { \
920         c[i] = v; \
921     } else { \
922         AV_WN32A(&c[i * 2], v); \
923     } \
924 } while (0)
925         if (!--band_left)
926             band_left = band_counts[++band];
927         if (is_tx32x32)
928             STORE_COEF(coef, rc, ((vp8_rac_get(c) ? -val : val) * qmul[!!i]) / 2);
929         else
930             STORE_COEF(coef, rc, (vp8_rac_get(c) ? -val : val) * qmul[!!i]);
931         nnz = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1;
932         tp = p[band][nnz];
933     } while (++i < n_coeffs);
934
935     return i;
936 }
937
938 static int decode_coeffs_b_8bpp(VP9Context *s, int16_t *coef, int n_coeffs,
939                                 unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
940                                 uint8_t (*p)[6][11], int nnz, const int16_t *scan,
941                                 const int16_t (*nb)[2], const int16_t *band_counts,
942                                 const int16_t *qmul)
943 {
944     return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 0, 1, 8, cnt, eob, p,
945                                    nnz, scan, nb, band_counts, qmul);
946 }
947
948 static int decode_coeffs_b32_8bpp(VP9Context *s, int16_t *coef, int n_coeffs,
949                                   unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
950                                   uint8_t (*p)[6][11], int nnz, const int16_t *scan,
951                                   const int16_t (*nb)[2], const int16_t *band_counts,
952                                   const int16_t *qmul)
953 {
954     return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 1, 1, 8, cnt, eob, p,
955                                    nnz, scan, nb, band_counts, qmul);
956 }
957
958 static int decode_coeffs_b_16bpp(VP9Context *s, int16_t *coef, int n_coeffs,
959                                  unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
960                                  uint8_t (*p)[6][11], int nnz, const int16_t *scan,
961                                  const int16_t (*nb)[2], const int16_t *band_counts,
962                                  const int16_t *qmul)
963 {
964     return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 0, 0, s->s.h.bpp, cnt, eob, p,
965                                    nnz, scan, nb, band_counts, qmul);
966 }
967
968 static int decode_coeffs_b32_16bpp(VP9Context *s, int16_t *coef, int n_coeffs,
969                                    unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
970                                    uint8_t (*p)[6][11], int nnz, const int16_t *scan,
971                                    const int16_t (*nb)[2], const int16_t *band_counts,
972                                    const int16_t *qmul)
973 {
974     return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 1, 0, s->s.h.bpp, cnt, eob, p,
975                                    nnz, scan, nb, band_counts, qmul);
976 }
977
978 static av_always_inline int decode_coeffs(AVCodecContext *avctx, int is8bitsperpixel)
979 {
980     VP9Context *s = avctx->priv_data;
981     VP9Block *b = s->b;
982     int row = s->row, col = s->col;
983     uint8_t (*p)[6][11] = s->prob.coef[b->tx][0 /* y */][!b->intra];
984     unsigned (*c)[6][3] = s->counts.coef[b->tx][0 /* y */][!b->intra];
985     unsigned (*e)[6][2] = s->counts.eob[b->tx][0 /* y */][!b->intra];
986     int w4 = bwh_tab[1][b->bs][0] << 1, h4 = bwh_tab[1][b->bs][1] << 1;
987     int end_x = FFMIN(2 * (s->cols - col), w4);
988     int end_y = FFMIN(2 * (s->rows - row), h4);
989     int n, pl, x, y, ret;
990     int16_t (*qmul)[2] = s->s.h.segmentation.feat[b->seg_id].qmul;
991     int tx = 4 * s->s.h.lossless + b->tx;
992     const int16_t * const *yscans = ff_vp9_scans[tx];
993     const int16_t (* const *ynbs)[2] = ff_vp9_scans_nb[tx];
994     const int16_t *uvscan = ff_vp9_scans[b->uvtx][DCT_DCT];
995     const int16_t (*uvnb)[2] = ff_vp9_scans_nb[b->uvtx][DCT_DCT];
996     uint8_t *a = &s->above_y_nnz_ctx[col * 2];
997     uint8_t *l = &s->left_y_nnz_ctx[(row & 7) << 1];
998     static const int16_t band_counts[4][8] = {
999         { 1, 2, 3, 4,  3,   16 - 13 },
1000         { 1, 2, 3, 4, 11,   64 - 21 },
1001         { 1, 2, 3, 4, 11,  256 - 21 },
1002         { 1, 2, 3, 4, 11, 1024 - 21 },
1003     };
1004     const int16_t *y_band_counts = band_counts[b->tx];
1005     const int16_t *uv_band_counts = band_counts[b->uvtx];
1006     int bytesperpixel = is8bitsperpixel ? 1 : 2;
1007     int total_coeff = 0;
1008
1009 #define MERGE(la, end, step, rd) \
1010     for (n = 0; n < end; n += step) \
1011         la[n] = !!rd(&la[n])
1012 #define MERGE_CTX(step, rd) \
1013     do { \
1014         MERGE(l, end_y, step, rd); \
1015         MERGE(a, end_x, step, rd); \
1016     } while (0)
1017
1018 #define DECODE_Y_COEF_LOOP(step, mode_index, v) \
1019     for (n = 0, y = 0; y < end_y; y += step) { \
1020         for (x = 0; x < end_x; x += step, n += step * step) { \
1021             enum TxfmType txtp = ff_vp9_intra_txfm_type[b->mode[mode_index]]; \
1022             ret = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \
1023                                     (s, s->block + 16 * n * bytesperpixel, 16 * step * step, \
1024                                      c, e, p, a[x] + l[y], yscans[txtp], \
1025                                      ynbs[txtp], y_band_counts, qmul[0]); \
1026             a[x] = l[y] = !!ret; \
1027             total_coeff |= !!ret; \
1028             if (step >= 4) { \
1029                 AV_WN16A(&s->eob[n], ret); \
1030             } else { \
1031                 s->eob[n] = ret; \
1032             } \
1033         } \
1034     }
1035
1036 #define SPLAT(la, end, step, cond) \
1037     if (step == 2) { \
1038         for (n = 1; n < end; n += step) \
1039             la[n] = la[n - 1]; \
1040     } else if (step == 4) { \
1041         if (cond) { \
1042             for (n = 0; n < end; n += step) \
1043                 AV_WN32A(&la[n], la[n] * 0x01010101); \
1044         } else { \
1045             for (n = 0; n < end; n += step) \
1046                 memset(&la[n + 1], la[n], FFMIN(end - n - 1, 3)); \
1047         } \
1048     } else /* step == 8 */ { \
1049         if (cond) { \
1050             if (HAVE_FAST_64BIT) { \
1051                 for (n = 0; n < end; n += step) \
1052                     AV_WN64A(&la[n], la[n] * 0x0101010101010101ULL); \
1053             } else { \
1054                 for (n = 0; n < end; n += step) { \
1055                     uint32_t v32 = la[n] * 0x01010101; \
1056                     AV_WN32A(&la[n],     v32); \
1057                     AV_WN32A(&la[n + 4], v32); \
1058                 } \
1059             } \
1060         } else { \
1061             for (n = 0; n < end; n += step) \
1062                 memset(&la[n + 1], la[n], FFMIN(end - n - 1, 7)); \
1063         } \
1064     }
1065 #define SPLAT_CTX(step) \
1066     do { \
1067         SPLAT(a, end_x, step, end_x == w4); \
1068         SPLAT(l, end_y, step, end_y == h4); \
1069     } while (0)
1070
1071     /* y tokens */
1072     switch (b->tx) {
1073     case TX_4X4:
1074         DECODE_Y_COEF_LOOP(1, b->bs > BS_8x8 ? n : 0,);
1075         break;
1076     case TX_8X8:
1077         MERGE_CTX(2, AV_RN16A);
1078         DECODE_Y_COEF_LOOP(2, 0,);
1079         SPLAT_CTX(2);
1080         break;
1081     case TX_16X16:
1082         MERGE_CTX(4, AV_RN32A);
1083         DECODE_Y_COEF_LOOP(4, 0,);
1084         SPLAT_CTX(4);
1085         break;
1086     case TX_32X32:
1087         MERGE_CTX(8, AV_RN64A);
1088         DECODE_Y_COEF_LOOP(8, 0, 32);
1089         SPLAT_CTX(8);
1090         break;
1091     }
1092
1093 #define DECODE_UV_COEF_LOOP(step, v) \
1094     for (n = 0, y = 0; y < end_y; y += step) { \
1095         for (x = 0; x < end_x; x += step, n += step * step) { \
1096             ret = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \
1097                                     (s, s->uvblock[pl] + 16 * n * bytesperpixel, \
1098                                      16 * step * step, c, e, p, a[x] + l[y], \
1099                                      uvscan, uvnb, uv_band_counts, qmul[1]); \
1100             a[x] = l[y] = !!ret; \
1101             total_coeff |= !!ret; \
1102             if (step >= 4) { \
1103                 AV_WN16A(&s->uveob[pl][n], ret); \
1104             } else { \
1105                 s->uveob[pl][n] = ret; \
1106             } \
1107         } \
1108     }
1109
1110     p = s->prob.coef[b->uvtx][1 /* uv */][!b->intra];
1111     c = s->counts.coef[b->uvtx][1 /* uv */][!b->intra];
1112     e = s->counts.eob[b->uvtx][1 /* uv */][!b->intra];
1113     w4 >>= s->ss_h;
1114     end_x >>= s->ss_h;
1115     h4 >>= s->ss_v;
1116     end_y >>= s->ss_v;
1117     for (pl = 0; pl < 2; pl++) {
1118         a = &s->above_uv_nnz_ctx[pl][col << !s->ss_h];
1119         l = &s->left_uv_nnz_ctx[pl][(row & 7) << !s->ss_v];
1120         switch (b->uvtx) {
1121         case TX_4X4:
1122             DECODE_UV_COEF_LOOP(1,);
1123             break;
1124         case TX_8X8:
1125             MERGE_CTX(2, AV_RN16A);
1126             DECODE_UV_COEF_LOOP(2,);
1127             SPLAT_CTX(2);
1128             break;
1129         case TX_16X16:
1130             MERGE_CTX(4, AV_RN32A);
1131             DECODE_UV_COEF_LOOP(4,);
1132             SPLAT_CTX(4);
1133             break;
1134         case TX_32X32:
1135             MERGE_CTX(8, AV_RN64A);
1136             DECODE_UV_COEF_LOOP(8, 32);
1137             SPLAT_CTX(8);
1138             break;
1139         }
1140     }
1141
1142     return total_coeff;
1143 }
1144
1145 static int decode_coeffs_8bpp(AVCodecContext *avctx)
1146 {
1147     return decode_coeffs(avctx, 1);
1148 }
1149
1150 static int decode_coeffs_16bpp(AVCodecContext *avctx)
1151 {
1152     return decode_coeffs(avctx, 0);
1153 }
1154
1155 static av_always_inline int check_intra_mode(VP9Context *s, int mode, uint8_t **a,
1156                                              uint8_t *dst_edge, ptrdiff_t stride_edge,
1157                                              uint8_t *dst_inner, ptrdiff_t stride_inner,
1158                                              uint8_t *l, int col, int x, int w,
1159                                              int row, int y, enum TxfmMode tx,
1160                                              int p, int ss_h, int ss_v, int bytesperpixel)
1161 {
1162     int have_top = row > 0 || y > 0;
1163     int have_left = col > s->tile_col_start || x > 0;
1164     int have_right = x < w - 1;
1165     int bpp = s->s.h.bpp;
1166     static const uint8_t mode_conv[10][2 /* have_left */][2 /* have_top */] = {
1167         [VERT_PRED]            = { { DC_127_PRED,          VERT_PRED            },
1168                                    { DC_127_PRED,          VERT_PRED            } },
1169         [HOR_PRED]             = { { DC_129_PRED,          DC_129_PRED          },
1170                                    { HOR_PRED,             HOR_PRED             } },
1171         [DC_PRED]              = { { DC_128_PRED,          TOP_DC_PRED          },
1172                                    { LEFT_DC_PRED,         DC_PRED              } },
1173         [DIAG_DOWN_LEFT_PRED]  = { { DC_127_PRED,          DIAG_DOWN_LEFT_PRED  },
1174                                    { DC_127_PRED,          DIAG_DOWN_LEFT_PRED  } },
1175         [DIAG_DOWN_RIGHT_PRED] = { { DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_RIGHT_PRED },
1176                                    { DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_RIGHT_PRED } },
1177         [VERT_RIGHT_PRED]      = { { VERT_RIGHT_PRED,      VERT_RIGHT_PRED      },
1178                                    { VERT_RIGHT_PRED,      VERT_RIGHT_PRED      } },
1179         [HOR_DOWN_PRED]        = { { HOR_DOWN_PRED,        HOR_DOWN_PRED        },
1180                                    { HOR_DOWN_PRED,        HOR_DOWN_PRED        } },
1181         [VERT_LEFT_PRED]       = { { DC_127_PRED,          VERT_LEFT_PRED       },
1182                                    { DC_127_PRED,          VERT_LEFT_PRED       } },
1183         [HOR_UP_PRED]          = { { DC_129_PRED,          DC_129_PRED          },
1184                                    { HOR_UP_PRED,          HOR_UP_PRED          } },
1185         [TM_VP8_PRED]          = { { DC_129_PRED,          VERT_PRED            },
1186                                    { HOR_PRED,             TM_VP8_PRED          } },
1187     };
1188     static const struct {
1189         uint8_t needs_left:1;
1190         uint8_t needs_top:1;
1191         uint8_t needs_topleft:1;
1192         uint8_t needs_topright:1;
1193         uint8_t invert_left:1;
1194     } edges[N_INTRA_PRED_MODES] = {
1195         [VERT_PRED]            = { .needs_top  = 1 },
1196         [HOR_PRED]             = { .needs_left = 1 },
1197         [DC_PRED]              = { .needs_top  = 1, .needs_left = 1 },
1198         [DIAG_DOWN_LEFT_PRED]  = { .needs_top  = 1, .needs_topright = 1 },
1199         [DIAG_DOWN_RIGHT_PRED] = { .needs_left = 1, .needs_top = 1,
1200                                    .needs_topleft = 1 },
1201         [VERT_RIGHT_PRED]      = { .needs_left = 1, .needs_top = 1,
1202                                    .needs_topleft = 1 },
1203         [HOR_DOWN_PRED]        = { .needs_left = 1, .needs_top = 1,
1204                                    .needs_topleft = 1 },
1205         [VERT_LEFT_PRED]       = { .needs_top  = 1, .needs_topright = 1 },
1206         [HOR_UP_PRED]          = { .needs_left = 1, .invert_left = 1 },
1207         [TM_VP8_PRED]          = { .needs_left = 1, .needs_top = 1,
1208                                    .needs_topleft = 1 },
1209         [LEFT_DC_PRED]         = { .needs_left = 1 },
1210         [TOP_DC_PRED]          = { .needs_top  = 1 },
1211         [DC_128_PRED]          = { 0 },
1212         [DC_127_PRED]          = { 0 },
1213         [DC_129_PRED]          = { 0 }
1214     };
1215
1216     av_assert2(mode >= 0 && mode < 10);
1217     mode = mode_conv[mode][have_left][have_top];
1218     if (edges[mode].needs_top) {
1219         uint8_t *top, *topleft;
1220         int n_px_need = 4 << tx, n_px_have = (((s->cols - col) << !ss_h) - x) * 4;
1221         int n_px_need_tr = 0;
1222
1223         if (tx == TX_4X4 && edges[mode].needs_topright && have_right)
1224             n_px_need_tr = 4;
1225
1226         // if top of sb64-row, use s->intra_pred_data[] instead of
1227         // dst[-stride] for intra prediction (it contains pre- instead of
1228         // post-loopfilter data)
1229         if (have_top) {
1230             top = !(row & 7) && !y ?
1231                 s->intra_pred_data[p] + (col * (8 >> ss_h) + x * 4) * bytesperpixel :
1232                 y == 0 ? &dst_edge[-stride_edge] : &dst_inner[-stride_inner];
1233             if (have_left)
1234                 topleft = !(row & 7) && !y ?
1235                     s->intra_pred_data[p] + (col * (8 >> ss_h) + x * 4) * bytesperpixel :
1236                     y == 0 || x == 0 ? &dst_edge[-stride_edge] :
1237                     &dst_inner[-stride_inner];
1238         }
1239
1240         if (have_top &&
1241             (!edges[mode].needs_topleft || (have_left && top == topleft)) &&
1242             (tx != TX_4X4 || !edges[mode].needs_topright || have_right) &&
1243             n_px_need + n_px_need_tr <= n_px_have) {
1244             *a = top;
1245         } else {
1246             if (have_top) {
1247                 if (n_px_need <= n_px_have) {
1248                     memcpy(*a, top, n_px_need * bytesperpixel);
1249                 } else {
1250 #define memset_bpp(c, i1, v, i2, num) do { \
1251     if (bytesperpixel == 1) { \
1252         memset(&(c)[(i1)], (v)[(i2)], (num)); \
1253     } else { \
1254         int n, val = AV_RN16A(&(v)[(i2) * 2]); \
1255         for (n = 0; n < (num); n++) { \
1256             AV_WN16A(&(c)[((i1) + n) * 2], val); \
1257         } \
1258     } \
1259 } while (0)
1260                     memcpy(*a, top, n_px_have * bytesperpixel);
1261                     memset_bpp(*a, n_px_have, (*a), n_px_have - 1, n_px_need - n_px_have);
1262                 }
1263             } else {
1264 #define memset_val(c, val, num) do { \
1265     if (bytesperpixel == 1) { \
1266         memset((c), (val), (num)); \
1267     } else { \
1268         int n; \
1269         for (n = 0; n < (num); n++) { \
1270             AV_WN16A(&(c)[n * 2], (val)); \
1271         } \
1272     } \
1273 } while (0)
1274                 memset_val(*a, (128 << (bpp - 8)) - 1, n_px_need);
1275             }
1276             if (edges[mode].needs_topleft) {
1277                 if (have_left && have_top) {
1278 #define assign_bpp(c, i1, v, i2) do { \
1279     if (bytesperpixel == 1) { \
1280         (c)[(i1)] = (v)[(i2)]; \
1281     } else { \
1282         AV_COPY16(&(c)[(i1) * 2], &(v)[(i2) * 2]); \
1283     } \
1284 } while (0)
1285                     assign_bpp(*a, -1, topleft, -1);
1286                 } else {
1287 #define assign_val(c, i, v) do { \
1288     if (bytesperpixel == 1) { \
1289         (c)[(i)] = (v); \
1290     } else { \
1291         AV_WN16A(&(c)[(i) * 2], (v)); \
1292     } \
1293 } while (0)
1294                     assign_val((*a), -1, (128 << (bpp - 8)) + (have_top ? +1 : -1));
1295                 }
1296             }
1297             if (tx == TX_4X4 && edges[mode].needs_topright) {
1298                 if (have_top && have_right &&
1299                     n_px_need + n_px_need_tr <= n_px_have) {
1300                     memcpy(&(*a)[4 * bytesperpixel], &top[4 * bytesperpixel], 4 * bytesperpixel);
1301                 } else {
1302                     memset_bpp(*a, 4, *a, 3, 4);
1303                 }
1304             }
1305         }
1306     }
1307     if (edges[mode].needs_left) {
1308         if (have_left) {
1309             int n_px_need = 4 << tx, i, n_px_have = (((s->rows - row) << !ss_v) - y) * 4;
1310             uint8_t *dst = x == 0 ? dst_edge : dst_inner;
1311             ptrdiff_t stride = x == 0 ? stride_edge : stride_inner;
1312
1313             if (edges[mode].invert_left) {
1314                 if (n_px_need <= n_px_have) {
1315                     for (i = 0; i < n_px_need; i++)
1316                         assign_bpp(l, i, &dst[i * stride], -1);
1317                 } else {
1318                     for (i = 0; i < n_px_have; i++)
1319                         assign_bpp(l, i, &dst[i * stride], -1);
1320                     memset_bpp(l, n_px_have, l, n_px_have - 1, n_px_need - n_px_have);
1321                 }
1322             } else {
1323                 if (n_px_need <= n_px_have) {
1324                     for (i = 0; i < n_px_need; i++)
1325                         assign_bpp(l, n_px_need - 1 - i, &dst[i * stride], -1);
1326                 } else {
1327                     for (i = 0; i < n_px_have; i++)
1328                         assign_bpp(l, n_px_need - 1 - i, &dst[i * stride], -1);
1329                     memset_bpp(l, 0, l, n_px_need - n_px_have, n_px_need - n_px_have);
1330                 }
1331             }
1332         } else {
1333             memset_val(l, (128 << (bpp - 8)) + 1, 4 << tx);
1334         }
1335     }
1336
1337     return mode;
1338 }
1339
1340 static av_always_inline void intra_recon(AVCodecContext *avctx, ptrdiff_t y_off,
1341                                          ptrdiff_t uv_off, int bytesperpixel)
1342 {
1343     VP9Context *s = avctx->priv_data;
1344     VP9Block *b = s->b;
1345     int row = s->row, col = s->col;
1346     int w4 = bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
1347     int h4 = bwh_tab[1][b->bs][1] << 1, x, y, step = 1 << (b->tx * 2);
1348     int end_x = FFMIN(2 * (s->cols - col), w4);
1349     int end_y = FFMIN(2 * (s->rows - row), h4);
1350     int tx = 4 * s->s.h.lossless + b->tx, uvtx = b->uvtx + 4 * s->s.h.lossless;
1351     int uvstep1d = 1 << b->uvtx, p;
1352     uint8_t *dst = s->dst[0], *dst_r = s->s.frames[CUR_FRAME].tf.f->data[0] + y_off;
1353     LOCAL_ALIGNED_32(uint8_t, a_buf, [96]);
1354     LOCAL_ALIGNED_32(uint8_t, l, [64]);
1355
1356     for (n = 0, y = 0; y < end_y; y += step1d) {
1357         uint8_t *ptr = dst, *ptr_r = dst_r;
1358         for (x = 0; x < end_x; x += step1d, ptr += 4 * step1d * bytesperpixel,
1359                                ptr_r += 4 * step1d * bytesperpixel, n += step) {
1360             int mode = b->mode[b->bs > BS_8x8 && b->tx == TX_4X4 ?
1361                                y * 2 + x : 0];
1362             uint8_t *a = &a_buf[32];
1363             enum TxfmType txtp = ff_vp9_intra_txfm_type[mode];
1364             int eob = b->skip ? 0 : b->tx > TX_8X8 ? AV_RN16A(&s->eob[n]) : s->eob[n];
1365
1366             mode = check_intra_mode(s, mode, &a, ptr_r,
1367                                     s->s.frames[CUR_FRAME].tf.f->linesize[0],
1368                                     ptr, s->y_stride, l,
1369                                     col, x, w4, row, y, b->tx, 0, 0, 0, bytesperpixel);
1370             s->dsp.intra_pred[b->tx][mode](ptr, s->y_stride, l, a);
1371             if (eob)
1372                 s->dsp.itxfm_add[tx][txtp](ptr, s->y_stride,
1373                                            s->block + 16 * n * bytesperpixel, eob);
1374         }
1375         dst_r += 4 * step1d * s->s.frames[CUR_FRAME].tf.f->linesize[0];
1376         dst   += 4 * step1d * s->y_stride;
1377     }
1378
1379     // U/V
1380     w4    >>= s->ss_h;
1381     end_x >>= s->ss_h;
1382     end_y >>= s->ss_v;
1383     step = 1 << (b->uvtx * 2);
1384     for (p = 0; p < 2; p++) {
1385         dst   = s->dst[1 + p];
1386         dst_r = s->s.frames[CUR_FRAME].tf.f->data[1 + p] + uv_off;
1387         for (n = 0, y = 0; y < end_y; y += uvstep1d) {
1388             uint8_t *ptr = dst, *ptr_r = dst_r;
1389             for (x = 0; x < end_x; x += uvstep1d, ptr += 4 * uvstep1d * bytesperpixel,
1390                                    ptr_r += 4 * uvstep1d * bytesperpixel, n += step) {
1391                 int mode = b->uvmode;
1392                 uint8_t *a = &a_buf[32];
1393                 int eob = b->skip ? 0 : b->uvtx > TX_8X8 ? AV_RN16A(&s->uveob[p][n]) : s->uveob[p][n];
1394
1395                 mode = check_intra_mode(s, mode, &a, ptr_r,
1396                                         s->s.frames[CUR_FRAME].tf.f->linesize[1],
1397                                         ptr, s->uv_stride, l, col, x, w4, row, y,
1398                                         b->uvtx, p + 1, s->ss_h, s->ss_v, bytesperpixel);
1399                 s->dsp.intra_pred[b->uvtx][mode](ptr, s->uv_stride, l, a);
1400                 if (eob)
1401                     s->dsp.itxfm_add[uvtx][DCT_DCT](ptr, s->uv_stride,
1402                                                     s->uvblock[p] + 16 * n * bytesperpixel, eob);
1403             }
1404             dst_r += 4 * uvstep1d * s->s.frames[CUR_FRAME].tf.f->linesize[1];
1405             dst   += 4 * uvstep1d * s->uv_stride;
1406         }
1407     }
1408 }
1409
1410 static void intra_recon_8bpp(AVCodecContext *avctx, ptrdiff_t y_off, ptrdiff_t uv_off)
1411 {
1412     intra_recon(avctx, y_off, uv_off, 1);
1413 }
1414
1415 static void intra_recon_16bpp(AVCodecContext *avctx, ptrdiff_t y_off, ptrdiff_t uv_off)
1416 {
1417     intra_recon(avctx, y_off, uv_off, 2);
1418 }
1419
1420 static av_always_inline void mc_luma_unscaled(VP9Context *s, vp9_mc_func (*mc)[2],
1421                                               uint8_t *dst, ptrdiff_t dst_stride,
1422                                               const uint8_t *ref, ptrdiff_t ref_stride,
1423                                               ThreadFrame *ref_frame,
1424                                               ptrdiff_t y, ptrdiff_t x, const VP56mv *mv,
1425                                               int bw, int bh, int w, int h, int bytesperpixel)
1426 {
1427     int mx = mv->x, my = mv->y, th;
1428
1429     y += my >> 3;
1430     x += mx >> 3;
1431     ref += y * ref_stride + x * bytesperpixel;
1432     mx &= 7;
1433     my &= 7;
1434     // FIXME bilinear filter only needs 0/1 pixels, not 3/4
1435     // we use +7 because the last 7 pixels of each sbrow can be changed in
1436     // the longest loopfilter of the next sbrow
1437     th = (y + bh + 4 * !!my + 7) >> 6;
1438     ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
1439     // The arm/aarch64 _hv filters read one more row than what actually is
1440     // needed, so switch to emulated edge one pixel sooner vertically
1441     // (!!my * 5) than horizontally (!!mx * 4).
1442     if (x < !!mx * 3 || y < !!my * 3 ||
1443         x + !!mx * 4 > w - bw || y + !!my * 5 > h - bh) {
1444         s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
1445                                  ref - !!my * 3 * ref_stride - !!mx * 3 * bytesperpixel,
1446                                  160, ref_stride,
1447                                  bw + !!mx * 7, bh + !!my * 7,
1448                                  x - !!mx * 3, y - !!my * 3, w, h);
1449         ref = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
1450         ref_stride = 160;
1451     }
1452     mc[!!mx][!!my](dst, dst_stride, ref, ref_stride, bh, mx << 1, my << 1);
1453 }
1454
1455 static av_always_inline void mc_chroma_unscaled(VP9Context *s, vp9_mc_func (*mc)[2],
1456                                                 uint8_t *dst_u, uint8_t *dst_v,
1457                                                 ptrdiff_t dst_stride,
1458                                                 const uint8_t *ref_u, ptrdiff_t src_stride_u,
1459                                                 const uint8_t *ref_v, ptrdiff_t src_stride_v,
1460                                                 ThreadFrame *ref_frame,
1461                                                 ptrdiff_t y, ptrdiff_t x, const VP56mv *mv,
1462                                                 int bw, int bh, int w, int h, int bytesperpixel)
1463 {
1464     int mx = mv->x * (1 << !s->ss_h), my = mv->y * (1 << !s->ss_v), th;
1465
1466     y += my >> 4;
1467     x += mx >> 4;
1468     ref_u += y * src_stride_u + x * bytesperpixel;
1469     ref_v += y * src_stride_v + x * bytesperpixel;
1470     mx &= 15;
1471     my &= 15;
1472     // FIXME bilinear filter only needs 0/1 pixels, not 3/4
1473     // we use +7 because the last 7 pixels of each sbrow can be changed in
1474     // the longest loopfilter of the next sbrow
1475     th = (y + bh + 4 * !!my + 7) >> (6 - s->ss_v);
1476     ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
1477     // The arm/aarch64 _hv filters read one more row than what actually is
1478     // needed, so switch to emulated edge one pixel sooner vertically
1479     // (!!my * 5) than horizontally (!!mx * 4).
1480     if (x < !!mx * 3 || y < !!my * 3 ||
1481         x + !!mx * 4 > w - bw || y + !!my * 5 > h - bh) {
1482         s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
1483                                  ref_u - !!my * 3 * src_stride_u - !!mx * 3 * bytesperpixel,
1484                                  160, src_stride_u,
1485                                  bw + !!mx * 7, bh + !!my * 7,
1486                                  x - !!mx * 3, y - !!my * 3, w, h);
1487         ref_u = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
1488         mc[!!mx][!!my](dst_u, dst_stride, ref_u, 160, bh, mx, my);
1489
1490         s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
1491                                  ref_v - !!my * 3 * src_stride_v - !!mx * 3 * bytesperpixel,
1492                                  160, src_stride_v,
1493                                  bw + !!mx * 7, bh + !!my * 7,
1494                                  x - !!mx * 3, y - !!my * 3, w, h);
1495         ref_v = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
1496         mc[!!mx][!!my](dst_v, dst_stride, ref_v, 160, bh, mx, my);
1497     } else {
1498         mc[!!mx][!!my](dst_u, dst_stride, ref_u, src_stride_u, bh, mx, my);
1499         mc[!!mx][!!my](dst_v, dst_stride, ref_v, src_stride_v, bh, mx, my);
1500     }
1501 }
1502
1503 #define mc_luma_dir(s, mc, dst, dst_ls, src, src_ls, tref, row, col, mv, \
1504                     px, py, pw, ph, bw, bh, w, h, i) \
1505     mc_luma_unscaled(s, s->dsp.mc, dst, dst_ls, src, src_ls, tref, row, col, \
1506                      mv, bw, bh, w, h, bytesperpixel)
1507 #define mc_chroma_dir(s, mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
1508                       row, col, mv, px, py, pw, ph, bw, bh, w, h, i) \
1509     mc_chroma_unscaled(s, s->dsp.mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
1510                        row, col, mv, bw, bh, w, h, bytesperpixel)
1511 #define SCALED 0
1512 #define FN(x) x##_8bpp
1513 #define BYTES_PER_PIXEL 1
1514 #include "vp9_mc_template.c"
1515 #undef FN
1516 #undef BYTES_PER_PIXEL
1517 #define FN(x) x##_16bpp
1518 #define BYTES_PER_PIXEL 2
1519 #include "vp9_mc_template.c"
1520 #undef mc_luma_dir
1521 #undef mc_chroma_dir
1522 #undef FN
1523 #undef BYTES_PER_PIXEL
1524 #undef SCALED
1525
1526 static av_always_inline void mc_luma_scaled(VP9Context *s, vp9_scaled_mc_func smc,
1527                                             vp9_mc_func (*mc)[2],
1528                                             uint8_t *dst, ptrdiff_t dst_stride,
1529                                             const uint8_t *ref, ptrdiff_t ref_stride,
1530                                             ThreadFrame *ref_frame,
1531                                             ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv,
1532                                             int px, int py, int pw, int ph,
1533                                             int bw, int bh, int w, int h, int bytesperpixel,
1534                                             const uint16_t *scale, const uint8_t *step)
1535 {
1536     if (s->s.frames[CUR_FRAME].tf.f->width == ref_frame->f->width &&
1537         s->s.frames[CUR_FRAME].tf.f->height == ref_frame->f->height) {
1538         mc_luma_unscaled(s, mc, dst, dst_stride, ref, ref_stride, ref_frame,
1539                          y, x, in_mv, bw, bh, w, h, bytesperpixel);
1540     } else {
1541 #define scale_mv(n, dim) (((int64_t)(n) * scale[dim]) >> 14)
1542     int mx, my;
1543     int refbw_m1, refbh_m1;
1544     int th;
1545     VP56mv mv;
1546
1547     mv.x = av_clip(in_mv->x, -(x + pw - px + 4) * 8, (s->cols * 8 - x + px + 3) * 8);
1548     mv.y = av_clip(in_mv->y, -(y + ph - py + 4) * 8, (s->rows * 8 - y + py + 3) * 8);
1549     // BUG libvpx seems to scale the two components separately. This introduces
1550     // rounding errors but we have to reproduce them to be exactly compatible
1551     // with the output from libvpx...
1552     mx = scale_mv(mv.x * 2, 0) + scale_mv(x * 16, 0);
1553     my = scale_mv(mv.y * 2, 1) + scale_mv(y * 16, 1);
1554
1555     y = my >> 4;
1556     x = mx >> 4;
1557     ref += y * ref_stride + x * bytesperpixel;
1558     mx &= 15;
1559     my &= 15;
1560     refbw_m1 = ((bw - 1) * step[0] + mx) >> 4;
1561     refbh_m1 = ((bh - 1) * step[1] + my) >> 4;
1562     // FIXME bilinear filter only needs 0/1 pixels, not 3/4
1563     // we use +7 because the last 7 pixels of each sbrow can be changed in
1564     // the longest loopfilter of the next sbrow
1565     th = (y + refbh_m1 + 4 + 7) >> 6;
1566     ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
1567     // The arm/aarch64 _hv filters read one more row than what actually is
1568     // needed, so switch to emulated edge one pixel sooner vertically
1569     // (y + 5 >= h - refbh_m1) than horizontally (x + 4 >= w - refbw_m1).
1570     if (x < 3 || y < 3 || x + 4 >= w - refbw_m1 || y + 5 >= h - refbh_m1) {
1571         s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
1572                                  ref - 3 * ref_stride - 3 * bytesperpixel,
1573                                  288, ref_stride,
1574                                  refbw_m1 + 8, refbh_m1 + 8,
1575                                  x - 3, y - 3, w, h);
1576         ref = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
1577         ref_stride = 288;
1578     }
1579     smc(dst, dst_stride, ref, ref_stride, bh, mx, my, step[0], step[1]);
1580     }
1581 }
1582
1583 static av_always_inline void mc_chroma_scaled(VP9Context *s, vp9_scaled_mc_func smc,
1584                                               vp9_mc_func (*mc)[2],
1585                                               uint8_t *dst_u, uint8_t *dst_v,
1586                                               ptrdiff_t dst_stride,
1587                                               const uint8_t *ref_u, ptrdiff_t src_stride_u,
1588                                               const uint8_t *ref_v, ptrdiff_t src_stride_v,
1589                                               ThreadFrame *ref_frame,
1590                                               ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv,
1591                                               int px, int py, int pw, int ph,
1592                                               int bw, int bh, int w, int h, int bytesperpixel,
1593                                               const uint16_t *scale, const uint8_t *step)
1594 {
1595     if (s->s.frames[CUR_FRAME].tf.f->width == ref_frame->f->width &&
1596         s->s.frames[CUR_FRAME].tf.f->height == ref_frame->f->height) {
1597         mc_chroma_unscaled(s, mc, dst_u, dst_v, dst_stride, ref_u, src_stride_u,
1598                            ref_v, src_stride_v, ref_frame,
1599                            y, x, in_mv, bw, bh, w, h, bytesperpixel);
1600     } else {
1601     int mx, my;
1602     int refbw_m1, refbh_m1;
1603     int th;
1604     VP56mv mv;
1605
1606     if (s->ss_h) {
1607         // BUG https://code.google.com/p/webm/issues/detail?id=820
1608         mv.x = av_clip(in_mv->x, -(x + pw - px + 4) * 16, (s->cols * 4 - x + px + 3) * 16);
1609         mx = scale_mv(mv.x, 0) + (scale_mv(x * 16, 0) & ~15) + (scale_mv(x * 32, 0) & 15);
1610     } else {
1611         mv.x = av_clip(in_mv->x, -(x + pw - px + 4) * 8, (s->cols * 8 - x + px + 3) * 8);
1612         mx = scale_mv(mv.x * 2, 0) + scale_mv(x * 16, 0);
1613     }
1614     if (s->ss_v) {
1615         // BUG https://code.google.com/p/webm/issues/detail?id=820
1616         mv.y = av_clip(in_mv->y, -(y + ph - py + 4) * 16, (s->rows * 4 - y + py + 3) * 16);
1617         my = scale_mv(mv.y, 1) + (scale_mv(y * 16, 1) & ~15) + (scale_mv(y * 32, 1) & 15);
1618     } else {
1619         mv.y = av_clip(in_mv->y, -(y + ph - py + 4) * 8, (s->rows * 8 - y + py + 3) * 8);
1620         my = scale_mv(mv.y * 2, 1) + scale_mv(y * 16, 1);
1621     }
1622 #undef scale_mv
1623     y = my >> 4;
1624     x = mx >> 4;
1625     ref_u += y * src_stride_u + x * bytesperpixel;
1626     ref_v += y * src_stride_v + x * bytesperpixel;
1627     mx &= 15;
1628     my &= 15;
1629     refbw_m1 = ((bw - 1) * step[0] + mx) >> 4;
1630     refbh_m1 = ((bh - 1) * step[1] + my) >> 4;
1631     // FIXME bilinear filter only needs 0/1 pixels, not 3/4
1632     // we use +7 because the last 7 pixels of each sbrow can be changed in
1633     // the longest loopfilter of the next sbrow
1634     th = (y + refbh_m1 + 4 + 7) >> (6 - s->ss_v);
1635     ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
1636     // The arm/aarch64 _hv filters read one more row than what actually is
1637     // needed, so switch to emulated edge one pixel sooner vertically
1638     // (y + 5 >= h - refbh_m1) than horizontally (x + 4 >= w - refbw_m1).
1639     if (x < 3 || y < 3 || x + 4 >= w - refbw_m1 || y + 5 >= h - refbh_m1) {
1640         s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
1641                                  ref_u - 3 * src_stride_u - 3 * bytesperpixel,
1642                                  288, src_stride_u,
1643                                  refbw_m1 + 8, refbh_m1 + 8,
1644                                  x - 3, y - 3, w, h);
1645         ref_u = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
1646         smc(dst_u, dst_stride, ref_u, 288, bh, mx, my, step[0], step[1]);
1647
1648         s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
1649                                  ref_v - 3 * src_stride_v - 3 * bytesperpixel,
1650                                  288, src_stride_v,
1651                                  refbw_m1 + 8, refbh_m1 + 8,
1652                                  x - 3, y - 3, w, h);
1653         ref_v = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
1654         smc(dst_v, dst_stride, ref_v, 288, bh, mx, my, step[0], step[1]);
1655     } else {
1656         smc(dst_u, dst_stride, ref_u, src_stride_u, bh, mx, my, step[0], step[1]);
1657         smc(dst_v, dst_stride, ref_v, src_stride_v, bh, mx, my, step[0], step[1]);
1658     }
1659     }
1660 }
1661
1662 #define mc_luma_dir(s, mc, dst, dst_ls, src, src_ls, tref, row, col, mv, \
1663                     px, py, pw, ph, bw, bh, w, h, i) \
1664     mc_luma_scaled(s, s->dsp.s##mc, s->dsp.mc, dst, dst_ls, src, src_ls, tref, row, col, \
1665                    mv, px, py, pw, ph, bw, bh, w, h, bytesperpixel, \
1666                    s->mvscale[b->ref[i]], s->mvstep[b->ref[i]])
1667 #define mc_chroma_dir(s, mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
1668                       row, col, mv, px, py, pw, ph, bw, bh, w, h, i) \
1669     mc_chroma_scaled(s, s->dsp.s##mc, s->dsp.mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
1670                      row, col, mv, px, py, pw, ph, bw, bh, w, h, bytesperpixel, \
1671                      s->mvscale[b->ref[i]], s->mvstep[b->ref[i]])
1672 #define SCALED 1
1673 #define FN(x) x##_scaled_8bpp
1674 #define BYTES_PER_PIXEL 1
1675 #include "vp9_mc_template.c"
1676 #undef FN
1677 #undef BYTES_PER_PIXEL
1678 #define FN(x) x##_scaled_16bpp
1679 #define BYTES_PER_PIXEL 2
1680 #include "vp9_mc_template.c"
1681 #undef mc_luma_dir
1682 #undef mc_chroma_dir
1683 #undef FN
1684 #undef BYTES_PER_PIXEL
1685 #undef SCALED
1686
1687 static av_always_inline void inter_recon(AVCodecContext *avctx, int bytesperpixel)
1688 {
1689     VP9Context *s = avctx->priv_data;
1690     VP9Block *b = s->b;
1691     int row = s->row, col = s->col;
1692
1693     if (s->mvscale[b->ref[0]][0] || (b->comp && s->mvscale[b->ref[1]][0])) {
1694         if (bytesperpixel == 1) {
1695             inter_pred_scaled_8bpp(avctx);
1696         } else {
1697             inter_pred_scaled_16bpp(avctx);
1698         }
1699     } else {
1700         if (bytesperpixel == 1) {
1701             inter_pred_8bpp(avctx);
1702         } else {
1703             inter_pred_16bpp(avctx);
1704         }
1705     }
1706
1707     if (!b->skip) {
1708         /* mostly copied intra_recon() */
1709
1710         int w4 = bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
1711         int h4 = bwh_tab[1][b->bs][1] << 1, x, y, step = 1 << (b->tx * 2);
1712         int end_x = FFMIN(2 * (s->cols - col), w4);
1713         int end_y = FFMIN(2 * (s->rows - row), h4);
1714         int tx = 4 * s->s.h.lossless + b->tx, uvtx = b->uvtx + 4 * s->s.h.lossless;
1715         int uvstep1d = 1 << b->uvtx, p;
1716         uint8_t *dst = s->dst[0];
1717
1718         // y itxfm add
1719         for (n = 0, y = 0; y < end_y; y += step1d) {
1720             uint8_t *ptr = dst;
1721             for (x = 0; x < end_x; x += step1d,
1722                  ptr += 4 * step1d * bytesperpixel, n += step) {
1723                 int eob = b->tx > TX_8X8 ? AV_RN16A(&s->eob[n]) : s->eob[n];
1724
1725                 if (eob)
1726                     s->dsp.itxfm_add[tx][DCT_DCT](ptr, s->y_stride,
1727                                                   s->block + 16 * n * bytesperpixel, eob);
1728             }
1729             dst += 4 * s->y_stride * step1d;
1730         }
1731
1732         // uv itxfm add
1733         end_x >>= s->ss_h;
1734         end_y >>= s->ss_v;
1735         step = 1 << (b->uvtx * 2);
1736         for (p = 0; p < 2; p++) {
1737             dst = s->dst[p + 1];
1738             for (n = 0, y = 0; y < end_y; y += uvstep1d) {
1739                 uint8_t *ptr = dst;
1740                 for (x = 0; x < end_x; x += uvstep1d,
1741                      ptr += 4 * uvstep1d * bytesperpixel, n += step) {
1742                     int eob = b->uvtx > TX_8X8 ? AV_RN16A(&s->uveob[p][n]) : s->uveob[p][n];
1743
1744                     if (eob)
1745                         s->dsp.itxfm_add[uvtx][DCT_DCT](ptr, s->uv_stride,
1746                                                         s->uvblock[p] + 16 * n * bytesperpixel, eob);
1747                 }
1748                 dst += 4 * uvstep1d * s->uv_stride;
1749             }
1750         }
1751     }
1752 }
1753
1754 static void inter_recon_8bpp(AVCodecContext *avctx)
1755 {
1756     inter_recon(avctx, 1);
1757 }
1758
1759 static void inter_recon_16bpp(AVCodecContext *avctx)
1760 {
1761     inter_recon(avctx, 2);
1762 }
1763
1764 static av_always_inline void mask_edges(uint8_t (*mask)[8][4], int ss_h, int ss_v,
1765                                         int row_and_7, int col_and_7,
1766                                         int w, int h, int col_end, int row_end,
1767                                         enum TxfmMode tx, int skip_inter)
1768 {
1769     static const unsigned wide_filter_col_mask[2] = { 0x11, 0x01 };
1770     static const unsigned wide_filter_row_mask[2] = { 0x03, 0x07 };
1771
1772     // FIXME I'm pretty sure all loops can be replaced by a single LUT if
1773     // we make VP9Filter.mask uint64_t (i.e. row/col all single variable)
1774     // and make the LUT 5-indexed (bl, bp, is_uv, tx and row/col), and then
1775     // use row_and_7/col_and_7 as shifts (1*col_and_7+8*row_and_7)
1776
1777     // the intended behaviour of the vp9 loopfilter is to work on 8-pixel
1778     // edges. This means that for UV, we work on two subsampled blocks at
1779     // a time, and we only use the topleft block's mode information to set
1780     // things like block strength. Thus, for any block size smaller than
1781     // 16x16, ignore the odd portion of the block.
1782     if (tx == TX_4X4 && (ss_v | ss_h)) {
1783         if (h == ss_v) {
1784             if (row_and_7 & 1)
1785                 return;
1786             if (!row_end)
1787                 h += 1;
1788         }
1789         if (w == ss_h) {
1790             if (col_and_7 & 1)
1791                 return;
1792             if (!col_end)
1793                 w += 1;
1794         }
1795     }
1796
1797     if (tx == TX_4X4 && !skip_inter) {
1798         int t = 1 << col_and_7, m_col = (t << w) - t, y;
1799         // on 32-px edges, use the 8-px wide loopfilter; else, use 4-px wide
1800         int m_row_8 = m_col & wide_filter_col_mask[ss_h], m_row_4 = m_col - m_row_8;
1801
1802         for (y = row_and_7; y < h + row_and_7; y++) {
1803             int col_mask_id = 2 - !(y & wide_filter_row_mask[ss_v]);
1804
1805             mask[0][y][1] |= m_row_8;
1806             mask[0][y][2] |= m_row_4;
1807             // for odd lines, if the odd col is not being filtered,
1808             // skip odd row also:
1809             // .---. <-- a
1810             // |   |
1811             // |___| <-- b
1812             // ^   ^
1813             // c   d
1814             //
1815             // if a/c are even row/col and b/d are odd, and d is skipped,
1816             // e.g. right edge of size-66x66.webm, then skip b also (bug)
1817             if ((ss_h & ss_v) && (col_end & 1) && (y & 1)) {
1818                 mask[1][y][col_mask_id] |= (t << (w - 1)) - t;
1819             } else {
1820                 mask[1][y][col_mask_id] |= m_col;
1821             }
1822             if (!ss_h)
1823                 mask[0][y][3] |= m_col;
1824             if (!ss_v) {
1825                 if (ss_h && (col_end & 1))
1826                     mask[1][y][3] |= (t << (w - 1)) - t;
1827                 else
1828                     mask[1][y][3] |= m_col;
1829             }
1830         }
1831     } else {
1832         int y, t = 1 << col_and_7, m_col = (t << w) - t;
1833
1834         if (!skip_inter) {
1835             int mask_id = (tx == TX_8X8);
1836             int l2 = tx + ss_h - 1, step1d;
1837             static const unsigned masks[4] = { 0xff, 0x55, 0x11, 0x01 };
1838             int m_row = m_col & masks[l2];
1839
1840             // at odd UV col/row edges tx16/tx32 loopfilter edges, force
1841             // 8wd loopfilter to prevent going off the visible edge.
1842             if (ss_h && tx > TX_8X8 && (w ^ (w - 1)) == 1) {
1843                 int m_row_16 = ((t << (w - 1)) - t) & masks[l2];
1844                 int m_row_8 = m_row - m_row_16;
1845
1846                 for (y = row_and_7; y < h + row_and_7; y++) {
1847                     mask[0][y][0] |= m_row_16;
1848                     mask[0][y][1] |= m_row_8;
1849                 }
1850             } else {
1851                 for (y = row_and_7; y < h + row_and_7; y++)
1852                     mask[0][y][mask_id] |= m_row;
1853             }
1854
1855             l2 = tx + ss_v - 1;
1856             step1d = 1 << l2;
1857             if (ss_v && tx > TX_8X8 && (h ^ (h - 1)) == 1) {
1858                 for (y = row_and_7; y < h + row_and_7 - 1; y += step1d)
1859                     mask[1][y][0] |= m_col;
1860                 if (y - row_and_7 == h - 1)
1861                     mask[1][y][1] |= m_col;
1862             } else {
1863                 for (y = row_and_7; y < h + row_and_7; y += step1d)
1864                     mask[1][y][mask_id] |= m_col;
1865             }
1866         } else if (tx != TX_4X4) {
1867             int mask_id;
1868
1869             mask_id = (tx == TX_8X8) || (h == ss_v);
1870             mask[1][row_and_7][mask_id] |= m_col;
1871             mask_id = (tx == TX_8X8) || (w == ss_h);
1872             for (y = row_and_7; y < h + row_and_7; y++)
1873                 mask[0][y][mask_id] |= t;
1874         } else {
1875             int t8 = t & wide_filter_col_mask[ss_h], t4 = t - t8;
1876
1877             for (y = row_and_7; y < h + row_and_7; y++) {
1878                 mask[0][y][2] |= t4;
1879                 mask[0][y][1] |= t8;
1880             }
1881             mask[1][row_and_7][2 - !(row_and_7 & wide_filter_row_mask[ss_v])] |= m_col;
1882         }
1883     }
1884 }
1885
1886 void ff_vp9_decode_block(AVCodecContext *avctx, int row, int col,
1887                          VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff,
1888                          enum BlockLevel bl, enum BlockPartition bp)
1889 {
1890     VP9Context *s = avctx->priv_data;
1891     VP9Block *b = s->b;
1892     enum BlockSize bs = bl * 3 + bp;
1893     int bytesperpixel = s->bytesperpixel;
1894     int w4 = bwh_tab[1][bs][0], h4 = bwh_tab[1][bs][1], lvl;
1895     int emu[2];
1896     AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
1897
1898     s->row = row;
1899     s->row7 = row & 7;
1900     s->col = col;
1901     s->col7 = col & 7;
1902
1903     s->min_mv.x = -(128 + col * 64);
1904     s->min_mv.y = -(128 + row * 64);
1905     s->max_mv.x = 128 + (s->cols - col - w4) * 64;
1906     s->max_mv.y = 128 + (s->rows - row - h4) * 64;
1907
1908     if (s->pass < 2) {
1909         b->bs = bs;
1910         b->bl = bl;
1911         b->bp = bp;
1912         decode_mode(avctx);
1913         b->uvtx = b->tx - ((s->ss_h && w4 * 2 == (1 << b->tx)) ||
1914                            (s->ss_v && h4 * 2 == (1 << b->tx)));
1915
1916         if (!b->skip) {
1917             int has_coeffs;
1918
1919             if (bytesperpixel == 1) {
1920                 has_coeffs = decode_coeffs_8bpp(avctx);
1921             } else {
1922                 has_coeffs = decode_coeffs_16bpp(avctx);
1923             }
1924             if (!has_coeffs && b->bs <= BS_8x8 && !b->intra) {
1925                 b->skip = 1;
1926                 memset(&s->above_skip_ctx[col], 1, w4);
1927                 memset(&s->left_skip_ctx[s->row7], 1, h4);
1928             }
1929         } else {
1930             int row7 = s->row7;
1931
1932 #define SPLAT_ZERO_CTX(v, n) \
1933     switch (n) { \
1934     case 1:  v = 0;          break; \
1935     case 2:  AV_ZERO16(&v);  break; \
1936     case 4:  AV_ZERO32(&v);  break; \
1937     case 8:  AV_ZERO64(&v);  break; \
1938     case 16: AV_ZERO128(&v); break; \
1939     }
1940 #define SPLAT_ZERO_YUV(dir, var, off, n, dir2) \
1941     do { \
1942         SPLAT_ZERO_CTX(s->dir##_y_##var[off * 2], n * 2); \
1943         if (s->ss_##dir2) { \
1944             SPLAT_ZERO_CTX(s->dir##_uv_##var[0][off], n); \
1945             SPLAT_ZERO_CTX(s->dir##_uv_##var[1][off], n); \
1946         } else { \
1947             SPLAT_ZERO_CTX(s->dir##_uv_##var[0][off * 2], n * 2); \
1948             SPLAT_ZERO_CTX(s->dir##_uv_##var[1][off * 2], n * 2); \
1949         } \
1950     } while (0)
1951
1952             switch (w4) {
1953             case 1: SPLAT_ZERO_YUV(above, nnz_ctx, col, 1, h); break;
1954             case 2: SPLAT_ZERO_YUV(above, nnz_ctx, col, 2, h); break;
1955             case 4: SPLAT_ZERO_YUV(above, nnz_ctx, col, 4, h); break;
1956             case 8: SPLAT_ZERO_YUV(above, nnz_ctx, col, 8, h); break;
1957             }
1958             switch (h4) {
1959             case 1: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 1, v); break;
1960             case 2: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 2, v); break;
1961             case 4: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 4, v); break;
1962             case 8: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 8, v); break;
1963             }
1964         }
1965
1966         if (s->pass == 1) {
1967             s->b++;
1968             s->block += w4 * h4 * 64 * bytesperpixel;
1969             s->uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v);
1970             s->uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v);
1971             s->eob += 4 * w4 * h4;
1972             s->uveob[0] += 4 * w4 * h4 >> (s->ss_h + s->ss_v);
1973             s->uveob[1] += 4 * w4 * h4 >> (s->ss_h + s->ss_v);
1974
1975             return;
1976         }
1977     }
1978
1979     // emulated overhangs if the stride of the target buffer can't hold. This
1980     // makes it possible to support emu-edge and so on even if we have large block
1981     // overhangs
1982     emu[0] = (col + w4) * 8 * bytesperpixel > f->linesize[0] ||
1983              (row + h4) > s->rows;
1984     emu[1] = ((col + w4) * 8 >> s->ss_h) * bytesperpixel > f->linesize[1] ||
1985              (row + h4) > s->rows;
1986     if (emu[0]) {
1987         s->dst[0] = s->tmp_y;
1988         s->y_stride = 128;
1989     } else {
1990         s->dst[0] = f->data[0] + yoff;
1991         s->y_stride = f->linesize[0];
1992     }
1993     if (emu[1]) {
1994         s->dst[1] = s->tmp_uv[0];
1995         s->dst[2] = s->tmp_uv[1];
1996         s->uv_stride = 128;
1997     } else {
1998         s->dst[1] = f->data[1] + uvoff;
1999         s->dst[2] = f->data[2] + uvoff;
2000         s->uv_stride = f->linesize[1];
2001     }
2002     if (b->intra) {
2003         if (s->s.h.bpp > 8) {
2004             intra_recon_16bpp(avctx, yoff, uvoff);
2005         } else {
2006             intra_recon_8bpp(avctx, yoff, uvoff);
2007         }
2008     } else {
2009         if (s->s.h.bpp > 8) {
2010             inter_recon_16bpp(avctx);
2011         } else {
2012             inter_recon_8bpp(avctx);
2013         }
2014     }
2015     if (emu[0]) {
2016         int w = FFMIN(s->cols - col, w4) * 8, h = FFMIN(s->rows - row, h4) * 8, n, o = 0;
2017
2018         for (n = 0; o < w; n++) {
2019             int bw = 64 >> n;
2020
2021             av_assert2(n <= 4);
2022             if (w & bw) {
2023                 s->dsp.mc[n][0][0][0][0](f->data[0] + yoff + o * bytesperpixel, f->linesize[0],
2024                                          s->tmp_y + o * bytesperpixel, 128, h, 0, 0);
2025                 o += bw;
2026             }
2027         }
2028     }
2029     if (emu[1]) {
2030         int w = FFMIN(s->cols - col, w4) * 8 >> s->ss_h;
2031         int h = FFMIN(s->rows - row, h4) * 8 >> s->ss_v, n, o = 0;
2032
2033         for (n = s->ss_h; o < w; n++) {
2034             int bw = 64 >> n;
2035
2036             av_assert2(n <= 4);
2037             if (w & bw) {
2038                 s->dsp.mc[n][0][0][0][0](f->data[1] + uvoff + o * bytesperpixel, f->linesize[1],
2039                                          s->tmp_uv[0] + o * bytesperpixel, 128, h, 0, 0);
2040                 s->dsp.mc[n][0][0][0][0](f->data[2] + uvoff + o * bytesperpixel, f->linesize[2],
2041                                          s->tmp_uv[1] + o * bytesperpixel, 128, h, 0, 0);
2042                 o += bw;
2043             }
2044         }
2045     }
2046
2047     // pick filter level and find edges to apply filter to
2048     if (s->s.h.filter.level &&
2049         (lvl = s->s.h.segmentation.feat[b->seg_id].lflvl[b->intra ? 0 : b->ref[0] + 1]
2050                                                       [b->mode[3] != ZEROMV]) > 0) {
2051         int x_end = FFMIN(s->cols - col, w4), y_end = FFMIN(s->rows - row, h4);
2052         int skip_inter = !b->intra && b->skip, col7 = s->col7, row7 = s->row7;
2053
2054         setctx_2d(&lflvl->level[row7 * 8 + col7], w4, h4, 8, lvl);
2055         mask_edges(lflvl->mask[0], 0, 0, row7, col7, x_end, y_end, 0, 0, b->tx, skip_inter);
2056         if (s->ss_h || s->ss_v)
2057             mask_edges(lflvl->mask[1], s->ss_h, s->ss_v, row7, col7, x_end, y_end,
2058                        s->cols & 1 && col + w4 >= s->cols ? s->cols & 7 : 0,
2059                        s->rows & 1 && row + h4 >= s->rows ? s->rows & 7 : 0,
2060                        b->uvtx, skip_inter);
2061
2062         if (!s->filter_lut.lim_lut[lvl]) {
2063             int sharp = s->s.h.filter.sharpness;
2064             int limit = lvl;
2065
2066             if (sharp > 0) {
2067                 limit >>= (sharp + 3) >> 2;
2068                 limit = FFMIN(limit, 9 - sharp);
2069             }
2070             limit = FFMAX(limit, 1);
2071
2072             s->filter_lut.lim_lut[lvl] = limit;
2073             s->filter_lut.mblim_lut[lvl] = 2 * (lvl + 2) + limit;
2074         }
2075     }
2076
2077     if (s->pass == 2) {
2078         s->b++;
2079         s->block += w4 * h4 * 64 * bytesperpixel;
2080         s->uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h);
2081         s->uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h);
2082         s->eob += 4 * w4 * h4;
2083         s->uveob[0] += 4 * w4 * h4 >> (s->ss_v + s->ss_h);
2084         s->uveob[1] += 4 * w4 * h4 >> (s->ss_v + s->ss_h);
2085     }
2086 }