← Back to branch summary

~ppsspp/ppsspp/ppsspp-1.1.1

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/vp9.c

  • Committer: Sérgio Benjamim
  • Date: 2015-10-17 01:37:55 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20151017013755-avrlz2pt37kwt43x
PPSSPP 1.1.1 source.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/vp9.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 "avcodec.h"
 
25
#include "get_bits.h"
 
26
#include "internal.h"
 
27
#include "thread.h"
 
28
#include "videodsp.h"
 
29
#include "vp56.h"
 
30
#include "vp9.h"
 
31
#include "vp9data.h"
 
32
#include "vp9dsp.h"
 
33
#include "libavutil/avassert.h"
 
34
#include "libavutil/pixdesc.h"
 
35
 
 
36
#define VP9_SYNCCODE 0x498342
 
37
 
 
38
enum CompPredMode {
 
39
    PRED_SINGLEREF,
 
40
    PRED_COMPREF,
 
41
    PRED_SWITCHABLE,
 
42
};
 
43
 
 
44
enum BlockLevel {
 
45
    BL_64X64,
 
46
    BL_32X32,
 
47
    BL_16X16,
 
48
    BL_8X8,
 
49
};
 
50
 
 
51
enum BlockSize {
 
52
    BS_64x64,
 
53
    BS_64x32,
 
54
    BS_32x64,
 
55
    BS_32x32,
 
56
    BS_32x16,
 
57
    BS_16x32,
 
58
    BS_16x16,
 
59
    BS_16x8,
 
60
    BS_8x16,
 
61
    BS_8x8,
 
62
    BS_8x4,
 
63
    BS_4x8,
 
64
    BS_4x4,
 
65
    N_BS_SIZES,
 
66
};
 
67
 
 
68
struct VP9mvrefPair {
 
69
    VP56mv mv[2];
 
70
    int8_t ref[2];
 
71
};
 
72
 
 
73
typedef struct VP9Frame {
 
74
    ThreadFrame tf;
 
75
    AVBufferRef *extradata;
 
76
    uint8_t *segmentation_map;
 
77
    struct VP9mvrefPair *mv;
 
78
    int uses_2pass;
 
79
} VP9Frame;
 
80
 
 
81
struct VP9Filter {
 
82
    uint8_t level[8 * 8];
 
83
    uint8_t /* bit=col */ mask[2 /* 0=y, 1=uv */][2 /* 0=col, 1=row */]
 
84
                              [8 /* rows */][4 /* 0=16, 1=8, 2=4, 3=inner4 */];
 
85
};
 
86
 
 
87
typedef struct VP9Block {
 
88
    uint8_t seg_id, intra, comp, ref[2], mode[4], uvmode, skip;
 
89
    enum FilterMode filter;
 
90
    VP56mv mv[4 /* b_idx */][2 /* ref */];
 
91
    enum BlockSize bs;
 
92
    enum TxfmMode tx, uvtx;
 
93
    enum BlockLevel bl;
 
94
    enum BlockPartition bp;
 
95
} VP9Block;
 
96
 
 
97
typedef struct VP9Context {
 
98
    VP9DSPContext dsp;
 
99
    VideoDSPContext vdsp;
 
100
    GetBitContext gb;
 
101
    VP56RangeCoder c;
 
102
    VP56RangeCoder *c_b;
 
103
    unsigned c_b_size;
 
104
    VP9Block *b_base, *b;
 
105
    int pass;
 
106
    int row, row7, col, col7;
 
107
    uint8_t *dst[3];
 
108
    ptrdiff_t y_stride, uv_stride;
 
109
 
 
110
    // bitstream header
 
111
    uint8_t keyframe, last_keyframe;
 
112
    uint8_t last_bpp, bpp, bpp_index, bytesperpixel;
 
113
    uint8_t invisible;
 
114
    uint8_t use_last_frame_mvs;
 
115
    uint8_t errorres;
 
116
    uint8_t ss_h, ss_v;
 
117
    uint8_t intraonly;
 
118
    uint8_t resetctx;
 
119
    uint8_t refreshrefmask;
 
120
    uint8_t highprecisionmvs;
 
121
    enum FilterMode filtermode;
 
122
    uint8_t allowcompinter;
 
123
    uint8_t fixcompref;
 
124
    uint8_t refreshctx;
 
125
    uint8_t parallelmode;
 
126
    uint8_t framectxid;
 
127
    uint8_t refidx[3];
 
128
    uint8_t signbias[3];
 
129
    uint8_t varcompref[2];
 
130
    ThreadFrame refs[8], next_refs[8];
 
131
#define CUR_FRAME 0
 
132
#define REF_FRAME_MVPAIR 1
 
133
#define REF_FRAME_SEGMAP 2
 
134
    VP9Frame frames[3];
 
135
 
 
136
    struct {
 
137
        uint8_t level;
 
138
        int8_t sharpness;
 
139
        uint8_t lim_lut[64];
 
140
        uint8_t mblim_lut[64];
 
141
    } filter;
 
142
    struct {
 
143
        uint8_t enabled;
 
144
        int8_t mode[2];
 
145
        int8_t ref[4];
 
146
    } lf_delta;
 
147
    uint8_t yac_qi;
 
148
    int8_t ydc_qdelta, uvdc_qdelta, uvac_qdelta;
 
149
    uint8_t lossless;
 
150
#define MAX_SEGMENT 8
 
151
    struct {
 
152
        uint8_t enabled;
 
153
        uint8_t temporal;
 
154
        uint8_t absolute_vals;
 
155
        uint8_t update_map;
 
156
        uint8_t ignore_refmap;
 
157
        struct {
 
158
            uint8_t q_enabled;
 
159
            uint8_t lf_enabled;
 
160
            uint8_t ref_enabled;
 
161
            uint8_t skip_enabled;
 
162
            uint8_t ref_val;
 
163
            int16_t q_val;
 
164
            int8_t lf_val;
 
165
            int16_t qmul[2][2];
 
166
            uint8_t lflvl[4][2];
 
167
        } feat[MAX_SEGMENT];
 
168
    } segmentation;
 
169
    struct {
 
170
        unsigned log2_tile_cols, log2_tile_rows;
 
171
        unsigned tile_cols, tile_rows;
 
172
        unsigned tile_row_start, tile_row_end, tile_col_start, tile_col_end;
 
173
    } tiling;
 
174
    unsigned sb_cols, sb_rows, rows, cols;
 
175
    struct {
 
176
        prob_context p;
 
177
        uint8_t coef[4][2][2][6][6][3];
 
178
    } prob_ctx[4];
 
179
    struct {
 
180
        prob_context p;
 
181
        uint8_t coef[4][2][2][6][6][11];
 
182
        uint8_t seg[7];
 
183
        uint8_t segpred[3];
 
184
    } prob;
 
185
    struct {
 
186
        unsigned y_mode[4][10];
 
187
        unsigned uv_mode[10][10];
 
188
        unsigned filter[4][3];
 
189
        unsigned mv_mode[7][4];
 
190
        unsigned intra[4][2];
 
191
        unsigned comp[5][2];
 
192
        unsigned single_ref[5][2][2];
 
193
        unsigned comp_ref[5][2];
 
194
        unsigned tx32p[2][4];
 
195
        unsigned tx16p[2][3];
 
196
        unsigned tx8p[2][2];
 
197
        unsigned skip[3][2];
 
198
        unsigned mv_joint[4];
 
199
        struct {
 
200
            unsigned sign[2];
 
201
            unsigned classes[11];
 
202
            unsigned class0[2];
 
203
            unsigned bits[10][2];
 
204
            unsigned class0_fp[2][4];
 
205
            unsigned fp[4];
 
206
            unsigned class0_hp[2];
 
207
            unsigned hp[2];
 
208
        } mv_comp[2];
 
209
        unsigned partition[4][4][4];
 
210
        unsigned coef[4][2][2][6][6][3];
 
211
        unsigned eob[4][2][2][6][6][2];
 
212
    } counts;
 
213
    enum TxfmMode txfmmode;
 
214
    enum CompPredMode comppredmode;
 
215
 
 
216
    // contextual (left/above) cache
 
217
    DECLARE_ALIGNED(16, uint8_t, left_y_nnz_ctx)[16];
 
218
    DECLARE_ALIGNED(16, uint8_t, left_mode_ctx)[16];
 
219
    DECLARE_ALIGNED(16, VP56mv, left_mv_ctx)[16][2];
 
220
    DECLARE_ALIGNED(16, uint8_t, left_uv_nnz_ctx)[2][16];
 
221
    DECLARE_ALIGNED(8, uint8_t, left_partition_ctx)[8];
 
222
    DECLARE_ALIGNED(8, uint8_t, left_skip_ctx)[8];
 
223
    DECLARE_ALIGNED(8, uint8_t, left_txfm_ctx)[8];
 
224
    DECLARE_ALIGNED(8, uint8_t, left_segpred_ctx)[8];
 
225
    DECLARE_ALIGNED(8, uint8_t, left_intra_ctx)[8];
 
226
    DECLARE_ALIGNED(8, uint8_t, left_comp_ctx)[8];
 
227
    DECLARE_ALIGNED(8, uint8_t, left_ref_ctx)[8];
 
228
    DECLARE_ALIGNED(8, uint8_t, left_filter_ctx)[8];
 
229
    uint8_t *above_partition_ctx;
 
230
    uint8_t *above_mode_ctx;
 
231
    // FIXME maybe merge some of the below in a flags field?
 
232
    uint8_t *above_y_nnz_ctx;
 
233
    uint8_t *above_uv_nnz_ctx[2];
 
234
    uint8_t *above_skip_ctx; // 1bit
 
235
    uint8_t *above_txfm_ctx; // 2bit
 
236
    uint8_t *above_segpred_ctx; // 1bit
 
237
    uint8_t *above_intra_ctx; // 1bit
 
238
    uint8_t *above_comp_ctx; // 1bit
 
239
    uint8_t *above_ref_ctx; // 2bit
 
240
    uint8_t *above_filter_ctx;
 
241
    VP56mv (*above_mv_ctx)[2];
 
242
 
 
243
    // whole-frame cache
 
244
    uint8_t *intra_pred_data[3];
 
245
    struct VP9Filter *lflvl;
 
246
    DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer)[135 * 144 * 2];
 
247
 
 
248
    // block reconstruction intermediates
 
249
    int block_alloc_using_2pass;
 
250
    int16_t *block_base, *block, *uvblock_base[2], *uvblock[2];
 
251
    uint8_t *eob_base, *uveob_base[2], *eob, *uveob[2];
 
252
    struct { int x, y; } min_mv, max_mv;
 
253
    DECLARE_ALIGNED(32, uint8_t, tmp_y)[64 * 64 * 2];
 
254
    DECLARE_ALIGNED(32, uint8_t, tmp_uv)[2][64 * 64 * 2];
 
255
    uint16_t mvscale[3][2];
 
256
    uint8_t mvstep[3][2];
 
257
} VP9Context;
 
258
 
 
259
static const uint8_t bwh_tab[2][N_BS_SIZES][2] = {
 
260
    {
 
261
        { 16, 16 }, { 16, 8 }, { 8, 16 }, { 8, 8 }, { 8, 4 }, { 4, 8 },
 
262
        { 4, 4 }, { 4, 2 }, { 2, 4 }, { 2, 2 }, { 2, 1 }, { 1, 2 }, { 1, 1 },
 
263
    }, {
 
264
        { 8, 8 }, { 8, 4 }, { 4, 8 }, { 4, 4 }, { 4, 2 }, { 2, 4 },
 
265
        { 2, 2 }, { 2, 1 }, { 1, 2 }, { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 },
 
266
    }
 
267
};
 
268
 
 
269
static int vp9_alloc_frame(AVCodecContext *ctx, VP9Frame *f)
 
270
{
 
271
    VP9Context *s = ctx->priv_data;
 
272
    int ret, sz;
 
273
 
 
274
    if ((ret = ff_thread_get_buffer(ctx, &f->tf, AV_GET_BUFFER_FLAG_REF)) < 0)
 
275
        return ret;
 
276
    sz = 64 * s->sb_cols * s->sb_rows;
 
277
    if (!(f->extradata = av_buffer_allocz(sz * (1 + sizeof(struct VP9mvrefPair))))) {
 
278
        ff_thread_release_buffer(ctx, &f->tf);
 
279
        return AVERROR(ENOMEM);
 
280
    }
 
281
 
 
282
    f->segmentation_map = f->extradata->data;
 
283
    f->mv = (struct VP9mvrefPair *) (f->extradata->data + sz);
 
284
 
 
285
    return 0;
 
286
}
 
287
 
 
288
static void vp9_unref_frame(AVCodecContext *ctx, VP9Frame *f)
 
289
{
 
290
    ff_thread_release_buffer(ctx, &f->tf);
 
291
    av_buffer_unref(&f->extradata);
 
292
}
 
293
 
 
294
static int vp9_ref_frame(AVCodecContext *ctx, VP9Frame *dst, VP9Frame *src)
 
295
{
 
296
    int res;
 
297
 
 
298
    if ((res = ff_thread_ref_frame(&dst->tf, &src->tf)) < 0) {
 
299
        return res;
 
300
    } else if (!(dst->extradata = av_buffer_ref(src->extradata))) {
 
301
        vp9_unref_frame(ctx, dst);
 
302
        return AVERROR(ENOMEM);
 
303
    }
 
304
 
 
305
    dst->segmentation_map = src->segmentation_map;
 
306
    dst->mv = src->mv;
 
307
    dst->uses_2pass = src->uses_2pass;
 
308
 
 
309
    return 0;
 
310
}
 
311
 
 
312
static int update_size(AVCodecContext *ctx, int w, int h, enum AVPixelFormat fmt)
 
313
{
 
314
    VP9Context *s = ctx->priv_data;
 
315
    uint8_t *p;
 
316
    int bytesperpixel = s->bytesperpixel;
 
317
 
 
318
    av_assert0(w > 0 && h > 0);
 
319
 
 
320
    if (s->intra_pred_data[0] && w == ctx->width && h == ctx->height && ctx->pix_fmt == fmt)
 
321
        return 0;
 
322
 
 
323
    ctx->width   = w;
 
324
    ctx->height  = h;
 
325
    ctx->pix_fmt = fmt;
 
326
    s->sb_cols   = (w + 63) >> 6;
 
327
    s->sb_rows   = (h + 63) >> 6;
 
328
    s->cols      = (w + 7) >> 3;
 
329
    s->rows      = (h + 7) >> 3;
 
330
 
 
331
#define assign(var, type, n) var = (type) p; p += s->sb_cols * (n) * sizeof(*var)
 
332
    av_freep(&s->intra_pred_data[0]);
 
333
    // FIXME we slightly over-allocate here for subsampled chroma, but a little
 
334
    // bit of padding shouldn't affect performance...
 
335
    p = av_malloc(s->sb_cols * (128 + 192 * bytesperpixel +
 
336
                                sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx)));
 
337
    if (!p)
 
338
        return AVERROR(ENOMEM);
 
339
    assign(s->intra_pred_data[0],  uint8_t *,             64 * bytesperpixel);
 
340
    assign(s->intra_pred_data[1],  uint8_t *,             64 * bytesperpixel);
 
341
    assign(s->intra_pred_data[2],  uint8_t *,             64 * bytesperpixel);
 
342
    assign(s->above_y_nnz_ctx,     uint8_t *,             16);
 
343
    assign(s->above_mode_ctx,      uint8_t *,             16);
 
344
    assign(s->above_mv_ctx,        VP56mv(*)[2],          16);
 
345
    assign(s->above_uv_nnz_ctx[0], uint8_t *,             16);
 
346
    assign(s->above_uv_nnz_ctx[1], uint8_t *,             16);
 
347
    assign(s->above_partition_ctx, uint8_t *,              8);
 
348
    assign(s->above_skip_ctx,      uint8_t *,              8);
 
349
    assign(s->above_txfm_ctx,      uint8_t *,              8);
 
350
    assign(s->above_segpred_ctx,   uint8_t *,              8);
 
351
    assign(s->above_intra_ctx,     uint8_t *,              8);
 
352
    assign(s->above_comp_ctx,      uint8_t *,              8);
 
353
    assign(s->above_ref_ctx,       uint8_t *,              8);
 
354
    assign(s->above_filter_ctx,    uint8_t *,              8);
 
355
    assign(s->lflvl,               struct VP9Filter *,     1);
 
356
#undef assign
 
357
 
 
358
    // these will be re-allocated a little later
 
359
    av_freep(&s->b_base);
 
360
    av_freep(&s->block_base);
 
361
 
 
362
    if (s->bpp != s->last_bpp) {
 
363
        ff_vp9dsp_init(&s->dsp, s->bpp);
 
364
        ff_videodsp_init(&s->vdsp, s->bpp);
 
365
        s->last_bpp = s->bpp;
 
366
    }
 
367
 
 
368
    return 0;
 
369
}
 
370
 
 
371
static int update_block_buffers(AVCodecContext *ctx)
 
372
{
 
373
    VP9Context *s = ctx->priv_data;
 
374
    int chroma_blocks, chroma_eobs, bytesperpixel = s->bytesperpixel;
 
375
 
 
376
    if (s->b_base && s->block_base && s->block_alloc_using_2pass == s->frames[CUR_FRAME].uses_2pass)
 
377
        return 0;
 
378
 
 
379
    av_free(s->b_base);
 
380
    av_free(s->block_base);
 
381
    chroma_blocks = 64 * 64 >> (s->ss_h + s->ss_v);
 
382
    chroma_eobs   = 16 * 16 >> (s->ss_h + s->ss_v);
 
383
    if (s->frames[CUR_FRAME].uses_2pass) {
 
384
        int sbs = s->sb_cols * s->sb_rows;
 
385
 
 
386
        s->b_base = av_malloc_array(s->cols * s->rows, sizeof(VP9Block));
 
387
        s->block_base = av_mallocz(((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
 
388
                                    16 * 16 + 2 * chroma_eobs) * sbs);
 
389
        if (!s->b_base || !s->block_base)
 
390
            return AVERROR(ENOMEM);
 
391
        s->uvblock_base[0] = s->block_base + sbs * 64 * 64 * bytesperpixel;
 
392
        s->uvblock_base[1] = s->uvblock_base[0] + sbs * chroma_blocks * bytesperpixel;
 
393
        s->eob_base = (uint8_t *) (s->uvblock_base[1] + sbs * chroma_blocks * bytesperpixel);
 
394
        s->uveob_base[0] = s->eob_base + 16 * 16 * sbs;
 
395
        s->uveob_base[1] = s->uveob_base[0] + chroma_eobs * sbs;
 
396
    } else {
 
397
        s->b_base = av_malloc(sizeof(VP9Block));
 
398
        s->block_base = av_mallocz((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
 
399
                                   16 * 16 + 2 * chroma_eobs);
 
400
        if (!s->b_base || !s->block_base)
 
401
            return AVERROR(ENOMEM);
 
402
        s->uvblock_base[0] = s->block_base + 64 * 64 * bytesperpixel;
 
403
        s->uvblock_base[1] = s->uvblock_base[0] + chroma_blocks * bytesperpixel;
 
404
        s->eob_base = (uint8_t *) (s->uvblock_base[1] + chroma_blocks * bytesperpixel);
 
405
        s->uveob_base[0] = s->eob_base + 16 * 16;
 
406
        s->uveob_base[1] = s->uveob_base[0] + chroma_eobs;
 
407
    }
 
408
    s->block_alloc_using_2pass = s->frames[CUR_FRAME].uses_2pass;
 
409
 
 
410
    return 0;
 
411
}
 
412
 
 
413
// for some reason the sign bit is at the end, not the start, of a bit sequence
 
414
static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)
 
415
{
 
416
    int v = get_bits(gb, n);
 
417
    return get_bits1(gb) ? -v : v;
 
418
}
 
419
 
 
420
static av_always_inline int inv_recenter_nonneg(int v, int m)
 
421
{
 
422
    return v > 2 * m ? v : v & 1 ? m - ((v + 1) >> 1) : m + (v >> 1);
 
423
}
 
424
 
 
425
// differential forward probability updates
 
426
static int update_prob(VP56RangeCoder *c, int p)
 
427
{
 
428
    static const int inv_map_table[255] = {
 
429
          7,  20,  33,  46,  59,  72,  85,  98, 111, 124, 137, 150, 163, 176,
 
430
        189, 202, 215, 228, 241, 254,   1,   2,   3,   4,   5,   6,   8,   9,
 
431
         10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  21,  22,  23,  24,
 
432
         25,  26,  27,  28,  29,  30,  31,  32,  34,  35,  36,  37,  38,  39,
 
433
         40,  41,  42,  43,  44,  45,  47,  48,  49,  50,  51,  52,  53,  54,
 
434
         55,  56,  57,  58,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,
 
435
         70,  71,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,
 
436
         86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  99, 100,
 
437
        101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 112, 113, 114, 115,
 
438
        116, 117, 118, 119, 120, 121, 122, 123, 125, 126, 127, 128, 129, 130,
 
439
        131, 132, 133, 134, 135, 136, 138, 139, 140, 141, 142, 143, 144, 145,
 
440
        146, 147, 148, 149, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
 
441
        161, 162, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
 
442
        177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, 191,
 
443
        192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204, 205, 206,
 
444
        207, 208, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219, 220, 221,
 
445
        222, 223, 224, 225, 226, 227, 229, 230, 231, 232, 233, 234, 235, 236,
 
446
        237, 238, 239, 240, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
 
447
        252, 253, 253,
 
448
    };
 
449
    int d;
 
450
 
 
451
    /* This code is trying to do a differential probability update. For a
 
452
     * current probability A in the range [1, 255], the difference to a new
 
453
     * probability of any value can be expressed differentially as 1-A,255-A
 
454
     * where some part of this (absolute range) exists both in positive as
 
455
     * well as the negative part, whereas another part only exists in one
 
456
     * half. We're trying to code this shared part differentially, i.e.
 
457
     * times two where the value of the lowest bit specifies the sign, and
 
458
     * the single part is then coded on top of this. This absolute difference
 
459
     * then again has a value of [0,254], but a bigger value in this range
 
460
     * indicates that we're further away from the original value A, so we
 
461
     * can code this as a VLC code, since higher values are increasingly
 
462
     * unlikely. The first 20 values in inv_map_table[] allow 'cheap, rough'
 
463
     * updates vs. the 'fine, exact' updates further down the range, which
 
464
     * adds one extra dimension to this differential update model. */
 
465
 
 
466
    if (!vp8_rac_get(c)) {
 
467
        d = vp8_rac_get_uint(c, 4) + 0;
 
468
    } else if (!vp8_rac_get(c)) {
 
469
        d = vp8_rac_get_uint(c, 4) + 16;
 
470
    } else if (!vp8_rac_get(c)) {
 
471
        d = vp8_rac_get_uint(c, 5) + 32;
 
472
    } else {
 
473
        d = vp8_rac_get_uint(c, 7);
 
474
        if (d >= 65)
 
475
            d = (d << 1) - 65 + vp8_rac_get(c);
 
476
        d += 64;
 
477
        av_assert2(d < FF_ARRAY_ELEMS(inv_map_table));
 
478
    }
 
479
 
 
480
    return p <= 128 ? 1 + inv_recenter_nonneg(inv_map_table[d], p - 1) :
 
481
                    255 - inv_recenter_nonneg(inv_map_table[d], 255 - p);
 
482
}
 
483
 
 
484
static enum AVPixelFormat read_colorspace_details(AVCodecContext *ctx)
 
485
{
 
486
    static const enum AVColorSpace colorspaces[8] = {
 
487
        AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M,
 
488
        AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB,
 
489
    };
 
490
    VP9Context *s = ctx->priv_data;
 
491
    enum AVPixelFormat res;
 
492
    int bits = ctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
 
493
 
 
494
    s->bpp_index = bits;
 
495
    s->bpp = 8 + bits * 2;
 
496
    s->bytesperpixel = (7 + s->bpp) >> 3;
 
497
    ctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
 
498
    if (ctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
 
499
        static const enum AVPixelFormat pix_fmt_rgb[3] = {
 
500
            AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12
 
501
        };
 
502
        if (ctx->profile & 1) {
 
503
            s->ss_h = s->ss_v = 1;
 
504
            res = pix_fmt_rgb[bits];
 
505
            ctx->color_range = AVCOL_RANGE_JPEG;
 
506
        } else {
 
507
            av_log(ctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
 
508
                   ctx->profile);
 
509
            return AVERROR_INVALIDDATA;
 
510
        }
 
511
    } else {
 
512
        static const enum AVPixelFormat pix_fmt_for_ss[3][2 /* v */][2 /* h */] = {
 
513
            { { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P },
 
514
              { AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV420P } },
 
515
            { { AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10 },
 
516
              { AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV420P10 } },
 
517
            { { AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12 },
 
518
              { AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12 } }
 
519
        };
 
520
        ctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
 
521
        if (ctx->profile & 1) {
 
522
            s->ss_h = get_bits1(&s->gb);
 
523
            s->ss_v = get_bits1(&s->gb);
 
524
            if ((res = pix_fmt_for_ss[bits][s->ss_v][s->ss_h]) == AV_PIX_FMT_YUV420P) {
 
525
                av_log(ctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
 
526
                       ctx->profile);
 
527
                return AVERROR_INVALIDDATA;
 
528
            } else if (get_bits1(&s->gb)) {
 
529
                av_log(ctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
 
530
                       ctx->profile);
 
531
                return AVERROR_INVALIDDATA;
 
532
            }
 
533
        } else {
 
534
            s->ss_h = s->ss_v = 1;
 
535
            res = pix_fmt_for_ss[bits][1][1];
 
536
        }
 
537
    }
 
538
 
 
539
    return res;
 
540
}
 
541
 
 
542
static int decode_frame_header(AVCodecContext *ctx,
 
543
                               const uint8_t *data, int size, int *ref)
 
544
{
 
545
    VP9Context *s = ctx->priv_data;
 
546
    int c, i, j, k, l, m, n, w, h, max, size2, res, sharp;
 
547
    enum AVPixelFormat fmt = ctx->pix_fmt;
 
548
    int last_invisible;
 
549
    const uint8_t *data2;
 
550
 
 
551
    /* general header */
 
552
    if ((res = init_get_bits8(&s->gb, data, size)) < 0) {
 
553
        av_log(ctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
 
554
        return res;
 
555
    }
 
556
    if (get_bits(&s->gb, 2) != 0x2) { // frame marker
 
557
        av_log(ctx, AV_LOG_ERROR, "Invalid frame marker\n");
 
558
        return AVERROR_INVALIDDATA;
 
559
    }
 
560
    ctx->profile  = get_bits1(&s->gb);
 
561
    ctx->profile |= get_bits1(&s->gb) << 1;
 
562
    if (ctx->profile == 3) ctx->profile += get_bits1(&s->gb);
 
563
    if (ctx->profile > 3) {
 
564
        av_log(ctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", ctx->profile);
 
565
        return AVERROR_INVALIDDATA;
 
566
    }
 
567
    if (get_bits1(&s->gb)) {
 
568
        *ref = get_bits(&s->gb, 3);
 
569
        return 0;
 
570
    }
 
571
    s->last_keyframe  = s->keyframe;
 
572
    s->keyframe       = !get_bits1(&s->gb);
 
573
    last_invisible    = s->invisible;
 
574
    s->invisible      = !get_bits1(&s->gb);
 
575
    s->errorres       = get_bits1(&s->gb);
 
576
    s->use_last_frame_mvs = !s->errorres && !last_invisible;
 
577
    if (s->keyframe) {
 
578
        if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
 
579
            av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");
 
580
            return AVERROR_INVALIDDATA;
 
581
        }
 
582
        if ((fmt = read_colorspace_details(ctx)) < 0)
 
583
            return fmt;
 
584
        // for profile 1, here follows the subsampling bits
 
585
        s->refreshrefmask = 0xff;
 
586
        w = get_bits(&s->gb, 16) + 1;
 
587
        h = get_bits(&s->gb, 16) + 1;
 
588
        if (get_bits1(&s->gb)) // display size
 
589
            skip_bits(&s->gb, 32);
 
590
    } else {
 
591
        s->intraonly  = s->invisible ? get_bits1(&s->gb) : 0;
 
592
        s->resetctx   = s->errorres ? 0 : get_bits(&s->gb, 2);
 
593
        if (s->intraonly) {
 
594
            if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
 
595
                av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");
 
596
                return AVERROR_INVALIDDATA;
 
597
            }
 
598
            if (ctx->profile == 1) {
 
599
                if ((fmt = read_colorspace_details(ctx)) < 0)
 
600
                    return fmt;
 
601
            } else {
 
602
                s->ss_h = s->ss_v = 1;
 
603
                s->bpp = 8;
 
604
                s->bpp_index = 0;
 
605
                s->bytesperpixel = 1;
 
606
                fmt = AV_PIX_FMT_YUV420P;
 
607
                ctx->colorspace = AVCOL_SPC_BT470BG;
 
608
                ctx->color_range = AVCOL_RANGE_JPEG;
 
609
            }
 
610
            s->refreshrefmask = get_bits(&s->gb, 8);
 
611
            w = get_bits(&s->gb, 16) + 1;
 
612
            h = get_bits(&s->gb, 16) + 1;
 
613
            if (get_bits1(&s->gb)) // display size
 
614
                skip_bits(&s->gb, 32);
 
615
        } else {
 
616
            s->refreshrefmask = get_bits(&s->gb, 8);
 
617
            s->refidx[0]      = get_bits(&s->gb, 3);
 
618
            s->signbias[0]    = get_bits1(&s->gb) && !s->errorres;
 
619
            s->refidx[1]      = get_bits(&s->gb, 3);
 
620
            s->signbias[1]    = get_bits1(&s->gb) && !s->errorres;
 
621
            s->refidx[2]      = get_bits(&s->gb, 3);
 
622
            s->signbias[2]    = get_bits1(&s->gb) && !s->errorres;
 
623
            if (!s->refs[s->refidx[0]].f->data[0] ||
 
624
                !s->refs[s->refidx[1]].f->data[0] ||
 
625
                !s->refs[s->refidx[2]].f->data[0]) {
 
626
                av_log(ctx, AV_LOG_ERROR, "Not all references are available\n");
 
627
                return AVERROR_INVALIDDATA;
 
628
            }
 
629
            if (get_bits1(&s->gb)) {
 
630
                w = s->refs[s->refidx[0]].f->width;
 
631
                h = s->refs[s->refidx[0]].f->height;
 
632
            } else if (get_bits1(&s->gb)) {
 
633
                w = s->refs[s->refidx[1]].f->width;
 
634
                h = s->refs[s->refidx[1]].f->height;
 
635
            } else if (get_bits1(&s->gb)) {
 
636
                w = s->refs[s->refidx[2]].f->width;
 
637
                h = s->refs[s->refidx[2]].f->height;
 
638
            } else {
 
639
                w = get_bits(&s->gb, 16) + 1;
 
640
                h = get_bits(&s->gb, 16) + 1;
 
641
            }
 
642
            // Note that in this code, "CUR_FRAME" is actually before we
 
643
            // have formally allocated a frame, and thus actually represents
 
644
            // the _last_ frame
 
645
            s->use_last_frame_mvs &= s->frames[CUR_FRAME].tf.f->width == w &&
 
646
                                     s->frames[CUR_FRAME].tf.f->height == h;
 
647
            if (get_bits1(&s->gb)) // display size
 
648
                skip_bits(&s->gb, 32);
 
649
            s->highprecisionmvs = get_bits1(&s->gb);
 
650
            s->filtermode = get_bits1(&s->gb) ? FILTER_SWITCHABLE :
 
651
                                                get_bits(&s->gb, 2);
 
652
            s->allowcompinter = (s->signbias[0] != s->signbias[1] ||
 
653
                                 s->signbias[0] != s->signbias[2]);
 
654
            if (s->allowcompinter) {
 
655
                if (s->signbias[0] == s->signbias[1]) {
 
656
                    s->fixcompref    = 2;
 
657
                    s->varcompref[0] = 0;
 
658
                    s->varcompref[1] = 1;
 
659
                } else if (s->signbias[0] == s->signbias[2]) {
 
660
                    s->fixcompref    = 1;
 
661
                    s->varcompref[0] = 0;
 
662
                    s->varcompref[1] = 2;
 
663
                } else {
 
664
                    s->fixcompref    = 0;
 
665
                    s->varcompref[0] = 1;
 
666
                    s->varcompref[1] = 2;
 
667
                }
 
668
            }
 
669
 
 
670
            for (i = 0; i < 3; i++) {
 
671
                AVFrame *ref = s->refs[s->refidx[i]].f;
 
672
                int refw = ref->width, refh = ref->height;
 
673
 
 
674
                if (ref->format != fmt) {
 
675
                    av_log(ctx, AV_LOG_ERROR,
 
676
                           "Ref pixfmt (%s) did not match current frame (%s)",
 
677
                           av_get_pix_fmt_name(ref->format),
 
678
                           av_get_pix_fmt_name(fmt));
 
679
                    return AVERROR_INVALIDDATA;
 
680
                } else if (refw == w && refh == h) {
 
681
                    s->mvscale[i][0] = s->mvscale[i][1] = 0;
 
682
                } else {
 
683
                    if (w * 2 < refw || h * 2 < refh || w > 16 * refw || h > 16 * refh) {
 
684
                        av_log(ctx, AV_LOG_ERROR,
 
685
                               "Invalid ref frame dimensions %dx%d for frame size %dx%d\n",
 
686
                               refw, refh, w, h);
 
687
                        return AVERROR_INVALIDDATA;
 
688
                    }
 
689
                    s->mvscale[i][0] = (refw << 14) / w;
 
690
                    s->mvscale[i][1] = (refh << 14) / h;
 
691
                    s->mvstep[i][0] = 16 * s->mvscale[i][0] >> 14;
 
692
                    s->mvstep[i][1] = 16 * s->mvscale[i][1] >> 14;
 
693
                }
 
694
            }
 
695
        }
 
696
    }
 
697
    s->refreshctx   = s->errorres ? 0 : get_bits1(&s->gb);
 
698
    s->parallelmode = s->errorres ? 1 : get_bits1(&s->gb);
 
699
    s->framectxid   = c = get_bits(&s->gb, 2);
 
700
 
 
701
    /* loopfilter header data */
 
702
    if (s->keyframe || s->errorres || s->intraonly) {
 
703
        // reset loopfilter defaults
 
704
        s->lf_delta.ref[0] = 1;
 
705
        s->lf_delta.ref[1] = 0;
 
706
        s->lf_delta.ref[2] = -1;
 
707
        s->lf_delta.ref[3] = -1;
 
708
        s->lf_delta.mode[0] = 0;
 
709
        s->lf_delta.mode[1] = 0;
 
710
    }
 
711
    s->filter.level = get_bits(&s->gb, 6);
 
712
    sharp = get_bits(&s->gb, 3);
 
713
    // if sharpness changed, reinit lim/mblim LUTs. if it didn't change, keep
 
714
    // the old cache values since they are still valid
 
715
    if (s->filter.sharpness != sharp)
 
716
        memset(s->filter.lim_lut, 0, sizeof(s->filter.lim_lut));
 
717
    s->filter.sharpness = sharp;
 
718
    if ((s->lf_delta.enabled = get_bits1(&s->gb))) {
 
719
        if (get_bits1(&s->gb)) {
 
720
            for (i = 0; i < 4; i++)
 
721
                if (get_bits1(&s->gb))
 
722
                    s->lf_delta.ref[i] = get_sbits_inv(&s->gb, 6);
 
723
            for (i = 0; i < 2; i++)
 
724
                if (get_bits1(&s->gb))
 
725
                    s->lf_delta.mode[i] = get_sbits_inv(&s->gb, 6);
 
726
        }
 
727
    }
 
728
 
 
729
    /* quantization header data */
 
730
    s->yac_qi      = get_bits(&s->gb, 8);
 
731
    s->ydc_qdelta  = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
 
732
    s->uvdc_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
 
733
    s->uvac_qdelta = get_bits1(&s->gb) ? get_sbits_inv(&s->gb, 4) : 0;
 
734
    s->lossless    = s->yac_qi == 0 && s->ydc_qdelta == 0 &&
 
735
                     s->uvdc_qdelta == 0 && s->uvac_qdelta == 0;
 
736
 
 
737
    /* segmentation header info */
 
738
    s->segmentation.ignore_refmap = 0;
 
739
    if ((s->segmentation.enabled = get_bits1(&s->gb))) {
 
740
        if ((s->segmentation.update_map = get_bits1(&s->gb))) {
 
741
            for (i = 0; i < 7; i++)
 
742
                s->prob.seg[i] = get_bits1(&s->gb) ?
 
743
                                 get_bits(&s->gb, 8) : 255;
 
744
            if ((s->segmentation.temporal = get_bits1(&s->gb))) {
 
745
                for (i = 0; i < 3; i++)
 
746
                    s->prob.segpred[i] = get_bits1(&s->gb) ?
 
747
                                         get_bits(&s->gb, 8) : 255;
 
748
            }
 
749
        }
 
750
        if ((!s->segmentation.update_map || s->segmentation.temporal) &&
 
751
            (w != s->frames[CUR_FRAME].tf.f->width ||
 
752
             h != s->frames[CUR_FRAME].tf.f->height)) {
 
753
            av_log(ctx, AV_LOG_WARNING,
 
754
                   "Reference segmap (temp=%d,update=%d) enabled on size-change!\n",
 
755
                   s->segmentation.temporal, s->segmentation.update_map);
 
756
                s->segmentation.ignore_refmap = 1;
 
757
            //return AVERROR_INVALIDDATA;
 
758
        }
 
759
 
 
760
        if (get_bits1(&s->gb)) {
 
761
            s->segmentation.absolute_vals = get_bits1(&s->gb);
 
762
            for (i = 0; i < 8; i++) {
 
763
                if ((s->segmentation.feat[i].q_enabled = get_bits1(&s->gb)))
 
764
                    s->segmentation.feat[i].q_val = get_sbits_inv(&s->gb, 8);
 
765
                if ((s->segmentation.feat[i].lf_enabled = get_bits1(&s->gb)))
 
766
                    s->segmentation.feat[i].lf_val = get_sbits_inv(&s->gb, 6);
 
767
                if ((s->segmentation.feat[i].ref_enabled = get_bits1(&s->gb)))
 
768
                    s->segmentation.feat[i].ref_val = get_bits(&s->gb, 2);
 
769
                s->segmentation.feat[i].skip_enabled = get_bits1(&s->gb);
 
770
            }
 
771
        }
 
772
    } else {
 
773
        s->segmentation.feat[0].q_enabled    = 0;
 
774
        s->segmentation.feat[0].lf_enabled   = 0;
 
775
        s->segmentation.feat[0].skip_enabled = 0;
 
776
        s->segmentation.feat[0].ref_enabled  = 0;
 
777
    }
 
778
 
 
779
    // set qmul[] based on Y/UV, AC/DC and segmentation Q idx deltas
 
780
    for (i = 0; i < (s->segmentation.enabled ? 8 : 1); i++) {
 
781
        int qyac, qydc, quvac, quvdc, lflvl, sh;
 
782
 
 
783
        if (s->segmentation.feat[i].q_enabled) {
 
784
            if (s->segmentation.absolute_vals)
 
785
                qyac = s->segmentation.feat[i].q_val;
 
786
            else
 
787
                qyac = s->yac_qi + s->segmentation.feat[i].q_val;
 
788
        } else {
 
789
            qyac  = s->yac_qi;
 
790
        }
 
791
        qydc  = av_clip_uintp2(qyac + s->ydc_qdelta, 8);
 
792
        quvdc = av_clip_uintp2(qyac + s->uvdc_qdelta, 8);
 
793
        quvac = av_clip_uintp2(qyac + s->uvac_qdelta, 8);
 
794
        qyac  = av_clip_uintp2(qyac, 8);
 
795
 
 
796
        s->segmentation.feat[i].qmul[0][0] = vp9_dc_qlookup[s->bpp_index][qydc];
 
797
        s->segmentation.feat[i].qmul[0][1] = vp9_ac_qlookup[s->bpp_index][qyac];
 
798
        s->segmentation.feat[i].qmul[1][0] = vp9_dc_qlookup[s->bpp_index][quvdc];
 
799
        s->segmentation.feat[i].qmul[1][1] = vp9_ac_qlookup[s->bpp_index][quvac];
 
800
 
 
801
        sh = s->filter.level >= 32;
 
802
        if (s->segmentation.feat[i].lf_enabled) {
 
803
            if (s->segmentation.absolute_vals)
 
804
                lflvl = av_clip_uintp2(s->segmentation.feat[i].lf_val, 6);
 
805
            else
 
806
                lflvl = av_clip_uintp2(s->filter.level + s->segmentation.feat[i].lf_val, 6);
 
807
        } else {
 
808
            lflvl  = s->filter.level;
 
809
        }
 
810
        if (s->lf_delta.enabled) {
 
811
            s->segmentation.feat[i].lflvl[0][0] =
 
812
            s->segmentation.feat[i].lflvl[0][1] =
 
813
                av_clip_uintp2(lflvl + (s->lf_delta.ref[0] << sh), 6);
 
814
            for (j = 1; j < 4; j++) {
 
815
                s->segmentation.feat[i].lflvl[j][0] =
 
816
                    av_clip_uintp2(lflvl + ((s->lf_delta.ref[j] +
 
817
                                             s->lf_delta.mode[0]) * (1 << sh)), 6);
 
818
                s->segmentation.feat[i].lflvl[j][1] =
 
819
                    av_clip_uintp2(lflvl + ((s->lf_delta.ref[j] +
 
820
                                             s->lf_delta.mode[1]) * (1 << sh)), 6);
 
821
            }
 
822
        } else {
 
823
            memset(s->segmentation.feat[i].lflvl, lflvl,
 
824
                   sizeof(s->segmentation.feat[i].lflvl));
 
825
        }
 
826
    }
 
827
 
 
828
    /* tiling info */
 
829
    if ((res = update_size(ctx, w, h, fmt)) < 0) {
 
830
        av_log(ctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n", w, h, fmt);
 
831
        return res;
 
832
    }
 
833
    for (s->tiling.log2_tile_cols = 0;
 
834
         (s->sb_cols >> s->tiling.log2_tile_cols) > 64;
 
835
         s->tiling.log2_tile_cols++) ;
 
836
    for (max = 0; (s->sb_cols >> max) >= 4; max++) ;
 
837
    max = FFMAX(0, max - 1);
 
838
    while (max > s->tiling.log2_tile_cols) {
 
839
        if (get_bits1(&s->gb))
 
840
            s->tiling.log2_tile_cols++;
 
841
        else
 
842
            break;
 
843
    }
 
844
    s->tiling.log2_tile_rows = decode012(&s->gb);
 
845
    s->tiling.tile_rows = 1 << s->tiling.log2_tile_rows;
 
846
    if (s->tiling.tile_cols != (1 << s->tiling.log2_tile_cols)) {
 
847
        s->tiling.tile_cols = 1 << s->tiling.log2_tile_cols;
 
848
        s->c_b = av_fast_realloc(s->c_b, &s->c_b_size,
 
849
                                 sizeof(VP56RangeCoder) * s->tiling.tile_cols);
 
850
        if (!s->c_b) {
 
851
            av_log(ctx, AV_LOG_ERROR, "Ran out of memory during range coder init\n");
 
852
            return AVERROR(ENOMEM);
 
853
        }
 
854
    }
 
855
 
 
856
    if (s->keyframe || s->errorres || s->intraonly) {
 
857
        s->prob_ctx[0].p = s->prob_ctx[1].p = s->prob_ctx[2].p =
 
858
                           s->prob_ctx[3].p = vp9_default_probs;
 
859
        memcpy(s->prob_ctx[0].coef, vp9_default_coef_probs,
 
860
               sizeof(vp9_default_coef_probs));
 
861
        memcpy(s->prob_ctx[1].coef, vp9_default_coef_probs,
 
862
               sizeof(vp9_default_coef_probs));
 
863
        memcpy(s->prob_ctx[2].coef, vp9_default_coef_probs,
 
864
               sizeof(vp9_default_coef_probs));
 
865
        memcpy(s->prob_ctx[3].coef, vp9_default_coef_probs,
 
866
               sizeof(vp9_default_coef_probs));
 
867
    }
 
868
 
 
869
    // next 16 bits is size of the rest of the header (arith-coded)
 
870
    size2 = get_bits(&s->gb, 16);
 
871
    data2 = align_get_bits(&s->gb);
 
872
    if (size2 > size - (data2 - data)) {
 
873
        av_log(ctx, AV_LOG_ERROR, "Invalid compressed header size\n");
 
874
        return AVERROR_INVALIDDATA;
 
875
    }
 
876
    ff_vp56_init_range_decoder(&s->c, data2, size2);
 
877
    if (vp56_rac_get_prob_branchy(&s->c, 128)) { // marker bit
 
878
        av_log(ctx, AV_LOG_ERROR, "Marker bit was set\n");
 
879
        return AVERROR_INVALIDDATA;
 
880
    }
 
881
 
 
882
    if (s->keyframe || s->intraonly) {
 
883
        memset(s->counts.coef, 0, sizeof(s->counts.coef));
 
884
        memset(s->counts.eob,  0, sizeof(s->counts.eob));
 
885
    } else {
 
886
        memset(&s->counts, 0, sizeof(s->counts));
 
887
    }
 
888
    // FIXME is it faster to not copy here, but do it down in the fw updates
 
889
    // as explicit copies if the fw update is missing (and skip the copy upon
 
890
    // fw update)?
 
891
    s->prob.p = s->prob_ctx[c].p;
 
892
 
 
893
    // txfm updates
 
894
    if (s->lossless) {
 
895
        s->txfmmode = TX_4X4;
 
896
    } else {
 
897
        s->txfmmode = vp8_rac_get_uint(&s->c, 2);
 
898
        if (s->txfmmode == 3)
 
899
            s->txfmmode += vp8_rac_get(&s->c);
 
900
 
 
901
        if (s->txfmmode == TX_SWITCHABLE) {
 
902
            for (i = 0; i < 2; i++)
 
903
                if (vp56_rac_get_prob_branchy(&s->c, 252))
 
904
                    s->prob.p.tx8p[i] = update_prob(&s->c, s->prob.p.tx8p[i]);
 
905
            for (i = 0; i < 2; i++)
 
906
                for (j = 0; j < 2; j++)
 
907
                    if (vp56_rac_get_prob_branchy(&s->c, 252))
 
908
                        s->prob.p.tx16p[i][j] =
 
909
                            update_prob(&s->c, s->prob.p.tx16p[i][j]);
 
910
            for (i = 0; i < 2; i++)
 
911
                for (j = 0; j < 3; j++)
 
912
                    if (vp56_rac_get_prob_branchy(&s->c, 252))
 
913
                        s->prob.p.tx32p[i][j] =
 
914
                            update_prob(&s->c, s->prob.p.tx32p[i][j]);
 
915
        }
 
916
    }
 
917
 
 
918
    // coef updates
 
919
    for (i = 0; i < 4; i++) {
 
920
        uint8_t (*ref)[2][6][6][3] = s->prob_ctx[c].coef[i];
 
921
        if (vp8_rac_get(&s->c)) {
 
922
            for (j = 0; j < 2; j++)
 
923
                for (k = 0; k < 2; k++)
 
924
                    for (l = 0; l < 6; l++)
 
925
                        for (m = 0; m < 6; m++) {
 
926
                            uint8_t *p = s->prob.coef[i][j][k][l][m];
 
927
                            uint8_t *r = ref[j][k][l][m];
 
928
                            if (m >= 3 && l == 0) // dc only has 3 pt
 
929
                                break;
 
930
                            for (n = 0; n < 3; n++) {
 
931
                                if (vp56_rac_get_prob_branchy(&s->c, 252)) {
 
932
                                    p[n] = update_prob(&s->c, r[n]);
 
933
                                } else {
 
934
                                    p[n] = r[n];
 
935
                                }
 
936
                            }
 
937
                            p[3] = 0;
 
938
                        }
 
939
        } else {
 
940
            for (j = 0; j < 2; j++)
 
941
                for (k = 0; k < 2; k++)
 
942
                    for (l = 0; l < 6; l++)
 
943
                        for (m = 0; m < 6; m++) {
 
944
                            uint8_t *p = s->prob.coef[i][j][k][l][m];
 
945
                            uint8_t *r = ref[j][k][l][m];
 
946
                            if (m > 3 && l == 0) // dc only has 3 pt
 
947
                                break;
 
948
                            memcpy(p, r, 3);
 
949
                            p[3] = 0;
 
950
                        }
 
951
        }
 
952
        if (s->txfmmode == i)
 
953
            break;
 
954
    }
 
955
 
 
956
    // mode updates
 
957
    for (i = 0; i < 3; i++)
 
958
        if (vp56_rac_get_prob_branchy(&s->c, 252))
 
959
            s->prob.p.skip[i] = update_prob(&s->c, s->prob.p.skip[i]);
 
960
    if (!s->keyframe && !s->intraonly) {
 
961
        for (i = 0; i < 7; i++)
 
962
            for (j = 0; j < 3; j++)
 
963
                if (vp56_rac_get_prob_branchy(&s->c, 252))
 
964
                    s->prob.p.mv_mode[i][j] =
 
965
                        update_prob(&s->c, s->prob.p.mv_mode[i][j]);
 
966
 
 
967
        if (s->filtermode == FILTER_SWITCHABLE)
 
968
            for (i = 0; i < 4; i++)
 
969
                for (j = 0; j < 2; j++)
 
970
                    if (vp56_rac_get_prob_branchy(&s->c, 252))
 
971
                        s->prob.p.filter[i][j] =
 
972
                            update_prob(&s->c, s->prob.p.filter[i][j]);
 
973
 
 
974
        for (i = 0; i < 4; i++)
 
975
            if (vp56_rac_get_prob_branchy(&s->c, 252))
 
976
                s->prob.p.intra[i] = update_prob(&s->c, s->prob.p.intra[i]);
 
977
 
 
978
        if (s->allowcompinter) {
 
979
            s->comppredmode = vp8_rac_get(&s->c);
 
980
            if (s->comppredmode)
 
981
                s->comppredmode += vp8_rac_get(&s->c);
 
982
            if (s->comppredmode == PRED_SWITCHABLE)
 
983
                for (i = 0; i < 5; i++)
 
984
                    if (vp56_rac_get_prob_branchy(&s->c, 252))
 
985
                        s->prob.p.comp[i] =
 
986
                            update_prob(&s->c, s->prob.p.comp[i]);
 
987
        } else {
 
988
            s->comppredmode = PRED_SINGLEREF;
 
989
        }
 
990
 
 
991
        if (s->comppredmode != PRED_COMPREF) {
 
992
            for (i = 0; i < 5; i++) {
 
993
                if (vp56_rac_get_prob_branchy(&s->c, 252))
 
994
                    s->prob.p.single_ref[i][0] =
 
995
                        update_prob(&s->c, s->prob.p.single_ref[i][0]);
 
996
                if (vp56_rac_get_prob_branchy(&s->c, 252))
 
997
                    s->prob.p.single_ref[i][1] =
 
998
                        update_prob(&s->c, s->prob.p.single_ref[i][1]);
 
999
            }
 
1000
        }
 
1001
 
 
1002
        if (s->comppredmode != PRED_SINGLEREF) {
 
1003
            for (i = 0; i < 5; i++)
 
1004
                if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1005
                    s->prob.p.comp_ref[i] =
 
1006
                        update_prob(&s->c, s->prob.p.comp_ref[i]);
 
1007
        }
 
1008
 
 
1009
        for (i = 0; i < 4; i++)
 
1010
            for (j = 0; j < 9; j++)
 
1011
                if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1012
                    s->prob.p.y_mode[i][j] =
 
1013
                        update_prob(&s->c, s->prob.p.y_mode[i][j]);
 
1014
 
 
1015
        for (i = 0; i < 4; i++)
 
1016
            for (j = 0; j < 4; j++)
 
1017
                for (k = 0; k < 3; k++)
 
1018
                    if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1019
                        s->prob.p.partition[3 - i][j][k] =
 
1020
                            update_prob(&s->c, s->prob.p.partition[3 - i][j][k]);
 
1021
 
 
1022
        // mv fields don't use the update_prob subexp model for some reason
 
1023
        for (i = 0; i < 3; i++)
 
1024
            if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1025
                s->prob.p.mv_joint[i] = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
1026
 
 
1027
        for (i = 0; i < 2; i++) {
 
1028
            if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1029
                s->prob.p.mv_comp[i].sign = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
1030
 
 
1031
            for (j = 0; j < 10; j++)
 
1032
                if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1033
                    s->prob.p.mv_comp[i].classes[j] =
 
1034
                        (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
1035
 
 
1036
            if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1037
                s->prob.p.mv_comp[i].class0 = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
1038
 
 
1039
            for (j = 0; j < 10; j++)
 
1040
                if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1041
                    s->prob.p.mv_comp[i].bits[j] =
 
1042
                        (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
1043
        }
 
1044
 
 
1045
        for (i = 0; i < 2; i++) {
 
1046
            for (j = 0; j < 2; j++)
 
1047
                for (k = 0; k < 3; k++)
 
1048
                    if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1049
                        s->prob.p.mv_comp[i].class0_fp[j][k] =
 
1050
                            (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
1051
 
 
1052
            for (j = 0; j < 3; j++)
 
1053
                if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1054
                    s->prob.p.mv_comp[i].fp[j] =
 
1055
                        (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
1056
        }
 
1057
 
 
1058
        if (s->highprecisionmvs) {
 
1059
            for (i = 0; i < 2; i++) {
 
1060
                if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1061
                    s->prob.p.mv_comp[i].class0_hp =
 
1062
                        (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
1063
 
 
1064
                if (vp56_rac_get_prob_branchy(&s->c, 252))
 
1065
                    s->prob.p.mv_comp[i].hp =
 
1066
                        (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
1067
            }
 
1068
        }
 
1069
    }
 
1070
 
 
1071
    return (data2 - data) + size2;
 
1072
}
 
1073
 
 
1074
static av_always_inline void clamp_mv(VP56mv *dst, const VP56mv *src,
 
1075
                                      VP9Context *s)
 
1076
{
 
1077
    dst->x = av_clip(src->x, s->min_mv.x, s->max_mv.x);
 
1078
    dst->y = av_clip(src->y, s->min_mv.y, s->max_mv.y);
 
1079
}
 
1080
 
 
1081
static void find_ref_mvs(VP9Context *s,
 
1082
                         VP56mv *pmv, int ref, int z, int idx, int sb)
 
1083
{
 
1084
    static const int8_t mv_ref_blk_off[N_BS_SIZES][8][2] = {
 
1085
        [BS_64x64] = {{  3, -1 }, { -1,  3 }, {  4, -1 }, { -1,  4 },
 
1086
                      { -1, -1 }, {  0, -1 }, { -1,  0 }, {  6, -1 }},
 
1087
        [BS_64x32] = {{  0, -1 }, { -1,  0 }, {  4, -1 }, { -1,  2 },
 
1088
                      { -1, -1 }, {  0, -3 }, { -3,  0 }, {  2, -1 }},
 
1089
        [BS_32x64] = {{ -1,  0 }, {  0, -1 }, { -1,  4 }, {  2, -1 },
 
1090
                      { -1, -1 }, { -3,  0 }, {  0, -3 }, { -1,  2 }},
 
1091
        [BS_32x32] = {{  1, -1 }, { -1,  1 }, {  2, -1 }, { -1,  2 },
 
1092
                      { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 }},
 
1093
        [BS_32x16] = {{  0, -1 }, { -1,  0 }, {  2, -1 }, { -1, -1 },
 
1094
                      { -1,  1 }, {  0, -3 }, { -3,  0 }, { -3, -3 }},
 
1095
        [BS_16x32] = {{ -1,  0 }, {  0, -1 }, { -1,  2 }, { -1, -1 },
 
1096
                      {  1, -1 }, { -3,  0 }, {  0, -3 }, { -3, -3 }},
 
1097
        [BS_16x16] = {{  0, -1 }, { -1,  0 }, {  1, -1 }, { -1,  1 },
 
1098
                      { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 }},
 
1099
        [BS_16x8]  = {{  0, -1 }, { -1,  0 }, {  1, -1 }, { -1, -1 },
 
1100
                      {  0, -2 }, { -2,  0 }, { -2, -1 }, { -1, -2 }},
 
1101
        [BS_8x16]  = {{ -1,  0 }, {  0, -1 }, { -1,  1 }, { -1, -1 },
 
1102
                      { -2,  0 }, {  0, -2 }, { -1, -2 }, { -2, -1 }},
 
1103
        [BS_8x8]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
 
1104
                      { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
 
1105
        [BS_8x4]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
 
1106
                      { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
 
1107
        [BS_4x8]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
 
1108
                      { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
 
1109
        [BS_4x4]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
 
1110
                      { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
 
1111
    };
 
1112
    VP9Block *b = s->b;
 
1113
    int row = s->row, col = s->col, row7 = s->row7;
 
1114
    const int8_t (*p)[2] = mv_ref_blk_off[b->bs];
 
1115
#define INVALID_MV 0x80008000U
 
1116
    uint32_t mem = INVALID_MV, mem_sub8x8 = INVALID_MV;
 
1117
    int i;
 
1118
 
 
1119
#define RETURN_DIRECT_MV(mv) \
 
1120
    do { \
 
1121
        uint32_t m = AV_RN32A(&mv); \
 
1122
        if (!idx) { \
 
1123
            AV_WN32A(pmv, m); \
 
1124
            return; \
 
1125
        } else if (mem == INVALID_MV) { \
 
1126
            mem = m; \
 
1127
        } else if (m != mem) { \
 
1128
            AV_WN32A(pmv, m); \
 
1129
            return; \
 
1130
        } \
 
1131
    } while (0)
 
1132
 
 
1133
    if (sb >= 0) {
 
1134
        if (sb == 2 || sb == 1) {
 
1135
            RETURN_DIRECT_MV(b->mv[0][z]);
 
1136
        } else if (sb == 3) {
 
1137
            RETURN_DIRECT_MV(b->mv[2][z]);
 
1138
            RETURN_DIRECT_MV(b->mv[1][z]);
 
1139
            RETURN_DIRECT_MV(b->mv[0][z]);
 
1140
        }
 
1141
 
 
1142
#define RETURN_MV(mv) \
 
1143
    do { \
 
1144
        if (sb > 0) { \
 
1145
            VP56mv tmp; \
 
1146
            uint32_t m; \
 
1147
            av_assert2(idx == 1); \
 
1148
            av_assert2(mem != INVALID_MV); \
 
1149
            if (mem_sub8x8 == INVALID_MV) { \
 
1150
                clamp_mv(&tmp, &mv, s); \
 
1151
                m = AV_RN32A(&tmp); \
 
1152
                if (m != mem) { \
 
1153
                    AV_WN32A(pmv, m); \
 
1154
                    return; \
 
1155
                } \
 
1156
                mem_sub8x8 = AV_RN32A(&mv); \
 
1157
            } else if (mem_sub8x8 != AV_RN32A(&mv)) { \
 
1158
                clamp_mv(&tmp, &mv, s); \
 
1159
                m = AV_RN32A(&tmp); \
 
1160
                if (m != mem) { \
 
1161
                    AV_WN32A(pmv, m); \
 
1162
                } else { \
 
1163
                    /* BUG I'm pretty sure this isn't the intention */ \
 
1164
                    AV_WN32A(pmv, 0); \
 
1165
                } \
 
1166
                return; \
 
1167
            } \
 
1168
        } else { \
 
1169
            uint32_t m = AV_RN32A(&mv); \
 
1170
            if (!idx) { \
 
1171
                clamp_mv(pmv, &mv, s); \
 
1172
                return; \
 
1173
            } else if (mem == INVALID_MV) { \
 
1174
                mem = m; \
 
1175
            } else if (m != mem) { \
 
1176
                clamp_mv(pmv, &mv, s); \
 
1177
                return; \
 
1178
            } \
 
1179
        } \
 
1180
    } while (0)
 
1181
 
 
1182
        if (row > 0) {
 
1183
            struct VP9mvrefPair *mv = &s->frames[CUR_FRAME].mv[(row - 1) * s->sb_cols * 8 + col];
 
1184
            if (mv->ref[0] == ref) {
 
1185
                RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][0]);
 
1186
            } else if (mv->ref[1] == ref) {
 
1187
                RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][1]);
 
1188
            }
 
1189
        }
 
1190
        if (col > s->tiling.tile_col_start) {
 
1191
            struct VP9mvrefPair *mv = &s->frames[CUR_FRAME].mv[row * s->sb_cols * 8 + col - 1];
 
1192
            if (mv->ref[0] == ref) {
 
1193
                RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][0]);
 
1194
            } else if (mv->ref[1] == ref) {
 
1195
                RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][1]);
 
1196
            }
 
1197
        }
 
1198
        i = 2;
 
1199
    } else {
 
1200
        i = 0;
 
1201
    }
 
1202
 
 
1203
    // previously coded MVs in this neighbourhood, using same reference frame
 
1204
    for (; i < 8; i++) {
 
1205
        int c = p[i][0] + col, r = p[i][1] + row;
 
1206
 
 
1207
        if (c >= s->tiling.tile_col_start && c < s->cols && r >= 0 && r < s->rows) {
 
1208
            struct VP9mvrefPair *mv = &s->frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
 
1209
 
 
1210
            if (mv->ref[0] == ref) {
 
1211
                RETURN_MV(mv->mv[0]);
 
1212
            } else if (mv->ref[1] == ref) {
 
1213
                RETURN_MV(mv->mv[1]);
 
1214
            }
 
1215
        }
 
1216
    }
 
1217
 
 
1218
    // MV at this position in previous frame, using same reference frame
 
1219
    if (s->use_last_frame_mvs) {
 
1220
        struct VP9mvrefPair *mv = &s->frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
 
1221
 
 
1222
        if (!s->frames[REF_FRAME_MVPAIR].uses_2pass)
 
1223
            ff_thread_await_progress(&s->frames[REF_FRAME_MVPAIR].tf, row >> 3, 0);
 
1224
        if (mv->ref[0] == ref) {
 
1225
            RETURN_MV(mv->mv[0]);
 
1226
        } else if (mv->ref[1] == ref) {
 
1227
            RETURN_MV(mv->mv[1]);
 
1228
        }
 
1229
    }
 
1230
 
 
1231
#define RETURN_SCALE_MV(mv, scale) \
 
1232
    do { \
 
1233
        if (scale) { \
 
1234
            VP56mv mv_temp = { -mv.x, -mv.y }; \
 
1235
            RETURN_MV(mv_temp); \
 
1236
        } else { \
 
1237
            RETURN_MV(mv); \
 
1238
        } \
 
1239
    } while (0)
 
1240
 
 
1241
    // previously coded MVs in this neighbourhood, using different reference frame
 
1242
    for (i = 0; i < 8; i++) {
 
1243
        int c = p[i][0] + col, r = p[i][1] + row;
 
1244
 
 
1245
        if (c >= s->tiling.tile_col_start && c < s->cols && r >= 0 && r < s->rows) {
 
1246
            struct VP9mvrefPair *mv = &s->frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
 
1247
 
 
1248
            if (mv->ref[0] != ref && mv->ref[0] >= 0) {
 
1249
                RETURN_SCALE_MV(mv->mv[0], s->signbias[mv->ref[0]] != s->signbias[ref]);
 
1250
            }
 
1251
            if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
 
1252
                // BUG - libvpx has this condition regardless of whether
 
1253
                // we used the first ref MV and pre-scaling
 
1254
                AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
 
1255
                RETURN_SCALE_MV(mv->mv[1], s->signbias[mv->ref[1]] != s->signbias[ref]);
 
1256
            }
 
1257
        }
 
1258
    }
 
1259
 
 
1260
    // MV at this position in previous frame, using different reference frame
 
1261
    if (s->use_last_frame_mvs) {
 
1262
        struct VP9mvrefPair *mv = &s->frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
 
1263
 
 
1264
        // no need to await_progress, because we already did that above
 
1265
        if (mv->ref[0] != ref && mv->ref[0] >= 0) {
 
1266
            RETURN_SCALE_MV(mv->mv[0], s->signbias[mv->ref[0]] != s->signbias[ref]);
 
1267
        }
 
1268
        if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
 
1269
            // BUG - libvpx has this condition regardless of whether
 
1270
            // we used the first ref MV and pre-scaling
 
1271
            AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
 
1272
            RETURN_SCALE_MV(mv->mv[1], s->signbias[mv->ref[1]] != s->signbias[ref]);
 
1273
        }
 
1274
    }
 
1275
 
 
1276
    AV_ZERO32(pmv);
 
1277
    clamp_mv(pmv, pmv, s);
 
1278
#undef INVALID_MV
 
1279
#undef RETURN_MV
 
1280
#undef RETURN_SCALE_MV
 
1281
}
 
1282
 
 
1283
static av_always_inline int read_mv_component(VP9Context *s, int idx, int hp)
 
1284
{
 
1285
    int bit, sign = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].sign);
 
1286
    int n, c = vp8_rac_get_tree(&s->c, vp9_mv_class_tree,
 
1287
                                s->prob.p.mv_comp[idx].classes);
 
1288
 
 
1289
    s->counts.mv_comp[idx].sign[sign]++;
 
1290
    s->counts.mv_comp[idx].classes[c]++;
 
1291
    if (c) {
 
1292
        int m;
 
1293
 
 
1294
        for (n = 0, m = 0; m < c; m++) {
 
1295
            bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].bits[m]);
 
1296
            n |= bit << m;
 
1297
            s->counts.mv_comp[idx].bits[m][bit]++;
 
1298
        }
 
1299
        n <<= 3;
 
1300
        bit = vp8_rac_get_tree(&s->c, vp9_mv_fp_tree, s->prob.p.mv_comp[idx].fp);
 
1301
        n |= bit << 1;
 
1302
        s->counts.mv_comp[idx].fp[bit]++;
 
1303
        if (hp) {
 
1304
            bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].hp);
 
1305
            s->counts.mv_comp[idx].hp[bit]++;
 
1306
            n |= bit;
 
1307
        } else {
 
1308
            n |= 1;
 
1309
            // bug in libvpx - we count for bw entropy purposes even if the
 
1310
            // bit wasn't coded
 
1311
            s->counts.mv_comp[idx].hp[1]++;
 
1312
        }
 
1313
        n += 8 << c;
 
1314
    } else {
 
1315
        n = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0);
 
1316
        s->counts.mv_comp[idx].class0[n]++;
 
1317
        bit = vp8_rac_get_tree(&s->c, vp9_mv_fp_tree,
 
1318
                               s->prob.p.mv_comp[idx].class0_fp[n]);
 
1319
        s->counts.mv_comp[idx].class0_fp[n][bit]++;
 
1320
        n = (n << 3) | (bit << 1);
 
1321
        if (hp) {
 
1322
            bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0_hp);
 
1323
            s->counts.mv_comp[idx].class0_hp[bit]++;
 
1324
            n |= bit;
 
1325
        } else {
 
1326
            n |= 1;
 
1327
            // bug in libvpx - we count for bw entropy purposes even if the
 
1328
            // bit wasn't coded
 
1329
            s->counts.mv_comp[idx].class0_hp[1]++;
 
1330
        }
 
1331
    }
 
1332
 
 
1333
    return sign ? -(n + 1) : (n + 1);
 
1334
}
 
1335
 
 
1336
static void fill_mv(VP9Context *s,
 
1337
                    VP56mv *mv, int mode, int sb)
 
1338
{
 
1339
    VP9Block *b = s->b;
 
1340
 
 
1341
    if (mode == ZEROMV) {
 
1342
        AV_ZERO64(mv);
 
1343
    } else {
 
1344
        int hp;
 
1345
 
 
1346
        // FIXME cache this value and reuse for other subblocks
 
1347
        find_ref_mvs(s, &mv[0], b->ref[0], 0, mode == NEARMV,
 
1348
                     mode == NEWMV ? -1 : sb);
 
1349
        // FIXME maybe move this code into find_ref_mvs()
 
1350
        if ((mode == NEWMV || sb == -1) &&
 
1351
            !(hp = s->highprecisionmvs && abs(mv[0].x) < 64 && abs(mv[0].y) < 64)) {
 
1352
            if (mv[0].y & 1) {
 
1353
                if (mv[0].y < 0)
 
1354
                    mv[0].y++;
 
1355
                else
 
1356
                    mv[0].y--;
 
1357
            }
 
1358
            if (mv[0].x & 1) {
 
1359
                if (mv[0].x < 0)
 
1360
                    mv[0].x++;
 
1361
                else
 
1362
                    mv[0].x--;
 
1363
            }
 
1364
        }
 
1365
        if (mode == NEWMV) {
 
1366
            enum MVJoint j = vp8_rac_get_tree(&s->c, vp9_mv_joint_tree,
 
1367
                                              s->prob.p.mv_joint);
 
1368
 
 
1369
            s->counts.mv_joint[j]++;
 
1370
            if (j >= MV_JOINT_V)
 
1371
                mv[0].y += read_mv_component(s, 0, hp);
 
1372
            if (j & 1)
 
1373
                mv[0].x += read_mv_component(s, 1, hp);
 
1374
        }
 
1375
 
 
1376
        if (b->comp) {
 
1377
            // FIXME cache this value and reuse for other subblocks
 
1378
            find_ref_mvs(s, &mv[1], b->ref[1], 1, mode == NEARMV,
 
1379
                         mode == NEWMV ? -1 : sb);
 
1380
            if ((mode == NEWMV || sb == -1) &&
 
1381
                !(hp = s->highprecisionmvs && abs(mv[1].x) < 64 && abs(mv[1].y) < 64)) {
 
1382
                if (mv[1].y & 1) {
 
1383
                    if (mv[1].y < 0)
 
1384
                        mv[1].y++;
 
1385
                    else
 
1386
                        mv[1].y--;
 
1387
                }
 
1388
                if (mv[1].x & 1) {
 
1389
                    if (mv[1].x < 0)
 
1390
                        mv[1].x++;
 
1391
                    else
 
1392
                        mv[1].x--;
 
1393
                }
 
1394
            }
 
1395
            if (mode == NEWMV) {
 
1396
                enum MVJoint j = vp8_rac_get_tree(&s->c, vp9_mv_joint_tree,
 
1397
                                                  s->prob.p.mv_joint);
 
1398
 
 
1399
                s->counts.mv_joint[j]++;
 
1400
                if (j >= MV_JOINT_V)
 
1401
                    mv[1].y += read_mv_component(s, 0, hp);
 
1402
                if (j & 1)
 
1403
                    mv[1].x += read_mv_component(s, 1, hp);
 
1404
            }
 
1405
        }
 
1406
    }
 
1407
}
 
1408
 
 
1409
static av_always_inline void setctx_2d(uint8_t *ptr, int w, int h,
 
1410
                                       ptrdiff_t stride, int v)
 
1411
{
 
1412
    switch (w) {
 
1413
    case 1:
 
1414
        do {
 
1415
            *ptr = v;
 
1416
            ptr += stride;
 
1417
        } while (--h);
 
1418
        break;
 
1419
    case 2: {
 
1420
        int v16 = v * 0x0101;
 
1421
        do {
 
1422
            AV_WN16A(ptr, v16);
 
1423
            ptr += stride;
 
1424
        } while (--h);
 
1425
        break;
 
1426
    }
 
1427
    case 4: {
 
1428
        uint32_t v32 = v * 0x01010101;
 
1429
        do {
 
1430
            AV_WN32A(ptr, v32);
 
1431
            ptr += stride;
 
1432
        } while (--h);
 
1433
        break;
 
1434
    }
 
1435
    case 8: {
 
1436
#if HAVE_FAST_64BIT
 
1437
        uint64_t v64 = v * 0x0101010101010101ULL;
 
1438
        do {
 
1439
            AV_WN64A(ptr, v64);
 
1440
            ptr += stride;
 
1441
        } while (--h);
 
1442
#else
 
1443
        uint32_t v32 = v * 0x01010101;
 
1444
        do {
 
1445
            AV_WN32A(ptr,     v32);
 
1446
            AV_WN32A(ptr + 4, v32);
 
1447
            ptr += stride;
 
1448
        } while (--h);
 
1449
#endif
 
1450
        break;
 
1451
    }
 
1452
    }
 
1453
}
 
1454
 
 
1455
static void decode_mode(AVCodecContext *ctx)
 
1456
{
 
1457
    static const uint8_t left_ctx[N_BS_SIZES] = {
 
1458
        0x0, 0x8, 0x0, 0x8, 0xc, 0x8, 0xc, 0xe, 0xc, 0xe, 0xf, 0xe, 0xf
 
1459
    };
 
1460
    static const uint8_t above_ctx[N_BS_SIZES] = {
 
1461
        0x0, 0x0, 0x8, 0x8, 0x8, 0xc, 0xc, 0xc, 0xe, 0xe, 0xe, 0xf, 0xf
 
1462
    };
 
1463
    static const uint8_t max_tx_for_bl_bp[N_BS_SIZES] = {
 
1464
        TX_32X32, TX_32X32, TX_32X32, TX_32X32, TX_16X16, TX_16X16,
 
1465
        TX_16X16, TX_8X8, TX_8X8, TX_8X8, TX_4X4, TX_4X4, TX_4X4
 
1466
    };
 
1467
    VP9Context *s = ctx->priv_data;
 
1468
    VP9Block *b = s->b;
 
1469
    int row = s->row, col = s->col, row7 = s->row7;
 
1470
    enum TxfmMode max_tx = max_tx_for_bl_bp[b->bs];
 
1471
    int bw4 = bwh_tab[1][b->bs][0], w4 = FFMIN(s->cols - col, bw4);
 
1472
    int bh4 = bwh_tab[1][b->bs][1], h4 = FFMIN(s->rows - row, bh4), y;
 
1473
    int have_a = row > 0, have_l = col > s->tiling.tile_col_start;
 
1474
    int vref, filter_id;
 
1475
 
 
1476
    if (!s->segmentation.enabled) {
 
1477
        b->seg_id = 0;
 
1478
    } else if (s->keyframe || s->intraonly) {
 
1479
        b->seg_id = vp8_rac_get_tree(&s->c, vp9_segmentation_tree, s->prob.seg);
 
1480
    } else if (!s->segmentation.update_map ||
 
1481
               (s->segmentation.temporal &&
 
1482
                vp56_rac_get_prob_branchy(&s->c,
 
1483
                    s->prob.segpred[s->above_segpred_ctx[col] +
 
1484
                                    s->left_segpred_ctx[row7]]))) {
 
1485
        if (!s->errorres && !s->segmentation.ignore_refmap) {
 
1486
            int pred = 8, x;
 
1487
            uint8_t *refsegmap = s->frames[REF_FRAME_SEGMAP].segmentation_map;
 
1488
 
 
1489
            if (!s->frames[REF_FRAME_SEGMAP].uses_2pass)
 
1490
                ff_thread_await_progress(&s->frames[REF_FRAME_SEGMAP].tf, row >> 3, 0);
 
1491
            for (y = 0; y < h4; y++) {
 
1492
                int idx_base = (y + row) * 8 * s->sb_cols + col;
 
1493
                for (x = 0; x < w4; x++)
 
1494
                    pred = FFMIN(pred, refsegmap[idx_base + x]);
 
1495
            }
 
1496
            av_assert1(pred < 8);
 
1497
            b->seg_id = pred;
 
1498
        } else {
 
1499
            b->seg_id = 0;
 
1500
        }
 
1501
 
 
1502
        memset(&s->above_segpred_ctx[col], 1, w4);
 
1503
        memset(&s->left_segpred_ctx[row7], 1, h4);
 
1504
    } else {
 
1505
        b->seg_id = vp8_rac_get_tree(&s->c, vp9_segmentation_tree,
 
1506
                                     s->prob.seg);
 
1507
 
 
1508
        memset(&s->above_segpred_ctx[col], 0, w4);
 
1509
        memset(&s->left_segpred_ctx[row7], 0, h4);
 
1510
    }
 
1511
    if (s->segmentation.enabled &&
 
1512
        (s->segmentation.update_map || s->keyframe || s->intraonly)) {
 
1513
        setctx_2d(&s->frames[CUR_FRAME].segmentation_map[row * 8 * s->sb_cols + col],
 
1514
                  bw4, bh4, 8 * s->sb_cols, b->seg_id);
 
1515
    }
 
1516
 
 
1517
    b->skip = s->segmentation.enabled &&
 
1518
        s->segmentation.feat[b->seg_id].skip_enabled;
 
1519
    if (!b->skip) {
 
1520
        int c = s->left_skip_ctx[row7] + s->above_skip_ctx[col];
 
1521
        b->skip = vp56_rac_get_prob(&s->c, s->prob.p.skip[c]);
 
1522
        s->counts.skip[c][b->skip]++;
 
1523
    }
 
1524
 
 
1525
    if (s->keyframe || s->intraonly) {
 
1526
        b->intra = 1;
 
1527
    } else if (s->segmentation.feat[b->seg_id].ref_enabled) {
 
1528
        b->intra = !s->segmentation.feat[b->seg_id].ref_val;
 
1529
    } else {
 
1530
        int c, bit;
 
1531
 
 
1532
        if (have_a && have_l) {
 
1533
            c = s->above_intra_ctx[col] + s->left_intra_ctx[row7];
 
1534
            c += (c == 2);
 
1535
        } else {
 
1536
            c = have_a ? 2 * s->above_intra_ctx[col] :
 
1537
                have_l ? 2 * s->left_intra_ctx[row7] : 0;
 
1538
        }
 
1539
        bit = vp56_rac_get_prob(&s->c, s->prob.p.intra[c]);
 
1540
        s->counts.intra[c][bit]++;
 
1541
        b->intra = !bit;
 
1542
    }
 
1543
 
 
1544
    if ((b->intra || !b->skip) && s->txfmmode == TX_SWITCHABLE) {
 
1545
        int c;
 
1546
        if (have_a) {
 
1547
            if (have_l) {
 
1548
                c = (s->above_skip_ctx[col] ? max_tx :
 
1549
                     s->above_txfm_ctx[col]) +
 
1550
                    (s->left_skip_ctx[row7] ? max_tx :
 
1551
                     s->left_txfm_ctx[row7]) > max_tx;
 
1552
            } else {
 
1553
                c = s->above_skip_ctx[col] ? 1 :
 
1554
                    (s->above_txfm_ctx[col] * 2 > max_tx);
 
1555
            }
 
1556
        } else if (have_l) {
 
1557
            c = s->left_skip_ctx[row7] ? 1 :
 
1558
                (s->left_txfm_ctx[row7] * 2 > max_tx);
 
1559
        } else {
 
1560
            c = 1;
 
1561
        }
 
1562
        switch (max_tx) {
 
1563
        case TX_32X32:
 
1564
            b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][0]);
 
1565
            if (b->tx) {
 
1566
                b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][1]);
 
1567
                if (b->tx == 2)
 
1568
                    b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][2]);
 
1569
            }
 
1570
            s->counts.tx32p[c][b->tx]++;
 
1571
            break;
 
1572
        case TX_16X16:
 
1573
            b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx16p[c][0]);
 
1574
            if (b->tx)
 
1575
                b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx16p[c][1]);
 
1576
            s->counts.tx16p[c][b->tx]++;
 
1577
            break;
 
1578
        case TX_8X8:
 
1579
            b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx8p[c]);
 
1580
            s->counts.tx8p[c][b->tx]++;
 
1581
            break;
 
1582
        case TX_4X4:
 
1583
            b->tx = TX_4X4;
 
1584
            break;
 
1585
        }
 
1586
    } else {
 
1587
        b->tx = FFMIN(max_tx, s->txfmmode);
 
1588
    }
 
1589
 
 
1590
    if (s->keyframe || s->intraonly) {
 
1591
        uint8_t *a = &s->above_mode_ctx[col * 2];
 
1592
        uint8_t *l = &s->left_mode_ctx[(row7) << 1];
 
1593
 
 
1594
        b->comp = 0;
 
1595
        if (b->bs > BS_8x8) {
 
1596
            // FIXME the memory storage intermediates here aren't really
 
1597
            // necessary, they're just there to make the code slightly
 
1598
            // simpler for now
 
1599
            b->mode[0] = a[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1600
                                    vp9_default_kf_ymode_probs[a[0]][l[0]]);
 
1601
            if (b->bs != BS_8x4) {
 
1602
                b->mode[1] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1603
                                 vp9_default_kf_ymode_probs[a[1]][b->mode[0]]);
 
1604
                l[0] = a[1] = b->mode[1];
 
1605
            } else {
 
1606
                l[0] = a[1] = b->mode[1] = b->mode[0];
 
1607
            }
 
1608
            if (b->bs != BS_4x8) {
 
1609
                b->mode[2] = a[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1610
                                        vp9_default_kf_ymode_probs[a[0]][l[1]]);
 
1611
                if (b->bs != BS_8x4) {
 
1612
                    b->mode[3] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1613
                                  vp9_default_kf_ymode_probs[a[1]][b->mode[2]]);
 
1614
                    l[1] = a[1] = b->mode[3];
 
1615
                } else {
 
1616
                    l[1] = a[1] = b->mode[3] = b->mode[2];
 
1617
                }
 
1618
            } else {
 
1619
                b->mode[2] = b->mode[0];
 
1620
                l[1] = a[1] = b->mode[3] = b->mode[1];
 
1621
            }
 
1622
        } else {
 
1623
            b->mode[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1624
                                          vp9_default_kf_ymode_probs[*a][*l]);
 
1625
            b->mode[3] = b->mode[2] = b->mode[1] = b->mode[0];
 
1626
            // FIXME this can probably be optimized
 
1627
            memset(a, b->mode[0], bwh_tab[0][b->bs][0]);
 
1628
            memset(l, b->mode[0], bwh_tab[0][b->bs][1]);
 
1629
        }
 
1630
        b->uvmode = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1631
                                     vp9_default_kf_uvmode_probs[b->mode[3]]);
 
1632
    } else if (b->intra) {
 
1633
        b->comp = 0;
 
1634
        if (b->bs > BS_8x8) {
 
1635
            b->mode[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1636
                                          s->prob.p.y_mode[0]);
 
1637
            s->counts.y_mode[0][b->mode[0]]++;
 
1638
            if (b->bs != BS_8x4) {
 
1639
                b->mode[1] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1640
                                              s->prob.p.y_mode[0]);
 
1641
                s->counts.y_mode[0][b->mode[1]]++;
 
1642
            } else {
 
1643
                b->mode[1] = b->mode[0];
 
1644
            }
 
1645
            if (b->bs != BS_4x8) {
 
1646
                b->mode[2] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1647
                                              s->prob.p.y_mode[0]);
 
1648
                s->counts.y_mode[0][b->mode[2]]++;
 
1649
                if (b->bs != BS_8x4) {
 
1650
                    b->mode[3] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1651
                                                  s->prob.p.y_mode[0]);
 
1652
                    s->counts.y_mode[0][b->mode[3]]++;
 
1653
                } else {
 
1654
                    b->mode[3] = b->mode[2];
 
1655
                }
 
1656
            } else {
 
1657
                b->mode[2] = b->mode[0];
 
1658
                b->mode[3] = b->mode[1];
 
1659
            }
 
1660
        } else {
 
1661
            static const uint8_t size_group[10] = {
 
1662
                3, 3, 3, 3, 2, 2, 2, 1, 1, 1
 
1663
            };
 
1664
            int sz = size_group[b->bs];
 
1665
 
 
1666
            b->mode[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1667
                                          s->prob.p.y_mode[sz]);
 
1668
            b->mode[1] = b->mode[2] = b->mode[3] = b->mode[0];
 
1669
            s->counts.y_mode[sz][b->mode[3]]++;
 
1670
        }
 
1671
        b->uvmode = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
 
1672
                                     s->prob.p.uv_mode[b->mode[3]]);
 
1673
        s->counts.uv_mode[b->mode[3]][b->uvmode]++;
 
1674
    } else {
 
1675
        static const uint8_t inter_mode_ctx_lut[14][14] = {
 
1676
            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
 
1677
            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
 
1678
            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
 
1679
            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
 
1680
            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
 
1681
            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
 
1682
            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
 
1683
            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
 
1684
            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
 
1685
            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
 
1686
            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 },
 
1687
            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 },
 
1688
            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 0, 3 },
 
1689
            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 3, 3, 4 },
 
1690
        };
 
1691
 
 
1692
        if (s->segmentation.feat[b->seg_id].ref_enabled) {
 
1693
            av_assert2(s->segmentation.feat[b->seg_id].ref_val != 0);
 
1694
            b->comp = 0;
 
1695
            b->ref[0] = s->segmentation.feat[b->seg_id].ref_val - 1;
 
1696
        } else {
 
1697
            // read comp_pred flag
 
1698
            if (s->comppredmode != PRED_SWITCHABLE) {
 
1699
                b->comp = s->comppredmode == PRED_COMPREF;
 
1700
            } else {
 
1701
                int c;
 
1702
 
 
1703
                // FIXME add intra as ref=0xff (or -1) to make these easier?
 
1704
                if (have_a) {
 
1705
                    if (have_l) {
 
1706
                        if (s->above_comp_ctx[col] && s->left_comp_ctx[row7]) {
 
1707
                            c = 4;
 
1708
                        } else if (s->above_comp_ctx[col]) {
 
1709
                            c = 2 + (s->left_intra_ctx[row7] ||
 
1710
                                     s->left_ref_ctx[row7] == s->fixcompref);
 
1711
                        } else if (s->left_comp_ctx[row7]) {
 
1712
                            c = 2 + (s->above_intra_ctx[col] ||
 
1713
                                     s->above_ref_ctx[col] == s->fixcompref);
 
1714
                        } else {
 
1715
                            c = (!s->above_intra_ctx[col] &&
 
1716
                                 s->above_ref_ctx[col] == s->fixcompref) ^
 
1717
                            (!s->left_intra_ctx[row7] &&
 
1718
                             s->left_ref_ctx[row & 7] == s->fixcompref);
 
1719
                        }
 
1720
                    } else {
 
1721
                        c = s->above_comp_ctx[col] ? 3 :
 
1722
                        (!s->above_intra_ctx[col] && s->above_ref_ctx[col] == s->fixcompref);
 
1723
                    }
 
1724
                } else if (have_l) {
 
1725
                    c = s->left_comp_ctx[row7] ? 3 :
 
1726
                    (!s->left_intra_ctx[row7] && s->left_ref_ctx[row7] == s->fixcompref);
 
1727
                } else {
 
1728
                    c = 1;
 
1729
                }
 
1730
                b->comp = vp56_rac_get_prob(&s->c, s->prob.p.comp[c]);
 
1731
                s->counts.comp[c][b->comp]++;
 
1732
            }
 
1733
 
 
1734
            // read actual references
 
1735
            // FIXME probably cache a few variables here to prevent repetitive
 
1736
            // memory accesses below
 
1737
            if (b->comp) /* two references */ {
 
1738
                int fix_idx = s->signbias[s->fixcompref], var_idx = !fix_idx, c, bit;
 
1739
 
 
1740
                b->ref[fix_idx] = s->fixcompref;
 
1741
                // FIXME can this codeblob be replaced by some sort of LUT?
 
1742
                if (have_a) {
 
1743
                    if (have_l) {
 
1744
                        if (s->above_intra_ctx[col]) {
 
1745
                            if (s->left_intra_ctx[row7]) {
 
1746
                                c = 2;
 
1747
                            } else {
 
1748
                                c = 1 + 2 * (s->left_ref_ctx[row7] != s->varcompref[1]);
 
1749
                            }
 
1750
                        } else if (s->left_intra_ctx[row7]) {
 
1751
                            c = 1 + 2 * (s->above_ref_ctx[col] != s->varcompref[1]);
 
1752
                        } else {
 
1753
                            int refl = s->left_ref_ctx[row7], refa = s->above_ref_ctx[col];
 
1754
 
 
1755
                            if (refl == refa && refa == s->varcompref[1]) {
 
1756
                                c = 0;
 
1757
                            } else if (!s->left_comp_ctx[row7] && !s->above_comp_ctx[col]) {
 
1758
                                if ((refa == s->fixcompref && refl == s->varcompref[0]) ||
 
1759
                                    (refl == s->fixcompref && refa == s->varcompref[0])) {
 
1760
                                    c = 4;
 
1761
                                } else {
 
1762
                                    c = (refa == refl) ? 3 : 1;
 
1763
                                }
 
1764
                            } else if (!s->left_comp_ctx[row7]) {
 
1765
                                if (refa == s->varcompref[1] && refl != s->varcompref[1]) {
 
1766
                                    c = 1;
 
1767
                                } else {
 
1768
                                    c = (refl == s->varcompref[1] &&
 
1769
                                         refa != s->varcompref[1]) ? 2 : 4;
 
1770
                                }
 
1771
                            } else if (!s->above_comp_ctx[col]) {
 
1772
                                if (refl == s->varcompref[1] && refa != s->varcompref[1]) {
 
1773
                                    c = 1;
 
1774
                                } else {
 
1775
                                    c = (refa == s->varcompref[1] &&
 
1776
                                         refl != s->varcompref[1]) ? 2 : 4;
 
1777
                                }
 
1778
                            } else {
 
1779
                                c = (refl == refa) ? 4 : 2;
 
1780
                            }
 
1781
                        }
 
1782
                    } else {
 
1783
                        if (s->above_intra_ctx[col]) {
 
1784
                            c = 2;
 
1785
                        } else if (s->above_comp_ctx[col]) {
 
1786
                            c = 4 * (s->above_ref_ctx[col] != s->varcompref[1]);
 
1787
                        } else {
 
1788
                            c = 3 * (s->above_ref_ctx[col] != s->varcompref[1]);
 
1789
                        }
 
1790
                    }
 
1791
                } else if (have_l) {
 
1792
                    if (s->left_intra_ctx[row7]) {
 
1793
                        c = 2;
 
1794
                    } else if (s->left_comp_ctx[row7]) {
 
1795
                        c = 4 * (s->left_ref_ctx[row7] != s->varcompref[1]);
 
1796
                    } else {
 
1797
                        c = 3 * (s->left_ref_ctx[row7] != s->varcompref[1]);
 
1798
                    }
 
1799
                } else {
 
1800
                    c = 2;
 
1801
                }
 
1802
                bit = vp56_rac_get_prob(&s->c, s->prob.p.comp_ref[c]);
 
1803
                b->ref[var_idx] = s->varcompref[bit];
 
1804
                s->counts.comp_ref[c][bit]++;
 
1805
            } else /* single reference */ {
 
1806
                int bit, c;
 
1807
 
 
1808
                if (have_a && !s->above_intra_ctx[col]) {
 
1809
                    if (have_l && !s->left_intra_ctx[row7]) {
 
1810
                        if (s->left_comp_ctx[row7]) {
 
1811
                            if (s->above_comp_ctx[col]) {
 
1812
                                c = 1 + (!s->fixcompref || !s->left_ref_ctx[row7] ||
 
1813
                                         !s->above_ref_ctx[col]);
 
1814
                            } else {
 
1815
                                c = (3 * !s->above_ref_ctx[col]) +
 
1816
                                    (!s->fixcompref || !s->left_ref_ctx[row7]);
 
1817
                            }
 
1818
                        } else if (s->above_comp_ctx[col]) {
 
1819
                            c = (3 * !s->left_ref_ctx[row7]) +
 
1820
                                (!s->fixcompref || !s->above_ref_ctx[col]);
 
1821
                        } else {
 
1822
                            c = 2 * !s->left_ref_ctx[row7] + 2 * !s->above_ref_ctx[col];
 
1823
                        }
 
1824
                    } else if (s->above_intra_ctx[col]) {
 
1825
                        c = 2;
 
1826
                    } else if (s->above_comp_ctx[col]) {
 
1827
                        c = 1 + (!s->fixcompref || !s->above_ref_ctx[col]);
 
1828
                    } else {
 
1829
                        c = 4 * (!s->above_ref_ctx[col]);
 
1830
                    }
 
1831
                } else if (have_l && !s->left_intra_ctx[row7]) {
 
1832
                    if (s->left_intra_ctx[row7]) {
 
1833
                        c = 2;
 
1834
                    } else if (s->left_comp_ctx[row7]) {
 
1835
                        c = 1 + (!s->fixcompref || !s->left_ref_ctx[row7]);
 
1836
                    } else {
 
1837
                        c = 4 * (!s->left_ref_ctx[row7]);
 
1838
                    }
 
1839
                } else {
 
1840
                    c = 2;
 
1841
                }
 
1842
                bit = vp56_rac_get_prob(&s->c, s->prob.p.single_ref[c][0]);
 
1843
                s->counts.single_ref[c][0][bit]++;
 
1844
                if (!bit) {
 
1845
                    b->ref[0] = 0;
 
1846
                } else {
 
1847
                    // FIXME can this codeblob be replaced by some sort of LUT?
 
1848
                    if (have_a) {
 
1849
                        if (have_l) {
 
1850
                            if (s->left_intra_ctx[row7]) {
 
1851
                                if (s->above_intra_ctx[col]) {
 
1852
                                    c = 2;
 
1853
                                } else if (s->above_comp_ctx[col]) {
 
1854
                                    c = 1 + 2 * (s->fixcompref == 1 ||
 
1855
                                                 s->above_ref_ctx[col] == 1);
 
1856
                                } else if (!s->above_ref_ctx[col]) {
 
1857
                                    c = 3;
 
1858
                                } else {
 
1859
                                    c = 4 * (s->above_ref_ctx[col] == 1);
 
1860
                                }
 
1861
                            } else if (s->above_intra_ctx[col]) {
 
1862
                                if (s->left_intra_ctx[row7]) {
 
1863
                                    c = 2;
 
1864
                                } else if (s->left_comp_ctx[row7]) {
 
1865
                                    c = 1 + 2 * (s->fixcompref == 1 ||
 
1866
                                                 s->left_ref_ctx[row7] == 1);
 
1867
                                } else if (!s->left_ref_ctx[row7]) {
 
1868
                                    c = 3;
 
1869
                                } else {
 
1870
                                    c = 4 * (s->left_ref_ctx[row7] == 1);
 
1871
                                }
 
1872
                            } else if (s->above_comp_ctx[col]) {
 
1873
                                if (s->left_comp_ctx[row7]) {
 
1874
                                    if (s->left_ref_ctx[row7] == s->above_ref_ctx[col]) {
 
1875
                                        c = 3 * (s->fixcompref == 1 ||
 
1876
                                                 s->left_ref_ctx[row7] == 1);
 
1877
                                    } else {
 
1878
                                        c = 2;
 
1879
                                    }
 
1880
                                } else if (!s->left_ref_ctx[row7]) {
 
1881
                                    c = 1 + 2 * (s->fixcompref == 1 ||
 
1882
                                                 s->above_ref_ctx[col] == 1);
 
1883
                                } else {
 
1884
                                    c = 3 * (s->left_ref_ctx[row7] == 1) +
 
1885
                                    (s->fixcompref == 1 || s->above_ref_ctx[col] == 1);
 
1886
                                }
 
1887
                            } else if (s->left_comp_ctx[row7]) {
 
1888
                                if (!s->above_ref_ctx[col]) {
 
1889
                                    c = 1 + 2 * (s->fixcompref == 1 ||
 
1890
                                                 s->left_ref_ctx[row7] == 1);
 
1891
                                } else {
 
1892
                                    c = 3 * (s->above_ref_ctx[col] == 1) +
 
1893
                                    (s->fixcompref == 1 || s->left_ref_ctx[row7] == 1);
 
1894
                                }
 
1895
                            } else if (!s->above_ref_ctx[col]) {
 
1896
                                if (!s->left_ref_ctx[row7]) {
 
1897
                                    c = 3;
 
1898
                                } else {
 
1899
                                    c = 4 * (s->left_ref_ctx[row7] == 1);
 
1900
                                }
 
1901
                            } else if (!s->left_ref_ctx[row7]) {
 
1902
                                c = 4 * (s->above_ref_ctx[col] == 1);
 
1903
                            } else {
 
1904
                                c = 2 * (s->left_ref_ctx[row7] == 1) +
 
1905
                                2 * (s->above_ref_ctx[col] == 1);
 
1906
                            }
 
1907
                        } else {
 
1908
                            if (s->above_intra_ctx[col] ||
 
1909
                                (!s->above_comp_ctx[col] && !s->above_ref_ctx[col])) {
 
1910
                                c = 2;
 
1911
                            } else if (s->above_comp_ctx[col]) {
 
1912
                                c = 3 * (s->fixcompref == 1 || s->above_ref_ctx[col] == 1);
 
1913
                            } else {
 
1914
                                c = 4 * (s->above_ref_ctx[col] == 1);
 
1915
                            }
 
1916
                        }
 
1917
                    } else if (have_l) {
 
1918
                        if (s->left_intra_ctx[row7] ||
 
1919
                            (!s->left_comp_ctx[row7] && !s->left_ref_ctx[row7])) {
 
1920
                            c = 2;
 
1921
                        } else if (s->left_comp_ctx[row7]) {
 
1922
                            c = 3 * (s->fixcompref == 1 || s->left_ref_ctx[row7] == 1);
 
1923
                        } else {
 
1924
                            c = 4 * (s->left_ref_ctx[row7] == 1);
 
1925
                        }
 
1926
                    } else {
 
1927
                        c = 2;
 
1928
                    }
 
1929
                    bit = vp56_rac_get_prob(&s->c, s->prob.p.single_ref[c][1]);
 
1930
                    s->counts.single_ref[c][1][bit]++;
 
1931
                    b->ref[0] = 1 + bit;
 
1932
                }
 
1933
            }
 
1934
        }
 
1935
 
 
1936
        if (b->bs <= BS_8x8) {
 
1937
            if (s->segmentation.feat[b->seg_id].skip_enabled) {
 
1938
                b->mode[0] = b->mode[1] = b->mode[2] = b->mode[3] = ZEROMV;
 
1939
            } else {
 
1940
                static const uint8_t off[10] = {
 
1941
                    3, 0, 0, 1, 0, 0, 0, 0, 0, 0
 
1942
                };
 
1943
 
 
1944
                // FIXME this needs to use the LUT tables from find_ref_mvs
 
1945
                // because not all are -1,0/0,-1
 
1946
                int c = inter_mode_ctx_lut[s->above_mode_ctx[col + off[b->bs]]]
 
1947
                                          [s->left_mode_ctx[row7 + off[b->bs]]];
 
1948
 
 
1949
                b->mode[0] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
 
1950
                                              s->prob.p.mv_mode[c]);
 
1951
                b->mode[1] = b->mode[2] = b->mode[3] = b->mode[0];
 
1952
                s->counts.mv_mode[c][b->mode[0] - 10]++;
 
1953
            }
 
1954
        }
 
1955
 
 
1956
        if (s->filtermode == FILTER_SWITCHABLE) {
 
1957
            int c;
 
1958
 
 
1959
            if (have_a && s->above_mode_ctx[col] >= NEARESTMV) {
 
1960
                if (have_l && s->left_mode_ctx[row7] >= NEARESTMV) {
 
1961
                    c = s->above_filter_ctx[col] == s->left_filter_ctx[row7] ?
 
1962
                        s->left_filter_ctx[row7] : 3;
 
1963
                } else {
 
1964
                    c = s->above_filter_ctx[col];
 
1965
                }
 
1966
            } else if (have_l && s->left_mode_ctx[row7] >= NEARESTMV) {
 
1967
                c = s->left_filter_ctx[row7];
 
1968
            } else {
 
1969
                c = 3;
 
1970
            }
 
1971
 
 
1972
            filter_id = vp8_rac_get_tree(&s->c, vp9_filter_tree,
 
1973
                                         s->prob.p.filter[c]);
 
1974
            s->counts.filter[c][filter_id]++;
 
1975
            b->filter = vp9_filter_lut[filter_id];
 
1976
        } else {
 
1977
            b->filter = s->filtermode;
 
1978
        }
 
1979
 
 
1980
        if (b->bs > BS_8x8) {
 
1981
            int c = inter_mode_ctx_lut[s->above_mode_ctx[col]][s->left_mode_ctx[row7]];
 
1982
 
 
1983
            b->mode[0] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
 
1984
                                          s->prob.p.mv_mode[c]);
 
1985
            s->counts.mv_mode[c][b->mode[0] - 10]++;
 
1986
            fill_mv(s, b->mv[0], b->mode[0], 0);
 
1987
 
 
1988
            if (b->bs != BS_8x4) {
 
1989
                b->mode[1] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
 
1990
                                              s->prob.p.mv_mode[c]);
 
1991
                s->counts.mv_mode[c][b->mode[1] - 10]++;
 
1992
                fill_mv(s, b->mv[1], b->mode[1], 1);
 
1993
            } else {
 
1994
                b->mode[1] = b->mode[0];
 
1995
                AV_COPY32(&b->mv[1][0], &b->mv[0][0]);
 
1996
                AV_COPY32(&b->mv[1][1], &b->mv[0][1]);
 
1997
            }
 
1998
 
 
1999
            if (b->bs != BS_4x8) {
 
2000
                b->mode[2] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
 
2001
                                              s->prob.p.mv_mode[c]);
 
2002
                s->counts.mv_mode[c][b->mode[2] - 10]++;
 
2003
                fill_mv(s, b->mv[2], b->mode[2], 2);
 
2004
 
 
2005
                if (b->bs != BS_8x4) {
 
2006
                    b->mode[3] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
 
2007
                                                  s->prob.p.mv_mode[c]);
 
2008
                    s->counts.mv_mode[c][b->mode[3] - 10]++;
 
2009
                    fill_mv(s, b->mv[3], b->mode[3], 3);
 
2010
                } else {
 
2011
                    b->mode[3] = b->mode[2];
 
2012
                    AV_COPY32(&b->mv[3][0], &b->mv[2][0]);
 
2013
                    AV_COPY32(&b->mv[3][1], &b->mv[2][1]);
 
2014
                }
 
2015
            } else {
 
2016
                b->mode[2] = b->mode[0];
 
2017
                AV_COPY32(&b->mv[2][0], &b->mv[0][0]);
 
2018
                AV_COPY32(&b->mv[2][1], &b->mv[0][1]);
 
2019
                b->mode[3] = b->mode[1];
 
2020
                AV_COPY32(&b->mv[3][0], &b->mv[1][0]);
 
2021
                AV_COPY32(&b->mv[3][1], &b->mv[1][1]);
 
2022
            }
 
2023
        } else {
 
2024
            fill_mv(s, b->mv[0], b->mode[0], -1);
 
2025
            AV_COPY32(&b->mv[1][0], &b->mv[0][0]);
 
2026
            AV_COPY32(&b->mv[2][0], &b->mv[0][0]);
 
2027
            AV_COPY32(&b->mv[3][0], &b->mv[0][0]);
 
2028
            AV_COPY32(&b->mv[1][1], &b->mv[0][1]);
 
2029
            AV_COPY32(&b->mv[2][1], &b->mv[0][1]);
 
2030
            AV_COPY32(&b->mv[3][1], &b->mv[0][1]);
 
2031
        }
 
2032
 
 
2033
        vref = b->ref[b->comp ? s->signbias[s->varcompref[0]] : 0];
 
2034
    }
 
2035
 
 
2036
#if HAVE_FAST_64BIT
 
2037
#define SPLAT_CTX(var, val, n) \
 
2038
    switch (n) { \
 
2039
    case 1:  var = val;                                    break; \
 
2040
    case 2:  AV_WN16A(&var, val *             0x0101);     break; \
 
2041
    case 4:  AV_WN32A(&var, val *         0x01010101);     break; \
 
2042
    case 8:  AV_WN64A(&var, val * 0x0101010101010101ULL);  break; \
 
2043
    case 16: { \
 
2044
        uint64_t v64 = val * 0x0101010101010101ULL; \
 
2045
        AV_WN64A(              &var,     v64); \
 
2046
        AV_WN64A(&((uint8_t *) &var)[8], v64); \
 
2047
        break; \
 
2048
    } \
 
2049
    }
 
2050
#else
 
2051
#define SPLAT_CTX(var, val, n) \
 
2052
    switch (n) { \
 
2053
    case 1:  var = val;                         break; \
 
2054
    case 2:  AV_WN16A(&var, val *     0x0101);  break; \
 
2055
    case 4:  AV_WN32A(&var, val * 0x01010101);  break; \
 
2056
    case 8: { \
 
2057
        uint32_t v32 = val * 0x01010101; \
 
2058
        AV_WN32A(              &var,     v32); \
 
2059
        AV_WN32A(&((uint8_t *) &var)[4], v32); \
 
2060
        break; \
 
2061
    } \
 
2062
    case 16: { \
 
2063
        uint32_t v32 = val * 0x01010101; \
 
2064
        AV_WN32A(              &var,      v32); \
 
2065
        AV_WN32A(&((uint8_t *) &var)[4],  v32); \
 
2066
        AV_WN32A(&((uint8_t *) &var)[8],  v32); \
 
2067
        AV_WN32A(&((uint8_t *) &var)[12], v32); \
 
2068
        break; \
 
2069
    } \
 
2070
    }
 
2071
#endif
 
2072
 
 
2073
    switch (bwh_tab[1][b->bs][0]) {
 
2074
#define SET_CTXS(dir, off, n) \
 
2075
    do { \
 
2076
        SPLAT_CTX(s->dir##_skip_ctx[off],      b->skip,          n); \
 
2077
        SPLAT_CTX(s->dir##_txfm_ctx[off],      b->tx,            n); \
 
2078
        SPLAT_CTX(s->dir##_partition_ctx[off], dir##_ctx[b->bs], n); \
 
2079
        if (!s->keyframe && !s->intraonly) { \
 
2080
            SPLAT_CTX(s->dir##_intra_ctx[off], b->intra,   n); \
 
2081
            SPLAT_CTX(s->dir##_comp_ctx[off],  b->comp,    n); \
 
2082
            SPLAT_CTX(s->dir##_mode_ctx[off],  b->mode[3], n); \
 
2083
            if (!b->intra) { \
 
2084
                SPLAT_CTX(s->dir##_ref_ctx[off], vref, n); \
 
2085
                if (s->filtermode == FILTER_SWITCHABLE) { \
 
2086
                    SPLAT_CTX(s->dir##_filter_ctx[off], filter_id, n); \
 
2087
                } \
 
2088
            } \
 
2089
        } \
 
2090
    } while (0)
 
2091
    case 1: SET_CTXS(above, col, 1); break;
 
2092
    case 2: SET_CTXS(above, col, 2); break;
 
2093
    case 4: SET_CTXS(above, col, 4); break;
 
2094
    case 8: SET_CTXS(above, col, 8); break;
 
2095
    }
 
2096
    switch (bwh_tab[1][b->bs][1]) {
 
2097
    case 1: SET_CTXS(left, row7, 1); break;
 
2098
    case 2: SET_CTXS(left, row7, 2); break;
 
2099
    case 4: SET_CTXS(left, row7, 4); break;
 
2100
    case 8: SET_CTXS(left, row7, 8); break;
 
2101
    }
 
2102
#undef SPLAT_CTX
 
2103
#undef SET_CTXS
 
2104
 
 
2105
    if (!s->keyframe && !s->intraonly) {
 
2106
        if (b->bs > BS_8x8) {
 
2107
            int mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]);
 
2108
 
 
2109
            AV_COPY32(&s->left_mv_ctx[row7 * 2 + 0][0], &b->mv[1][0]);
 
2110
            AV_COPY32(&s->left_mv_ctx[row7 * 2 + 0][1], &b->mv[1][1]);
 
2111
            AV_WN32A(&s->left_mv_ctx[row7 * 2 + 1][0], mv0);
 
2112
            AV_WN32A(&s->left_mv_ctx[row7 * 2 + 1][1], mv1);
 
2113
            AV_COPY32(&s->above_mv_ctx[col * 2 + 0][0], &b->mv[2][0]);
 
2114
            AV_COPY32(&s->above_mv_ctx[col * 2 + 0][1], &b->mv[2][1]);
 
2115
            AV_WN32A(&s->above_mv_ctx[col * 2 + 1][0], mv0);
 
2116
            AV_WN32A(&s->above_mv_ctx[col * 2 + 1][1], mv1);
 
2117
        } else {
 
2118
            int n, mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]);
 
2119
 
 
2120
            for (n = 0; n < w4 * 2; n++) {
 
2121
                AV_WN32A(&s->above_mv_ctx[col * 2 + n][0], mv0);
 
2122
                AV_WN32A(&s->above_mv_ctx[col * 2 + n][1], mv1);
 
2123
            }
 
2124
            for (n = 0; n < h4 * 2; n++) {
 
2125
                AV_WN32A(&s->left_mv_ctx[row7 * 2 + n][0], mv0);
 
2126
                AV_WN32A(&s->left_mv_ctx[row7 * 2 + n][1], mv1);
 
2127
            }
 
2128
        }
 
2129
    }
 
2130
 
 
2131
    // FIXME kinda ugly
 
2132
    for (y = 0; y < h4; y++) {
 
2133
        int x, o = (row + y) * s->sb_cols * 8 + col;
 
2134
        struct VP9mvrefPair *mv = &s->frames[CUR_FRAME].mv[o];
 
2135
 
 
2136
        if (b->intra) {
 
2137
            for (x = 0; x < w4; x++) {
 
2138
                mv[x].ref[0] =
 
2139
                mv[x].ref[1] = -1;
 
2140
            }
 
2141
        } else if (b->comp) {
 
2142
            for (x = 0; x < w4; x++) {
 
2143
                mv[x].ref[0] = b->ref[0];
 
2144
                mv[x].ref[1] = b->ref[1];
 
2145
                AV_COPY32(&mv[x].mv[0], &b->mv[3][0]);
 
2146
                AV_COPY32(&mv[x].mv[1], &b->mv[3][1]);
 
2147
            }
 
2148
        } else {
 
2149
            for (x = 0; x < w4; x++) {
 
2150
                mv[x].ref[0] = b->ref[0];
 
2151
                mv[x].ref[1] = -1;
 
2152
                AV_COPY32(&mv[x].mv[0], &b->mv[3][0]);
 
2153
            }
 
2154
        }
 
2155
    }
 
2156
}
 
2157
 
 
2158
// FIXME merge cnt/eob arguments?
 
2159
static av_always_inline int
 
2160
decode_coeffs_b_generic(VP56RangeCoder *c, int16_t *coef, int n_coeffs,
 
2161
                        int is_tx32x32, int is8bitsperpixel, int bpp, unsigned (*cnt)[6][3],
 
2162
                        unsigned (*eob)[6][2], uint8_t (*p)[6][11],
 
2163
                        int nnz, const int16_t *scan, const int16_t (*nb)[2],
 
2164
                        const int16_t *band_counts, const int16_t *qmul)
 
2165
{
 
2166
    int i = 0, band = 0, band_left = band_counts[band];
 
2167
    uint8_t *tp = p[0][nnz];
 
2168
    uint8_t cache[1024];
 
2169
 
 
2170
    do {
 
2171
        int val, rc;
 
2172
 
 
2173
        val = vp56_rac_get_prob_branchy(c, tp[0]); // eob
 
2174
        eob[band][nnz][val]++;
 
2175
        if (!val)
 
2176
            break;
 
2177
 
 
2178
    skip_eob:
 
2179
        if (!vp56_rac_get_prob_branchy(c, tp[1])) { // zero
 
2180
            cnt[band][nnz][0]++;
 
2181
            if (!--band_left)
 
2182
                band_left = band_counts[++band];
 
2183
            cache[scan[i]] = 0;
 
2184
            nnz = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1;
 
2185
            tp = p[band][nnz];
 
2186
            if (++i == n_coeffs)
 
2187
                break; //invalid input; blocks should end with EOB
 
2188
            goto skip_eob;
 
2189
        }
 
2190
 
 
2191
        rc = scan[i];
 
2192
        if (!vp56_rac_get_prob_branchy(c, tp[2])) { // one
 
2193
            cnt[band][nnz][1]++;
 
2194
            val = 1;
 
2195
            cache[rc] = 1;
 
2196
        } else {
 
2197
            // fill in p[3-10] (model fill) - only once per frame for each pos
 
2198
            if (!tp[3])
 
2199
                memcpy(&tp[3], vp9_model_pareto8[tp[2]], 8);
 
2200
 
 
2201
            cnt[band][nnz][2]++;
 
2202
            if (!vp56_rac_get_prob_branchy(c, tp[3])) { // 2, 3, 4
 
2203
                if (!vp56_rac_get_prob_branchy(c, tp[4])) {
 
2204
                    cache[rc] = val = 2;
 
2205
                } else {
 
2206
                    val = 3 + vp56_rac_get_prob(c, tp[5]);
 
2207
                    cache[rc] = 3;
 
2208
                }
 
2209
            } else if (!vp56_rac_get_prob_branchy(c, tp[6])) { // cat1/2
 
2210
                cache[rc] = 4;
 
2211
                if (!vp56_rac_get_prob_branchy(c, tp[7])) {
 
2212
                    val = 5 + vp56_rac_get_prob(c, 159);
 
2213
                } else {
 
2214
                    val  = 7 + (vp56_rac_get_prob(c, 165) << 1);
 
2215
                    val +=      vp56_rac_get_prob(c, 145);
 
2216
                }
 
2217
            } else { // cat 3-6
 
2218
                cache[rc] = 5;
 
2219
                if (!vp56_rac_get_prob_branchy(c, tp[8])) {
 
2220
                    if (!vp56_rac_get_prob_branchy(c, tp[9])) {
 
2221
                        val  = 11 + (vp56_rac_get_prob(c, 173) << 2);
 
2222
                        val +=      (vp56_rac_get_prob(c, 148) << 1);
 
2223
                        val +=       vp56_rac_get_prob(c, 140);
 
2224
                    } else {
 
2225
                        val  = 19 + (vp56_rac_get_prob(c, 176) << 3);
 
2226
                        val +=      (vp56_rac_get_prob(c, 155) << 2);
 
2227
                        val +=      (vp56_rac_get_prob(c, 140) << 1);
 
2228
                        val +=       vp56_rac_get_prob(c, 135);
 
2229
                    }
 
2230
                } else if (!vp56_rac_get_prob_branchy(c, tp[10])) {
 
2231
                    val  = 35 + (vp56_rac_get_prob(c, 180) << 4);
 
2232
                    val +=      (vp56_rac_get_prob(c, 157) << 3);
 
2233
                    val +=      (vp56_rac_get_prob(c, 141) << 2);
 
2234
                    val +=      (vp56_rac_get_prob(c, 134) << 1);
 
2235
                    val +=       vp56_rac_get_prob(c, 130);
 
2236
                } else {
 
2237
                    val = 67;
 
2238
                    if (!is8bitsperpixel) {
 
2239
                        if (bpp == 12) {
 
2240
                            val += vp56_rac_get_prob(c, 255) << 17;
 
2241
                            val += vp56_rac_get_prob(c, 255) << 16;
 
2242
                        }
 
2243
                        val +=  (vp56_rac_get_prob(c, 255) << 15);
 
2244
                        val +=  (vp56_rac_get_prob(c, 255) << 14);
 
2245
                    }
 
2246
                    val +=      (vp56_rac_get_prob(c, 254) << 13);
 
2247
                    val +=      (vp56_rac_get_prob(c, 254) << 12);
 
2248
                    val +=      (vp56_rac_get_prob(c, 254) << 11);
 
2249
                    val +=      (vp56_rac_get_prob(c, 252) << 10);
 
2250
                    val +=      (vp56_rac_get_prob(c, 249) << 9);
 
2251
                    val +=      (vp56_rac_get_prob(c, 243) << 8);
 
2252
                    val +=      (vp56_rac_get_prob(c, 230) << 7);
 
2253
                    val +=      (vp56_rac_get_prob(c, 196) << 6);
 
2254
                    val +=      (vp56_rac_get_prob(c, 177) << 5);
 
2255
                    val +=      (vp56_rac_get_prob(c, 153) << 4);
 
2256
                    val +=      (vp56_rac_get_prob(c, 140) << 3);
 
2257
                    val +=      (vp56_rac_get_prob(c, 133) << 2);
 
2258
                    val +=      (vp56_rac_get_prob(c, 130) << 1);
 
2259
                    val +=       vp56_rac_get_prob(c, 129);
 
2260
                }
 
2261
            }
 
2262
        }
 
2263
#define STORE_COEF(c, i, v) do { \
 
2264
    if (is8bitsperpixel) { \
 
2265
        c[i] = v; \
 
2266
    } else { \
 
2267
        AV_WN32A(&c[i * 2], v); \
 
2268
    } \
 
2269
} while (0)
 
2270
        if (!--band_left)
 
2271
            band_left = band_counts[++band];
 
2272
        if (is_tx32x32)
 
2273
            STORE_COEF(coef, rc, ((vp8_rac_get(c) ? -val : val) * qmul[!!i]) / 2);
 
2274
        else
 
2275
            STORE_COEF(coef, rc, (vp8_rac_get(c) ? -val : val) * qmul[!!i]);
 
2276
        nnz = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1;
 
2277
        tp = p[band][nnz];
 
2278
    } while (++i < n_coeffs);
 
2279
 
 
2280
    return i;
 
2281
}
 
2282
 
 
2283
static int decode_coeffs_b_8bpp(VP9Context *s, int16_t *coef, int n_coeffs,
 
2284
                                unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
 
2285
                                uint8_t (*p)[6][11], int nnz, const int16_t *scan,
 
2286
                                const int16_t (*nb)[2], const int16_t *band_counts,
 
2287
                                const int16_t *qmul)
 
2288
{
 
2289
    return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 0, 1, 8, cnt, eob, p,
 
2290
                                   nnz, scan, nb, band_counts, qmul);
 
2291
}
 
2292
 
 
2293
static int decode_coeffs_b32_8bpp(VP9Context *s, int16_t *coef, int n_coeffs,
 
2294
                                  unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
 
2295
                                  uint8_t (*p)[6][11], int nnz, const int16_t *scan,
 
2296
                                  const int16_t (*nb)[2], const int16_t *band_counts,
 
2297
                                  const int16_t *qmul)
 
2298
{
 
2299
    return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 1, 1, 8, cnt, eob, p,
 
2300
                                   nnz, scan, nb, band_counts, qmul);
 
2301
}
 
2302
 
 
2303
static int decode_coeffs_b_16bpp(VP9Context *s, int16_t *coef, int n_coeffs,
 
2304
                                 unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
 
2305
                                 uint8_t (*p)[6][11], int nnz, const int16_t *scan,
 
2306
                                 const int16_t (*nb)[2], const int16_t *band_counts,
 
2307
                                 const int16_t *qmul)
 
2308
{
 
2309
    return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 0, 0, s->bpp, cnt, eob, p,
 
2310
                                   nnz, scan, nb, band_counts, qmul);
 
2311
}
 
2312
 
 
2313
static int decode_coeffs_b32_16bpp(VP9Context *s, int16_t *coef, int n_coeffs,
 
2314
                                   unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
 
2315
                                   uint8_t (*p)[6][11], int nnz, const int16_t *scan,
 
2316
                                   const int16_t (*nb)[2], const int16_t *band_counts,
 
2317
                                   const int16_t *qmul)
 
2318
{
 
2319
    return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 1, 0, s->bpp, cnt, eob, p,
 
2320
                                   nnz, scan, nb, band_counts, qmul);
 
2321
}
 
2322
 
 
2323
static av_always_inline int decode_coeffs(AVCodecContext *ctx, int is8bitsperpixel)
 
2324
{
 
2325
    VP9Context *s = ctx->priv_data;
 
2326
    VP9Block *b = s->b;
 
2327
    int row = s->row, col = s->col;
 
2328
    uint8_t (*p)[6][11] = s->prob.coef[b->tx][0 /* y */][!b->intra];
 
2329
    unsigned (*c)[6][3] = s->counts.coef[b->tx][0 /* y */][!b->intra];
 
2330
    unsigned (*e)[6][2] = s->counts.eob[b->tx][0 /* y */][!b->intra];
 
2331
    int w4 = bwh_tab[1][b->bs][0] << 1, h4 = bwh_tab[1][b->bs][1] << 1;
 
2332
    int end_x = FFMIN(2 * (s->cols - col), w4);
 
2333
    int end_y = FFMIN(2 * (s->rows - row), h4);
 
2334
    int n, pl, x, y, res;
 
2335
    int16_t (*qmul)[2] = s->segmentation.feat[b->seg_id].qmul;
 
2336
    int tx = 4 * s->lossless + b->tx;
 
2337
    const int16_t * const *yscans = vp9_scans[tx];
 
2338
    const int16_t (* const *ynbs)[2] = vp9_scans_nb[tx];
 
2339
    const int16_t *uvscan = vp9_scans[b->uvtx][DCT_DCT];
 
2340
    const int16_t (*uvnb)[2] = vp9_scans_nb[b->uvtx][DCT_DCT];
 
2341
    uint8_t *a = &s->above_y_nnz_ctx[col * 2];
 
2342
    uint8_t *l = &s->left_y_nnz_ctx[(row & 7) << 1];
 
2343
    static const int16_t band_counts[4][8] = {
 
2344
        { 1, 2, 3, 4,  3,   16 - 13 },
 
2345
        { 1, 2, 3, 4, 11,   64 - 21 },
 
2346
        { 1, 2, 3, 4, 11,  256 - 21 },
 
2347
        { 1, 2, 3, 4, 11, 1024 - 21 },
 
2348
    };
 
2349
    const int16_t *y_band_counts = band_counts[b->tx];
 
2350
    const int16_t *uv_band_counts = band_counts[b->uvtx];
 
2351
    int bytesperpixel = is8bitsperpixel ? 1 : 2;
 
2352
    int total_coeff = 0;
 
2353
 
 
2354
#define MERGE(la, end, step, rd) \
 
2355
    for (n = 0; n < end; n += step) \
 
2356
        la[n] = !!rd(&la[n])
 
2357
#define MERGE_CTX(step, rd) \
 
2358
    do { \
 
2359
        MERGE(l, end_y, step, rd); \
 
2360
        MERGE(a, end_x, step, rd); \
 
2361
    } while (0)
 
2362
 
 
2363
#define DECODE_Y_COEF_LOOP(step, mode_index, v) \
 
2364
    for (n = 0, y = 0; y < end_y; y += step) { \
 
2365
        for (x = 0; x < end_x; x += step, n += step * step) { \
 
2366
            enum TxfmType txtp = vp9_intra_txfm_type[b->mode[mode_index]]; \
 
2367
            res = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \
 
2368
                                    (s, s->block + 16 * n * bytesperpixel, 16 * step * step, \
 
2369
                                     c, e, p, a[x] + l[y], yscans[txtp], \
 
2370
                                     ynbs[txtp], y_band_counts, qmul[0]); \
 
2371
            a[x] = l[y] = !!res; \
 
2372
            total_coeff |= !!res; \
 
2373
            if (step >= 4) { \
 
2374
                AV_WN16A(&s->eob[n], res); \
 
2375
            } else { \
 
2376
                s->eob[n] = res; \
 
2377
            } \
 
2378
        } \
 
2379
    }
 
2380
 
 
2381
#define SPLAT(la, end, step, cond) \
 
2382
    if (step == 2) { \
 
2383
        for (n = 1; n < end; n += step) \
 
2384
            la[n] = la[n - 1]; \
 
2385
    } else if (step == 4) { \
 
2386
        if (cond) { \
 
2387
            for (n = 0; n < end; n += step) \
 
2388
                AV_WN32A(&la[n], la[n] * 0x01010101); \
 
2389
        } else { \
 
2390
            for (n = 0; n < end; n += step) \
 
2391
                memset(&la[n + 1], la[n], FFMIN(end - n - 1, 3)); \
 
2392
        } \
 
2393
    } else /* step == 8 */ { \
 
2394
        if (cond) { \
 
2395
            if (HAVE_FAST_64BIT) { \
 
2396
                for (n = 0; n < end; n += step) \
 
2397
                    AV_WN64A(&la[n], la[n] * 0x0101010101010101ULL); \
 
2398
            } else { \
 
2399
                for (n = 0; n < end; n += step) { \
 
2400
                    uint32_t v32 = la[n] * 0x01010101; \
 
2401
                    AV_WN32A(&la[n],     v32); \
 
2402
                    AV_WN32A(&la[n + 4], v32); \
 
2403
                } \
 
2404
            } \
 
2405
        } else { \
 
2406
            for (n = 0; n < end; n += step) \
 
2407
                memset(&la[n + 1], la[n], FFMIN(end - n - 1, 7)); \
 
2408
        } \
 
2409
    }
 
2410
#define SPLAT_CTX(step) \
 
2411
    do { \
 
2412
        SPLAT(a, end_x, step, end_x == w4); \
 
2413
        SPLAT(l, end_y, step, end_y == h4); \
 
2414
    } while (0)
 
2415
 
 
2416
    /* y tokens */
 
2417
    switch (b->tx) {
 
2418
    case TX_4X4:
 
2419
        DECODE_Y_COEF_LOOP(1, b->bs > BS_8x8 ? n : 0,);
 
2420
        break;
 
2421
    case TX_8X8:
 
2422
        MERGE_CTX(2, AV_RN16A);
 
2423
        DECODE_Y_COEF_LOOP(2, 0,);
 
2424
        SPLAT_CTX(2);
 
2425
        break;
 
2426
    case TX_16X16:
 
2427
        MERGE_CTX(4, AV_RN32A);
 
2428
        DECODE_Y_COEF_LOOP(4, 0,);
 
2429
        SPLAT_CTX(4);
 
2430
        break;
 
2431
    case TX_32X32:
 
2432
        MERGE_CTX(8, AV_RN64A);
 
2433
        DECODE_Y_COEF_LOOP(8, 0, 32);
 
2434
        SPLAT_CTX(8);
 
2435
        break;
 
2436
    }
 
2437
 
 
2438
#define DECODE_UV_COEF_LOOP(step, v) \
 
2439
    for (n = 0, y = 0; y < end_y; y += step) { \
 
2440
        for (x = 0; x < end_x; x += step, n += step * step) { \
 
2441
            res = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \
 
2442
                                    (s, s->uvblock[pl] + 16 * n * bytesperpixel, \
 
2443
                                     16 * step * step, c, e, p, a[x] + l[y], \
 
2444
                                     uvscan, uvnb, uv_band_counts, qmul[1]); \
 
2445
            a[x] = l[y] = !!res; \
 
2446
            total_coeff |= !!res; \
 
2447
            if (step >= 4) { \
 
2448
                AV_WN16A(&s->uveob[pl][n], res); \
 
2449
            } else { \
 
2450
                s->uveob[pl][n] = res; \
 
2451
            } \
 
2452
        } \
 
2453
    }
 
2454
 
 
2455
    p = s->prob.coef[b->uvtx][1 /* uv */][!b->intra];
 
2456
    c = s->counts.coef[b->uvtx][1 /* uv */][!b->intra];
 
2457
    e = s->counts.eob[b->uvtx][1 /* uv */][!b->intra];
 
2458
    w4 >>= s->ss_h;
 
2459
    end_x >>= s->ss_h;
 
2460
    h4 >>= s->ss_v;
 
2461
    end_y >>= s->ss_v;
 
2462
    for (pl = 0; pl < 2; pl++) {
 
2463
        a = &s->above_uv_nnz_ctx[pl][col << !s->ss_h];
 
2464
        l = &s->left_uv_nnz_ctx[pl][(row & 7) << !s->ss_v];
 
2465
        switch (b->uvtx) {
 
2466
        case TX_4X4:
 
2467
            DECODE_UV_COEF_LOOP(1,);
 
2468
            break;
 
2469
        case TX_8X8:
 
2470
            MERGE_CTX(2, AV_RN16A);
 
2471
            DECODE_UV_COEF_LOOP(2,);
 
2472
            SPLAT_CTX(2);
 
2473
            break;
 
2474
        case TX_16X16:
 
2475
            MERGE_CTX(4, AV_RN32A);
 
2476
            DECODE_UV_COEF_LOOP(4,);
 
2477
            SPLAT_CTX(4);
 
2478
            break;
 
2479
        case TX_32X32:
 
2480
            MERGE_CTX(8, AV_RN64A);
 
2481
            DECODE_UV_COEF_LOOP(8, 32);
 
2482
            SPLAT_CTX(8);
 
2483
            break;
 
2484
        }
 
2485
    }
 
2486
 
 
2487
    return total_coeff;
 
2488
}
 
2489
 
 
2490
static int decode_coeffs_8bpp(AVCodecContext *ctx)
 
2491
{
 
2492
    return decode_coeffs(ctx, 1);
 
2493
}
 
2494
 
 
2495
static int decode_coeffs_16bpp(AVCodecContext *ctx)
 
2496
{
 
2497
    return decode_coeffs(ctx, 0);
 
2498
}
 
2499
 
 
2500
static av_always_inline int check_intra_mode(VP9Context *s, int mode, uint8_t **a,
 
2501
                                             uint8_t *dst_edge, ptrdiff_t stride_edge,
 
2502
                                             uint8_t *dst_inner, ptrdiff_t stride_inner,
 
2503
                                             uint8_t *l, int col, int x, int w,
 
2504
                                             int row, int y, enum TxfmMode tx,
 
2505
                                             int p, int ss_h, int ss_v, int bytesperpixel)
 
2506
{
 
2507
    int have_top = row > 0 || y > 0;
 
2508
    int have_left = col > s->tiling.tile_col_start || x > 0;
 
2509
    int have_right = x < w - 1;
 
2510
    int bpp = s->bpp;
 
2511
    static const uint8_t mode_conv[10][2 /* have_left */][2 /* have_top */] = {
 
2512
        [VERT_PRED]            = { { DC_127_PRED,          VERT_PRED },
 
2513
                                   { DC_127_PRED,          VERT_PRED } },
 
2514
        [HOR_PRED]             = { { DC_129_PRED,          DC_129_PRED },
 
2515
                                   { HOR_PRED,             HOR_PRED } },
 
2516
        [DC_PRED]              = { { DC_128_PRED,          TOP_DC_PRED },
 
2517
                                   { LEFT_DC_PRED,         DC_PRED } },
 
2518
        [DIAG_DOWN_LEFT_PRED]  = { { DC_127_PRED,          DIAG_DOWN_LEFT_PRED },
 
2519
                                   { DC_127_PRED,          DIAG_DOWN_LEFT_PRED } },
 
2520
        [DIAG_DOWN_RIGHT_PRED] = { { DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_RIGHT_PRED },
 
2521
                                   { DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_RIGHT_PRED } },
 
2522
        [VERT_RIGHT_PRED]      = { { VERT_RIGHT_PRED,      VERT_RIGHT_PRED },
 
2523
                                   { VERT_RIGHT_PRED,      VERT_RIGHT_PRED } },
 
2524
        [HOR_DOWN_PRED]        = { { HOR_DOWN_PRED,        HOR_DOWN_PRED },
 
2525
                                   { HOR_DOWN_PRED,        HOR_DOWN_PRED } },
 
2526
        [VERT_LEFT_PRED]       = { { DC_127_PRED,          VERT_LEFT_PRED },
 
2527
                                   { DC_127_PRED,          VERT_LEFT_PRED } },
 
2528
        [HOR_UP_PRED]          = { { DC_129_PRED,          DC_129_PRED },
 
2529
                                   { HOR_UP_PRED,          HOR_UP_PRED } },
 
2530
        [TM_VP8_PRED]          = { { DC_129_PRED,          VERT_PRED },
 
2531
                                   { HOR_PRED,             TM_VP8_PRED } },
 
2532
    };
 
2533
    static const struct {
 
2534
        uint8_t needs_left:1;
 
2535
        uint8_t needs_top:1;
 
2536
        uint8_t needs_topleft:1;
 
2537
        uint8_t needs_topright:1;
 
2538
        uint8_t invert_left:1;
 
2539
    } edges[N_INTRA_PRED_MODES] = {
 
2540
        [VERT_PRED]            = { .needs_top  = 1 },
 
2541
        [HOR_PRED]             = { .needs_left = 1 },
 
2542
        [DC_PRED]              = { .needs_top  = 1, .needs_left = 1 },
 
2543
        [DIAG_DOWN_LEFT_PRED]  = { .needs_top  = 1, .needs_topright = 1 },
 
2544
        [DIAG_DOWN_RIGHT_PRED] = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
 
2545
        [VERT_RIGHT_PRED]      = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
 
2546
        [HOR_DOWN_PRED]        = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
 
2547
        [VERT_LEFT_PRED]       = { .needs_top  = 1, .needs_topright = 1 },
 
2548
        [HOR_UP_PRED]          = { .needs_left = 1, .invert_left = 1 },
 
2549
        [TM_VP8_PRED]          = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
 
2550
        [LEFT_DC_PRED]         = { .needs_left = 1 },
 
2551
        [TOP_DC_PRED]          = { .needs_top  = 1 },
 
2552
        [DC_128_PRED]          = { 0 },
 
2553
        [DC_127_PRED]          = { 0 },
 
2554
        [DC_129_PRED]          = { 0 }
 
2555
    };
 
2556
 
 
2557
    av_assert2(mode >= 0 && mode < 10);
 
2558
    mode = mode_conv[mode][have_left][have_top];
 
2559
    if (edges[mode].needs_top) {
 
2560
        uint8_t *top, *topleft;
 
2561
        int n_px_need = 4 << tx, n_px_have = (((s->cols - col) << !ss_h) - x) * 4;
 
2562
        int n_px_need_tr = 0;
 
2563
 
 
2564
        if (tx == TX_4X4 && edges[mode].needs_topright && have_right)
 
2565
            n_px_need_tr = 4;
 
2566
 
 
2567
        // if top of sb64-row, use s->intra_pred_data[] instead of
 
2568
        // dst[-stride] for intra prediction (it contains pre- instead of
 
2569
        // post-loopfilter data)
 
2570
        if (have_top) {
 
2571
            top = !(row & 7) && !y ?
 
2572
                s->intra_pred_data[p] + (col * (8 >> ss_h) + x * 4) * bytesperpixel :
 
2573
                y == 0 ? &dst_edge[-stride_edge] : &dst_inner[-stride_inner];
 
2574
            if (have_left)
 
2575
                topleft = !(row & 7) && !y ?
 
2576
                    s->intra_pred_data[p] + (col * (8 >> ss_h) + x * 4) * bytesperpixel :
 
2577
                    y == 0 || x == 0 ? &dst_edge[-stride_edge] :
 
2578
                    &dst_inner[-stride_inner];
 
2579
        }
 
2580
 
 
2581
        if (have_top &&
 
2582
            (!edges[mode].needs_topleft || (have_left && top == topleft)) &&
 
2583
            (tx != TX_4X4 || !edges[mode].needs_topright || have_right) &&
 
2584
            n_px_need + n_px_need_tr <= n_px_have) {
 
2585
            *a = top;
 
2586
        } else {
 
2587
            if (have_top) {
 
2588
                if (n_px_need <= n_px_have) {
 
2589
                    memcpy(*a, top, n_px_need * bytesperpixel);
 
2590
                } else {
 
2591
#define memset_bpp(c, i1, v, i2, num) do { \
 
2592
    if (bytesperpixel == 1) { \
 
2593
        memset(&(c)[(i1)], (v)[(i2)], (num)); \
 
2594
    } else { \
 
2595
        int n, val = AV_RN16A(&(v)[(i2) * 2]); \
 
2596
        for (n = 0; n < (num); n++) { \
 
2597
            AV_WN16A(&(c)[((i1) + n) * 2], val); \
 
2598
        } \
 
2599
    } \
 
2600
} while (0)
 
2601
                    memcpy(*a, top, n_px_have * bytesperpixel);
 
2602
                    memset_bpp(*a, n_px_have, (*a), n_px_have - 1, n_px_need - n_px_have);
 
2603
                }
 
2604
            } else {
 
2605
#define memset_val(c, val, num) do { \
 
2606
    if (bytesperpixel == 1) { \
 
2607
        memset((c), (val), (num)); \
 
2608
    } else { \
 
2609
        int n; \
 
2610
        for (n = 0; n < (num); n++) { \
 
2611
            AV_WN16A(&(c)[n * 2], (val)); \
 
2612
        } \
 
2613
    } \
 
2614
} while (0)
 
2615
                memset_val(*a, (128 << (bpp - 8)) - 1, n_px_need);
 
2616
            }
 
2617
            if (edges[mode].needs_topleft) {
 
2618
                if (have_left && have_top) {
 
2619
#define assign_bpp(c, i1, v, i2) do { \
 
2620
    if (bytesperpixel == 1) { \
 
2621
        (c)[(i1)] = (v)[(i2)]; \
 
2622
    } else { \
 
2623
        AV_COPY16(&(c)[(i1) * 2], &(v)[(i2) * 2]); \
 
2624
    } \
 
2625
} while (0)
 
2626
                    assign_bpp(*a, -1, topleft, -1);
 
2627
                } else {
 
2628
#define assign_val(c, i, v) do { \
 
2629
    if (bytesperpixel == 1) { \
 
2630
        (c)[(i)] = (v); \
 
2631
    } else { \
 
2632
        AV_WN16A(&(c)[(i) * 2], (v)); \
 
2633
    } \
 
2634
} while (0)
 
2635
                    assign_val((*a), -1, (128 << (bpp - 8)) + (have_top ? +1 : -1));
 
2636
                }
 
2637
            }
 
2638
            if (tx == TX_4X4 && edges[mode].needs_topright) {
 
2639
                if (have_top && have_right &&
 
2640
                    n_px_need + n_px_need_tr <= n_px_have) {
 
2641
                    memcpy(&(*a)[4 * bytesperpixel], &top[4 * bytesperpixel], 4 * bytesperpixel);
 
2642
                } else {
 
2643
                    memset_bpp(*a, 4, *a, 3, 4);
 
2644
                }
 
2645
            }
 
2646
        }
 
2647
    }
 
2648
    if (edges[mode].needs_left) {
 
2649
        if (have_left) {
 
2650
            int n_px_need = 4 << tx, i, n_px_have = (((s->rows - row) << !ss_v) - y) * 4;
 
2651
            uint8_t *dst = x == 0 ? dst_edge : dst_inner;
 
2652
            ptrdiff_t stride = x == 0 ? stride_edge : stride_inner;
 
2653
 
 
2654
            if (edges[mode].invert_left) {
 
2655
                if (n_px_need <= n_px_have) {
 
2656
                    for (i = 0; i < n_px_need; i++)
 
2657
                        assign_bpp(l, i, &dst[i * stride], -1);
 
2658
                } else {
 
2659
                    for (i = 0; i < n_px_have; i++)
 
2660
                        assign_bpp(l, i, &dst[i * stride], -1);
 
2661
                    memset_bpp(l, n_px_have, l, n_px_have - 1, n_px_need - n_px_have);
 
2662
                }
 
2663
            } else {
 
2664
                if (n_px_need <= n_px_have) {
 
2665
                    for (i = 0; i < n_px_need; i++)
 
2666
                        assign_bpp(l, n_px_need - 1 - i, &dst[i * stride], -1);
 
2667
                } else {
 
2668
                    for (i = 0; i < n_px_have; i++)
 
2669
                        assign_bpp(l, n_px_need - 1 - i, &dst[i * stride], -1);
 
2670
                    memset_bpp(l, 0, l, n_px_need - n_px_have, n_px_need - n_px_have);
 
2671
                }
 
2672
            }
 
2673
        } else {
 
2674
            memset_val(l, (128 << (bpp - 8)) + 1, 4 << tx);
 
2675
        }
 
2676
    }
 
2677
 
 
2678
    return mode;
 
2679
}
 
2680
 
 
2681
static av_always_inline void intra_recon(AVCodecContext *ctx, ptrdiff_t y_off,
 
2682
                                         ptrdiff_t uv_off, int bytesperpixel)
 
2683
{
 
2684
    VP9Context *s = ctx->priv_data;
 
2685
    VP9Block *b = s->b;
 
2686
    int row = s->row, col = s->col;
 
2687
    int w4 = bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
 
2688
    int h4 = bwh_tab[1][b->bs][1] << 1, x, y, step = 1 << (b->tx * 2);
 
2689
    int end_x = FFMIN(2 * (s->cols - col), w4);
 
2690
    int end_y = FFMIN(2 * (s->rows - row), h4);
 
2691
    int tx = 4 * s->lossless + b->tx, uvtx = b->uvtx + 4 * s->lossless;
 
2692
    int uvstep1d = 1 << b->uvtx, p;
 
2693
    uint8_t *dst = s->dst[0], *dst_r = s->frames[CUR_FRAME].tf.f->data[0] + y_off;
 
2694
    LOCAL_ALIGNED_32(uint8_t, a_buf, [96]);
 
2695
    LOCAL_ALIGNED_32(uint8_t, l, [64]);
 
2696
 
 
2697
    for (n = 0, y = 0; y < end_y; y += step1d) {
 
2698
        uint8_t *ptr = dst, *ptr_r = dst_r;
 
2699
        for (x = 0; x < end_x; x += step1d, ptr += 4 * step1d * bytesperpixel,
 
2700
                               ptr_r += 4 * step1d * bytesperpixel, n += step) {
 
2701
            int mode = b->mode[b->bs > BS_8x8 && b->tx == TX_4X4 ?
 
2702
                               y * 2 + x : 0];
 
2703
            uint8_t *a = &a_buf[32];
 
2704
            enum TxfmType txtp = vp9_intra_txfm_type[mode];
 
2705
            int eob = b->skip ? 0 : b->tx > TX_8X8 ? AV_RN16A(&s->eob[n]) : s->eob[n];
 
2706
 
 
2707
            mode = check_intra_mode(s, mode, &a, ptr_r,
 
2708
                                    s->frames[CUR_FRAME].tf.f->linesize[0],
 
2709
                                    ptr, s->y_stride, l,
 
2710
                                    col, x, w4, row, y, b->tx, 0, 0, 0, bytesperpixel);
 
2711
            s->dsp.intra_pred[b->tx][mode](ptr, s->y_stride, l, a);
 
2712
            if (eob)
 
2713
                s->dsp.itxfm_add[tx][txtp](ptr, s->y_stride,
 
2714
                                           s->block + 16 * n * bytesperpixel, eob);
 
2715
        }
 
2716
        dst_r += 4 * step1d * s->frames[CUR_FRAME].tf.f->linesize[0];
 
2717
        dst   += 4 * step1d * s->y_stride;
 
2718
    }
 
2719
 
 
2720
    // U/V
 
2721
    w4 >>= s->ss_h;
 
2722
    end_x >>= s->ss_h;
 
2723
    end_y >>= s->ss_v;
 
2724
    step = 1 << (b->uvtx * 2);
 
2725
    for (p = 0; p < 2; p++) {
 
2726
        dst   = s->dst[1 + p];
 
2727
        dst_r = s->frames[CUR_FRAME].tf.f->data[1 + p] + uv_off;
 
2728
        for (n = 0, y = 0; y < end_y; y += uvstep1d) {
 
2729
            uint8_t *ptr = dst, *ptr_r = dst_r;
 
2730
            for (x = 0; x < end_x; x += uvstep1d, ptr += 4 * uvstep1d * bytesperpixel,
 
2731
                                   ptr_r += 4 * uvstep1d * bytesperpixel, n += step) {
 
2732
                int mode = b->uvmode;
 
2733
                uint8_t *a = &a_buf[32];
 
2734
                int eob = b->skip ? 0 : b->uvtx > TX_8X8 ? AV_RN16A(&s->uveob[p][n]) : s->uveob[p][n];
 
2735
 
 
2736
                mode = check_intra_mode(s, mode, &a, ptr_r,
 
2737
                                        s->frames[CUR_FRAME].tf.f->linesize[1],
 
2738
                                        ptr, s->uv_stride, l, col, x, w4, row, y,
 
2739
                                        b->uvtx, p + 1, s->ss_h, s->ss_v, bytesperpixel);
 
2740
                s->dsp.intra_pred[b->uvtx][mode](ptr, s->uv_stride, l, a);
 
2741
                if (eob)
 
2742
                    s->dsp.itxfm_add[uvtx][DCT_DCT](ptr, s->uv_stride,
 
2743
                                                    s->uvblock[p] + 16 * n * bytesperpixel, eob);
 
2744
            }
 
2745
            dst_r += 4 * uvstep1d * s->frames[CUR_FRAME].tf.f->linesize[1];
 
2746
            dst   += 4 * uvstep1d * s->uv_stride;
 
2747
        }
 
2748
    }
 
2749
}
 
2750
 
 
2751
static void intra_recon_8bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
 
2752
{
 
2753
    intra_recon(ctx, y_off, uv_off, 1);
 
2754
}
 
2755
 
 
2756
static void intra_recon_16bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
 
2757
{
 
2758
    intra_recon(ctx, y_off, uv_off, 2);
 
2759
}
 
2760
 
 
2761
static av_always_inline void mc_luma_scaled(VP9Context *s, vp9_scaled_mc_func smc,
 
2762
                                            uint8_t *dst, ptrdiff_t dst_stride,
 
2763
                                            const uint8_t *ref, ptrdiff_t ref_stride,
 
2764
                                            ThreadFrame *ref_frame,
 
2765
                                            ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv,
 
2766
                                            int px, int py, int pw, int ph,
 
2767
                                            int bw, int bh, int w, int h, int bytesperpixel,
 
2768
                                            const uint16_t *scale, const uint8_t *step)
 
2769
{
 
2770
#define scale_mv(n, dim) (((int64_t)(n) * scale[dim]) >> 14)
 
2771
    int mx, my;
 
2772
    int refbw_m1, refbh_m1;
 
2773
    int th;
 
2774
    VP56mv mv;
 
2775
 
 
2776
    mv.x = av_clip(in_mv->x, -(x + pw - px + 4) << 3, (s->cols * 8 - x + px + 3) << 3);
 
2777
    mv.y = av_clip(in_mv->y, -(y + ph - py + 4) << 3, (s->rows * 8 - y + py + 3) << 3);
 
2778
    // BUG libvpx seems to scale the two components separately. This introduces
 
2779
    // rounding errors but we have to reproduce them to be exactly compatible
 
2780
    // with the output from libvpx...
 
2781
    mx = scale_mv(mv.x * 2, 0) + scale_mv(x * 16, 0);
 
2782
    my = scale_mv(mv.y * 2, 1) + scale_mv(y * 16, 1);
 
2783
 
 
2784
    y = my >> 4;
 
2785
    x = mx >> 4;
 
2786
    ref += y * ref_stride + x * bytesperpixel;
 
2787
    mx &= 15;
 
2788
    my &= 15;
 
2789
    refbw_m1 = ((bw - 1) * step[0] + mx) >> 4;
 
2790
    refbh_m1 = ((bh - 1) * step[1] + my) >> 4;
 
2791
    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
 
2792
    // we use +7 because the last 7 pixels of each sbrow can be changed in
 
2793
    // the longest loopfilter of the next sbrow
 
2794
    th = (y + refbh_m1 + 4 + 7) >> 6;
 
2795
    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
 
2796
    if (x < 3 || y < 3 || x + 4 >= w - refbw_m1 || y + 4 >= h - refbh_m1) {
 
2797
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
 
2798
                                 ref - 3 * ref_stride - 3 * bytesperpixel,
 
2799
                                 288, ref_stride,
 
2800
                                 refbw_m1 + 8, refbh_m1 + 8,
 
2801
                                 x - 3, y - 3, w, h);
 
2802
        ref = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
 
2803
        ref_stride = 288;
 
2804
    }
 
2805
    smc(dst, dst_stride, ref, ref_stride, bh, mx, my, step[0], step[1]);
 
2806
}
 
2807
 
 
2808
static av_always_inline void mc_chroma_scaled(VP9Context *s, vp9_scaled_mc_func smc,
 
2809
                                              uint8_t *dst_u, uint8_t *dst_v,
 
2810
                                              ptrdiff_t dst_stride,
 
2811
                                              const uint8_t *ref_u, ptrdiff_t src_stride_u,
 
2812
                                              const uint8_t *ref_v, ptrdiff_t src_stride_v,
 
2813
                                              ThreadFrame *ref_frame,
 
2814
                                              ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv,
 
2815
                                              int px, int py, int pw, int ph,
 
2816
                                              int bw, int bh, int w, int h, int bytesperpixel,
 
2817
                                              const uint16_t *scale, const uint8_t *step)
 
2818
{
 
2819
    int mx, my;
 
2820
    int refbw_m1, refbh_m1;
 
2821
    int th;
 
2822
    VP56mv mv;
 
2823
 
 
2824
    if (s->ss_h) {
 
2825
        // BUG https://code.google.com/p/webm/issues/detail?id=820
 
2826
        mv.x = av_clip(in_mv->x, -(x + pw - px + 4) << 4, (s->cols * 4 - x + px + 3) << 4);
 
2827
        mx = scale_mv(mv.x, 0) + (scale_mv(x * 16, 0) & ~15) + (scale_mv(x * 32, 0) & 15);
 
2828
    } else {
 
2829
        mv.x = av_clip(in_mv->x, -(x + pw - px + 4) << 3, (s->cols * 8 - x + px + 3) << 3);
 
2830
        mx = scale_mv(mv.x << 1, 0) + scale_mv(x * 16, 0);
 
2831
    }
 
2832
    if (s->ss_v) {
 
2833
        // BUG https://code.google.com/p/webm/issues/detail?id=820
 
2834
        mv.y = av_clip(in_mv->y, -(y + ph - py + 4) << 4, (s->rows * 4 - y + py + 3) << 4);
 
2835
        my = scale_mv(mv.y, 1) + (scale_mv(y * 16, 1) & ~15) + (scale_mv(y * 32, 1) & 15);
 
2836
    } else {
 
2837
        mv.y = av_clip(in_mv->y, -(y + ph - py + 4) << 3, (s->rows * 8 - y + py + 3) << 3);
 
2838
        my = scale_mv(mv.y << 1, 1) + scale_mv(y * 16, 1);
 
2839
    }
 
2840
#undef scale_mv
 
2841
    y = my >> 4;
 
2842
    x = mx >> 4;
 
2843
    ref_u += y * src_stride_u + x * bytesperpixel;
 
2844
    ref_v += y * src_stride_v + x * bytesperpixel;
 
2845
    mx &= 15;
 
2846
    my &= 15;
 
2847
    refbw_m1 = ((bw - 1) * step[0] + mx) >> 4;
 
2848
    refbh_m1 = ((bh - 1) * step[1] + my) >> 4;
 
2849
    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
 
2850
    // we use +7 because the last 7 pixels of each sbrow can be changed in
 
2851
    // the longest loopfilter of the next sbrow
 
2852
    th = (y + refbh_m1 + 4 + 7) >> (6 - s->ss_v);
 
2853
    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
 
2854
    if (x < 3 || y < 3 || x + 4 >= w - refbw_m1 || y + 4 >= h - refbh_m1) {
 
2855
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
 
2856
                                 ref_u - 3 * src_stride_u - 3 * bytesperpixel,
 
2857
                                 288, src_stride_u,
 
2858
                                 refbw_m1 + 8, refbh_m1 + 8,
 
2859
                                 x - 3, y - 3, w, h);
 
2860
        ref_u = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
 
2861
        smc(dst_u, dst_stride, ref_u, 288, bh, mx, my, step[0], step[1]);
 
2862
 
 
2863
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
 
2864
                                 ref_v - 3 * src_stride_v - 3 * bytesperpixel,
 
2865
                                 288, src_stride_v,
 
2866
                                 refbw_m1 + 8, refbh_m1 + 8,
 
2867
                                 x - 3, y - 3, w, h);
 
2868
        ref_v = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
 
2869
        smc(dst_v, dst_stride, ref_v, 288, bh, mx, my, step[0], step[1]);
 
2870
    } else {
 
2871
        smc(dst_u, dst_stride, ref_u, src_stride_u, bh, mx, my, step[0], step[1]);
 
2872
        smc(dst_v, dst_stride, ref_v, src_stride_v, bh, mx, my, step[0], step[1]);
 
2873
    }
 
2874
}
 
2875
 
 
2876
#define mc_luma_dir(s, mc, dst, dst_ls, src, src_ls, tref, row, col, mv, \
 
2877
                    px, py, pw, ph, bw, bh, w, h, i) \
 
2878
    mc_luma_scaled(s, s->dsp.s##mc, dst, dst_ls, src, src_ls, tref, row, col, \
 
2879
                   mv, px, py, pw, ph, bw, bh, w, h, bytesperpixel, \
 
2880
                   s->mvscale[b->ref[i]], s->mvstep[b->ref[i]])
 
2881
#define mc_chroma_dir(s, mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
 
2882
                      row, col, mv, px, py, pw, ph, bw, bh, w, h, i) \
 
2883
    mc_chroma_scaled(s, s->dsp.s##mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
 
2884
                     row, col, mv, px, py, pw, ph, bw, bh, w, h, bytesperpixel, \
 
2885
                     s->mvscale[b->ref[i]], s->mvstep[b->ref[i]])
 
2886
#define SCALED 1
 
2887
#define FN(x) x##_scaled_8bpp
 
2888
#define BYTES_PER_PIXEL 1
 
2889
#include "vp9_mc_template.c"
 
2890
#undef FN
 
2891
#undef BYTES_PER_PIXEL
 
2892
#define FN(x) x##_scaled_16bpp
 
2893
#define BYTES_PER_PIXEL 2
 
2894
#include "vp9_mc_template.c"
 
2895
#undef mc_luma_dir
 
2896
#undef mc_chroma_dir
 
2897
#undef FN
 
2898
#undef BYTES_PER_PIXEL
 
2899
#undef SCALED
 
2900
 
 
2901
static av_always_inline void mc_luma_unscaled(VP9Context *s, vp9_mc_func (*mc)[2],
 
2902
                                              uint8_t *dst, ptrdiff_t dst_stride,
 
2903
                                              const uint8_t *ref, ptrdiff_t ref_stride,
 
2904
                                              ThreadFrame *ref_frame,
 
2905
                                              ptrdiff_t y, ptrdiff_t x, const VP56mv *mv,
 
2906
                                              int bw, int bh, int w, int h, int bytesperpixel)
 
2907
{
 
2908
    int mx = mv->x, my = mv->y, th;
 
2909
 
 
2910
    y += my >> 3;
 
2911
    x += mx >> 3;
 
2912
    ref += y * ref_stride + x * bytesperpixel;
 
2913
    mx &= 7;
 
2914
    my &= 7;
 
2915
    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
 
2916
    // we use +7 because the last 7 pixels of each sbrow can be changed in
 
2917
    // the longest loopfilter of the next sbrow
 
2918
    th = (y + bh + 4 * !!my + 7) >> 6;
 
2919
    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
 
2920
    if (x < !!mx * 3 || y < !!my * 3 ||
 
2921
        x + !!mx * 4 > w - bw || y + !!my * 4 > h - bh) {
 
2922
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
 
2923
                                 ref - !!my * 3 * ref_stride - !!mx * 3 * bytesperpixel,
 
2924
                                 160, ref_stride,
 
2925
                                 bw + !!mx * 7, bh + !!my * 7,
 
2926
                                 x - !!mx * 3, y - !!my * 3, w, h);
 
2927
        ref = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
 
2928
        ref_stride = 160;
 
2929
    }
 
2930
    mc[!!mx][!!my](dst, dst_stride, ref, ref_stride, bh, mx << 1, my << 1);
 
2931
}
 
2932
 
 
2933
static av_always_inline void mc_chroma_unscaled(VP9Context *s, vp9_mc_func (*mc)[2],
 
2934
                                                uint8_t *dst_u, uint8_t *dst_v,
 
2935
                                                ptrdiff_t dst_stride,
 
2936
                                                const uint8_t *ref_u, ptrdiff_t src_stride_u,
 
2937
                                                const uint8_t *ref_v, ptrdiff_t src_stride_v,
 
2938
                                                ThreadFrame *ref_frame,
 
2939
                                                ptrdiff_t y, ptrdiff_t x, const VP56mv *mv,
 
2940
                                                int bw, int bh, int w, int h, int bytesperpixel)
 
2941
{
 
2942
    int mx = mv->x << !s->ss_h, my = mv->y << !s->ss_v, th;
 
2943
 
 
2944
    y += my >> 4;
 
2945
    x += mx >> 4;
 
2946
    ref_u += y * src_stride_u + x * bytesperpixel;
 
2947
    ref_v += y * src_stride_v + x * bytesperpixel;
 
2948
    mx &= 15;
 
2949
    my &= 15;
 
2950
    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
 
2951
    // we use +7 because the last 7 pixels of each sbrow can be changed in
 
2952
    // the longest loopfilter of the next sbrow
 
2953
    th = (y + bh + 4 * !!my + 7) >> (6 - s->ss_v);
 
2954
    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
 
2955
    if (x < !!mx * 3 || y < !!my * 3 ||
 
2956
        x + !!mx * 4 > w - bw || y + !!my * 4 > h - bh) {
 
2957
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
 
2958
                                 ref_u - !!my * 3 * src_stride_u - !!mx * 3 * bytesperpixel,
 
2959
                                 160, src_stride_u,
 
2960
                                 bw + !!mx * 7, bh + !!my * 7,
 
2961
                                 x - !!mx * 3, y - !!my * 3, w, h);
 
2962
        ref_u = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
 
2963
        mc[!!mx][!!my](dst_u, dst_stride, ref_u, 160, bh, mx, my);
 
2964
 
 
2965
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
 
2966
                                 ref_v - !!my * 3 * src_stride_v - !!mx * 3 * bytesperpixel,
 
2967
                                 160, src_stride_v,
 
2968
                                 bw + !!mx * 7, bh + !!my * 7,
 
2969
                                 x - !!mx * 3, y - !!my * 3, w, h);
 
2970
        ref_v = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
 
2971
        mc[!!mx][!!my](dst_v, dst_stride, ref_v, 160, bh, mx, my);
 
2972
    } else {
 
2973
        mc[!!mx][!!my](dst_u, dst_stride, ref_u, src_stride_u, bh, mx, my);
 
2974
        mc[!!mx][!!my](dst_v, dst_stride, ref_v, src_stride_v, bh, mx, my);
 
2975
    }
 
2976
}
 
2977
 
 
2978
#define mc_luma_dir(s, mc, dst, dst_ls, src, src_ls, tref, row, col, mv, \
 
2979
                    px, py, pw, ph, bw, bh, w, h, i) \
 
2980
    mc_luma_unscaled(s, s->dsp.mc, dst, dst_ls, src, src_ls, tref, row, col, \
 
2981
                     mv, bw, bh, w, h, bytesperpixel)
 
2982
#define mc_chroma_dir(s, mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
 
2983
                      row, col, mv, px, py, pw, ph, bw, bh, w, h, i) \
 
2984
    mc_chroma_unscaled(s, s->dsp.mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
 
2985
                       row, col, mv, bw, bh, w, h, bytesperpixel)
 
2986
#define SCALED 0
 
2987
#define FN(x) x##_8bpp
 
2988
#define BYTES_PER_PIXEL 1
 
2989
#include "vp9_mc_template.c"
 
2990
#undef FN
 
2991
#undef BYTES_PER_PIXEL
 
2992
#define FN(x) x##_16bpp
 
2993
#define BYTES_PER_PIXEL 2
 
2994
#include "vp9_mc_template.c"
 
2995
#undef mc_luma_dir_dir
 
2996
#undef mc_chroma_dir_dir
 
2997
#undef FN
 
2998
#undef BYTES_PER_PIXEL
 
2999
#undef SCALED
 
3000
 
 
3001
static av_always_inline void inter_recon(AVCodecContext *ctx, int bytesperpixel)
 
3002
{
 
3003
    VP9Context *s = ctx->priv_data;
 
3004
    VP9Block *b = s->b;
 
3005
    int row = s->row, col = s->col;
 
3006
 
 
3007
    if (s->mvscale[b->ref[0]][0] || (b->comp && s->mvscale[b->ref[1]][0])) {
 
3008
        if (bytesperpixel == 1) {
 
3009
            inter_pred_scaled_8bpp(ctx);
 
3010
        } else {
 
3011
            inter_pred_scaled_16bpp(ctx);
 
3012
        }
 
3013
    } else {
 
3014
        if (bytesperpixel == 1) {
 
3015
            inter_pred_8bpp(ctx);
 
3016
        } else {
 
3017
            inter_pred_16bpp(ctx);
 
3018
        }
 
3019
    }
 
3020
    if (!b->skip) {
 
3021
        /* mostly copied intra_recon() */
 
3022
 
 
3023
        int w4 = bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
 
3024
        int h4 = bwh_tab[1][b->bs][1] << 1, x, y, step = 1 << (b->tx * 2);
 
3025
        int end_x = FFMIN(2 * (s->cols - col), w4);
 
3026
        int end_y = FFMIN(2 * (s->rows - row), h4);
 
3027
        int tx = 4 * s->lossless + b->tx, uvtx = b->uvtx + 4 * s->lossless;
 
3028
        int uvstep1d = 1 << b->uvtx, p;
 
3029
        uint8_t *dst = s->dst[0];
 
3030
 
 
3031
        // y itxfm add
 
3032
        for (n = 0, y = 0; y < end_y; y += step1d) {
 
3033
            uint8_t *ptr = dst;
 
3034
            for (x = 0; x < end_x; x += step1d,
 
3035
                 ptr += 4 * step1d * bytesperpixel, n += step) {
 
3036
                int eob = b->tx > TX_8X8 ? AV_RN16A(&s->eob[n]) : s->eob[n];
 
3037
 
 
3038
                if (eob)
 
3039
                    s->dsp.itxfm_add[tx][DCT_DCT](ptr, s->y_stride,
 
3040
                                                  s->block + 16 * n * bytesperpixel, eob);
 
3041
            }
 
3042
            dst += 4 * s->y_stride * step1d;
 
3043
        }
 
3044
 
 
3045
        // uv itxfm add
 
3046
        end_x >>= s->ss_h;
 
3047
        end_y >>= s->ss_v;
 
3048
        step = 1 << (b->uvtx * 2);
 
3049
        for (p = 0; p < 2; p++) {
 
3050
            dst = s->dst[p + 1];
 
3051
            for (n = 0, y = 0; y < end_y; y += uvstep1d) {
 
3052
                uint8_t *ptr = dst;
 
3053
                for (x = 0; x < end_x; x += uvstep1d,
 
3054
                     ptr += 4 * uvstep1d * bytesperpixel, n += step) {
 
3055
                    int eob = b->uvtx > TX_8X8 ? AV_RN16A(&s->uveob[p][n]) : s->uveob[p][n];
 
3056
 
 
3057
                    if (eob)
 
3058
                        s->dsp.itxfm_add[uvtx][DCT_DCT](ptr, s->uv_stride,
 
3059
                                                        s->uvblock[p] + 16 * n * bytesperpixel, eob);
 
3060
                }
 
3061
                dst += 4 * uvstep1d * s->uv_stride;
 
3062
            }
 
3063
        }
 
3064
    }
 
3065
}
 
3066
 
 
3067
static void inter_recon_8bpp(AVCodecContext *ctx)
 
3068
{
 
3069
    inter_recon(ctx, 1);
 
3070
}
 
3071
 
 
3072
static void inter_recon_16bpp(AVCodecContext *ctx)
 
3073
{
 
3074
    inter_recon(ctx, 2);
 
3075
}
 
3076
 
 
3077
static av_always_inline void mask_edges(uint8_t (*mask)[8][4], int ss_h, int ss_v,
 
3078
                                        int row_and_7, int col_and_7,
 
3079
                                        int w, int h, int col_end, int row_end,
 
3080
                                        enum TxfmMode tx, int skip_inter)
 
3081
{
 
3082
    static const unsigned wide_filter_col_mask[2] = { 0x11, 0x01 };
 
3083
    static const unsigned wide_filter_row_mask[2] = { 0x03, 0x07 };
 
3084
 
 
3085
    // FIXME I'm pretty sure all loops can be replaced by a single LUT if
 
3086
    // we make VP9Filter.mask uint64_t (i.e. row/col all single variable)
 
3087
    // and make the LUT 5-indexed (bl, bp, is_uv, tx and row/col), and then
 
3088
    // use row_and_7/col_and_7 as shifts (1*col_and_7+8*row_and_7)
 
3089
 
 
3090
    // the intended behaviour of the vp9 loopfilter is to work on 8-pixel
 
3091
    // edges. This means that for UV, we work on two subsampled blocks at
 
3092
    // a time, and we only use the topleft block's mode information to set
 
3093
    // things like block strength. Thus, for any block size smaller than
 
3094
    // 16x16, ignore the odd portion of the block.
 
3095
    if (tx == TX_4X4 && (ss_v | ss_h)) {
 
3096
        if (h == ss_v) {
 
3097
            if (row_and_7 & 1)
 
3098
                return;
 
3099
            if (!row_end)
 
3100
                h += 1;
 
3101
        }
 
3102
        if (w == ss_h) {
 
3103
            if (col_and_7 & 1)
 
3104
                return;
 
3105
            if (!col_end)
 
3106
                w += 1;
 
3107
        }
 
3108
    }
 
3109
 
 
3110
    if (tx == TX_4X4 && !skip_inter) {
 
3111
        int t = 1 << col_and_7, m_col = (t << w) - t, y;
 
3112
        // on 32-px edges, use the 8-px wide loopfilter; else, use 4-px wide
 
3113
        int m_row_8 = m_col & wide_filter_col_mask[ss_h], m_row_4 = m_col - m_row_8;
 
3114
 
 
3115
        for (y = row_and_7; y < h + row_and_7; y++) {
 
3116
            int col_mask_id = 2 - !(y & wide_filter_row_mask[ss_v]);
 
3117
 
 
3118
            mask[0][y][1] |= m_row_8;
 
3119
            mask[0][y][2] |= m_row_4;
 
3120
            // for odd lines, if the odd col is not being filtered,
 
3121
            // skip odd row also:
 
3122
            // .---. <-- a
 
3123
            // |   |
 
3124
            // |___| <-- b
 
3125
            // ^   ^
 
3126
            // c   d
 
3127
            //
 
3128
            // if a/c are even row/col and b/d are odd, and d is skipped,
 
3129
            // e.g. right edge of size-66x66.webm, then skip b also (bug)
 
3130
            if ((ss_h & ss_v) && (col_end & 1) && (y & 1)) {
 
3131
                mask[1][y][col_mask_id] |= (t << (w - 1)) - t;
 
3132
            } else {
 
3133
                mask[1][y][col_mask_id] |= m_col;
 
3134
            }
 
3135
            if (!ss_h)
 
3136
                mask[0][y][3] |= m_col;
 
3137
            if (!ss_v) {
 
3138
                if (ss_h && (col_end & 1))
 
3139
                    mask[1][y][3] |= (t << (w - 1)) - t;
 
3140
                else
 
3141
                    mask[1][y][3] |= m_col;
 
3142
            }
 
3143
        }
 
3144
    } else {
 
3145
        int y, t = 1 << col_and_7, m_col = (t << w) - t;
 
3146
 
 
3147
        if (!skip_inter) {
 
3148
            int mask_id = (tx == TX_8X8);
 
3149
            static const unsigned masks[4] = { 0xff, 0x55, 0x11, 0x01 };
 
3150
            int l2 = tx + ss_h - 1, step1d;
 
3151
            int m_row = m_col & masks[l2];
 
3152
 
 
3153
            // at odd UV col/row edges tx16/tx32 loopfilter edges, force
 
3154
            // 8wd loopfilter to prevent going off the visible edge.
 
3155
            if (ss_h && tx > TX_8X8 && (w ^ (w - 1)) == 1) {
 
3156
                int m_row_16 = ((t << (w - 1)) - t) & masks[l2];
 
3157
                int m_row_8 = m_row - m_row_16;
 
3158
 
 
3159
                for (y = row_and_7; y < h + row_and_7; y++) {
 
3160
                    mask[0][y][0] |= m_row_16;
 
3161
                    mask[0][y][1] |= m_row_8;
 
3162
                }
 
3163
            } else {
 
3164
                for (y = row_and_7; y < h + row_and_7; y++)
 
3165
                    mask[0][y][mask_id] |= m_row;
 
3166
            }
 
3167
 
 
3168
            l2 = tx + ss_v - 1;
 
3169
            step1d = 1 << l2;
 
3170
            if (ss_v && tx > TX_8X8 && (h ^ (h - 1)) == 1) {
 
3171
                for (y = row_and_7; y < h + row_and_7 - 1; y += step1d)
 
3172
                    mask[1][y][0] |= m_col;
 
3173
                if (y - row_and_7 == h - 1)
 
3174
                    mask[1][y][1] |= m_col;
 
3175
            } else {
 
3176
                for (y = row_and_7; y < h + row_and_7; y += step1d)
 
3177
                    mask[1][y][mask_id] |= m_col;
 
3178
            }
 
3179
        } else if (tx != TX_4X4) {
 
3180
            int mask_id;
 
3181
 
 
3182
            mask_id = (tx == TX_8X8) || (h == ss_v);
 
3183
            mask[1][row_and_7][mask_id] |= m_col;
 
3184
            mask_id = (tx == TX_8X8) || (w == ss_h);
 
3185
            for (y = row_and_7; y < h + row_and_7; y++)
 
3186
                mask[0][y][mask_id] |= t;
 
3187
        } else {
 
3188
            int t8 = t & wide_filter_col_mask[ss_h], t4 = t - t8;
 
3189
 
 
3190
            for (y = row_and_7; y < h + row_and_7; y++) {
 
3191
                mask[0][y][2] |= t4;
 
3192
                mask[0][y][1] |= t8;
 
3193
            }
 
3194
            mask[1][row_and_7][2 - !(row_and_7 & wide_filter_row_mask[ss_v])] |= m_col;
 
3195
        }
 
3196
    }
 
3197
}
 
3198
 
 
3199
static void decode_b(AVCodecContext *ctx, int row, int col,
 
3200
                     struct VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff,
 
3201
                     enum BlockLevel bl, enum BlockPartition bp)
 
3202
{
 
3203
    VP9Context *s = ctx->priv_data;
 
3204
    VP9Block *b = s->b;
 
3205
    enum BlockSize bs = bl * 3 + bp;
 
3206
    int bytesperpixel = s->bytesperpixel;
 
3207
    int w4 = bwh_tab[1][bs][0], h4 = bwh_tab[1][bs][1], lvl;
 
3208
    int emu[2];
 
3209
    AVFrame *f = s->frames[CUR_FRAME].tf.f;
 
3210
 
 
3211
    s->row = row;
 
3212
    s->row7 = row & 7;
 
3213
    s->col = col;
 
3214
    s->col7 = col & 7;
 
3215
    s->min_mv.x = -(128 + col * 64);
 
3216
    s->min_mv.y = -(128 + row * 64);
 
3217
    s->max_mv.x = 128 + (s->cols - col - w4) * 64;
 
3218
    s->max_mv.y = 128 + (s->rows - row - h4) * 64;
 
3219
    if (s->pass < 2) {
 
3220
        b->bs = bs;
 
3221
        b->bl = bl;
 
3222
        b->bp = bp;
 
3223
        decode_mode(ctx);
 
3224
        b->uvtx = b->tx - ((s->ss_h && w4 * 2 == (1 << b->tx)) ||
 
3225
                           (s->ss_v && h4 * 2 == (1 << b->tx)));
 
3226
 
 
3227
        if (!b->skip) {
 
3228
            int has_coeffs;
 
3229
 
 
3230
            if (bytesperpixel == 1) {
 
3231
                has_coeffs = decode_coeffs_8bpp(ctx);
 
3232
            } else {
 
3233
                has_coeffs = decode_coeffs_16bpp(ctx);
 
3234
            }
 
3235
            if (!has_coeffs && b->bs <= BS_8x8 && !b->intra) {
 
3236
                b->skip = 1;
 
3237
                memset(&s->above_skip_ctx[col], 1, w4);
 
3238
                memset(&s->left_skip_ctx[s->row7], 1, h4);
 
3239
            }
 
3240
        } else {
 
3241
            int row7 = s->row7;
 
3242
 
 
3243
#define SPLAT_ZERO_CTX(v, n) \
 
3244
    switch (n) { \
 
3245
    case 1:  v = 0;          break; \
 
3246
    case 2:  AV_ZERO16(&v);  break; \
 
3247
    case 4:  AV_ZERO32(&v);  break; \
 
3248
    case 8:  AV_ZERO64(&v);  break; \
 
3249
    case 16: AV_ZERO128(&v); break; \
 
3250
    }
 
3251
#define SPLAT_ZERO_YUV(dir, var, off, n, dir2) \
 
3252
    do { \
 
3253
        SPLAT_ZERO_CTX(s->dir##_y_##var[off * 2], n * 2); \
 
3254
        if (s->ss_##dir2) { \
 
3255
            SPLAT_ZERO_CTX(s->dir##_uv_##var[0][off], n); \
 
3256
            SPLAT_ZERO_CTX(s->dir##_uv_##var[1][off], n); \
 
3257
        } else { \
 
3258
            SPLAT_ZERO_CTX(s->dir##_uv_##var[0][off * 2], n * 2); \
 
3259
            SPLAT_ZERO_CTX(s->dir##_uv_##var[1][off * 2], n * 2); \
 
3260
        } \
 
3261
    } while (0)
 
3262
 
 
3263
            switch (w4) {
 
3264
            case 1: SPLAT_ZERO_YUV(above, nnz_ctx, col, 1, h); break;
 
3265
            case 2: SPLAT_ZERO_YUV(above, nnz_ctx, col, 2, h); break;
 
3266
            case 4: SPLAT_ZERO_YUV(above, nnz_ctx, col, 4, h); break;
 
3267
            case 8: SPLAT_ZERO_YUV(above, nnz_ctx, col, 8, h); break;
 
3268
            }
 
3269
            switch (h4) {
 
3270
            case 1: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 1, v); break;
 
3271
            case 2: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 2, v); break;
 
3272
            case 4: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 4, v); break;
 
3273
            case 8: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 8, v); break;
 
3274
            }
 
3275
        }
 
3276
        if (s->pass == 1) {
 
3277
            s->b++;
 
3278
            s->block += w4 * h4 * 64 * bytesperpixel;
 
3279
            s->uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v);
 
3280
            s->uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v);
 
3281
            s->eob += 4 * w4 * h4;
 
3282
            s->uveob[0] += 4 * w4 * h4 >> (s->ss_h + s->ss_v);
 
3283
            s->uveob[1] += 4 * w4 * h4 >> (s->ss_h + s->ss_v);
 
3284
 
 
3285
            return;
 
3286
        }
 
3287
    }
 
3288
 
 
3289
    // emulated overhangs if the stride of the target buffer can't hold. This
 
3290
    // makes it possible to support emu-edge and so on even if we have large block
 
3291
    // overhangs
 
3292
    emu[0] = (col + w4) * 8 > f->linesize[0] ||
 
3293
             (row + h4) > s->rows;
 
3294
    emu[1] = (col + w4) * 4 > f->linesize[1] ||
 
3295
             (row + h4) > s->rows;
 
3296
    if (emu[0]) {
 
3297
        s->dst[0] = s->tmp_y;
 
3298
        s->y_stride = 128;
 
3299
    } else {
 
3300
        s->dst[0] = f->data[0] + yoff;
 
3301
        s->y_stride = f->linesize[0];
 
3302
    }
 
3303
    if (emu[1]) {
 
3304
        s->dst[1] = s->tmp_uv[0];
 
3305
        s->dst[2] = s->tmp_uv[1];
 
3306
        s->uv_stride = 128;
 
3307
    } else {
 
3308
        s->dst[1] = f->data[1] + uvoff;
 
3309
        s->dst[2] = f->data[2] + uvoff;
 
3310
        s->uv_stride = f->linesize[1];
 
3311
    }
 
3312
    if (b->intra) {
 
3313
        if (s->bpp > 8) {
 
3314
            intra_recon_16bpp(ctx, yoff, uvoff);
 
3315
        } else {
 
3316
            intra_recon_8bpp(ctx, yoff, uvoff);
 
3317
        }
 
3318
    } else {
 
3319
        if (s->bpp > 8) {
 
3320
            inter_recon_16bpp(ctx);
 
3321
        } else {
 
3322
            inter_recon_8bpp(ctx);
 
3323
        }
 
3324
    }
 
3325
    if (emu[0]) {
 
3326
        int w = FFMIN(s->cols - col, w4) * 8, h = FFMIN(s->rows - row, h4) * 8, n, o = 0;
 
3327
 
 
3328
        for (n = 0; o < w; n++) {
 
3329
            int bw = 64 >> n;
 
3330
 
 
3331
            av_assert2(n <= 4);
 
3332
            if (w & bw) {
 
3333
                s->dsp.mc[n][0][0][0][0](f->data[0] + yoff + o, f->linesize[0],
 
3334
                                         s->tmp_y + o, 128, h, 0, 0);
 
3335
                o += bw * bytesperpixel;
 
3336
            }
 
3337
        }
 
3338
    }
 
3339
    if (emu[1]) {
 
3340
        int w = FFMIN(s->cols - col, w4) * 8 >> s->ss_h;
 
3341
        int h = FFMIN(s->rows - row, h4) * 8 >> s->ss_v, n, o = 0;
 
3342
 
 
3343
        for (n = s->ss_h; o < w; n++) {
 
3344
            int bw = 64 >> n;
 
3345
 
 
3346
            av_assert2(n <= 4);
 
3347
            if (w & bw) {
 
3348
                s->dsp.mc[n][0][0][0][0](f->data[1] + uvoff + o, f->linesize[1],
 
3349
                                         s->tmp_uv[0] + o, 128, h, 0, 0);
 
3350
                s->dsp.mc[n][0][0][0][0](f->data[2] + uvoff + o, f->linesize[2],
 
3351
                                         s->tmp_uv[1] + o, 128, h, 0, 0);
 
3352
                o += bw * bytesperpixel;
 
3353
            }
 
3354
        }
 
3355
    }
 
3356
 
 
3357
    // pick filter level and find edges to apply filter to
 
3358
    if (s->filter.level &&
 
3359
        (lvl = s->segmentation.feat[b->seg_id].lflvl[b->intra ? 0 : b->ref[0] + 1]
 
3360
                                                    [b->mode[3] != ZEROMV]) > 0) {
 
3361
        int x_end = FFMIN(s->cols - col, w4), y_end = FFMIN(s->rows - row, h4);
 
3362
        int skip_inter = !b->intra && b->skip, col7 = s->col7, row7 = s->row7;
 
3363
 
 
3364
        setctx_2d(&lflvl->level[row7 * 8 + col7], w4, h4, 8, lvl);
 
3365
        mask_edges(lflvl->mask[0], 0, 0, row7, col7, x_end, y_end, 0, 0, b->tx, skip_inter);
 
3366
        if (s->ss_h || s->ss_v)
 
3367
            mask_edges(lflvl->mask[1], s->ss_h, s->ss_v, row7, col7, x_end, y_end,
 
3368
                       s->cols & 1 && col + w4 >= s->cols ? s->cols & 7 : 0,
 
3369
                       s->rows & 1 && row + h4 >= s->rows ? s->rows & 7 : 0,
 
3370
                       b->uvtx, skip_inter);
 
3371
 
 
3372
        if (!s->filter.lim_lut[lvl]) {
 
3373
            int sharp = s->filter.sharpness;
 
3374
            int limit = lvl;
 
3375
 
 
3376
            if (sharp > 0) {
 
3377
                limit >>= (sharp + 3) >> 2;
 
3378
                limit = FFMIN(limit, 9 - sharp);
 
3379
            }
 
3380
            limit = FFMAX(limit, 1);
 
3381
 
 
3382
            s->filter.lim_lut[lvl] = limit;
 
3383
            s->filter.mblim_lut[lvl] = 2 * (lvl + 2) + limit;
 
3384
        }
 
3385
    }
 
3386
 
 
3387
    if (s->pass == 2) {
 
3388
        s->b++;
 
3389
        s->block += w4 * h4 * 64 * bytesperpixel;
 
3390
        s->uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h);
 
3391
        s->uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h);
 
3392
        s->eob += 4 * w4 * h4;
 
3393
        s->uveob[0] += 4 * w4 * h4 >> (s->ss_v + s->ss_h);
 
3394
        s->uveob[1] += 4 * w4 * h4 >> (s->ss_v + s->ss_h);
 
3395
    }
 
3396
}
 
3397
 
 
3398
static void decode_sb(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl,
 
3399
                      ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
 
3400
{
 
3401
    VP9Context *s = ctx->priv_data;
 
3402
    int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
 
3403
            (((s->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);
 
3404
    const uint8_t *p = s->keyframe || s->intraonly ? vp9_default_kf_partition_probs[bl][c] :
 
3405
                                                     s->prob.p.partition[bl][c];
 
3406
    enum BlockPartition bp;
 
3407
    ptrdiff_t hbs = 4 >> bl;
 
3408
    AVFrame *f = s->frames[CUR_FRAME].tf.f;
 
3409
    ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
 
3410
    int bytesperpixel = s->bytesperpixel;
 
3411
 
 
3412
    if (bl == BL_8X8) {
 
3413
        bp = vp8_rac_get_tree(&s->c, vp9_partition_tree, p);
 
3414
        decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
 
3415
    } else if (col + hbs < s->cols) { // FIXME why not <=?
 
3416
        if (row + hbs < s->rows) { // FIXME why not <=?
 
3417
            bp = vp8_rac_get_tree(&s->c, vp9_partition_tree, p);
 
3418
            switch (bp) {
 
3419
            case PARTITION_NONE:
 
3420
                decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
 
3421
                break;
 
3422
            case PARTITION_H:
 
3423
                decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
 
3424
                yoff  += hbs * 8 * y_stride;
 
3425
                uvoff += hbs * 8 * uv_stride >> s->ss_v;
 
3426
                decode_b(ctx, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
 
3427
                break;
 
3428
            case PARTITION_V:
 
3429
                decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
 
3430
                yoff  += hbs * 8 * bytesperpixel;
 
3431
                uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
 
3432
                decode_b(ctx, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
 
3433
                break;
 
3434
            case PARTITION_SPLIT:
 
3435
                decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
 
3436
                decode_sb(ctx, row, col + hbs, lflvl,
 
3437
                          yoff + 8 * hbs * bytesperpixel,
 
3438
                          uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
 
3439
                yoff  += hbs * 8 * y_stride;
 
3440
                uvoff += hbs * 8 * uv_stride >> s->ss_v;
 
3441
                decode_sb(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
 
3442
                decode_sb(ctx, row + hbs, col + hbs, lflvl,
 
3443
                          yoff + 8 * hbs * bytesperpixel,
 
3444
                          uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
 
3445
                break;
 
3446
            default:
 
3447
                av_assert0(0);
 
3448
            }
 
3449
        } else if (vp56_rac_get_prob_branchy(&s->c, p[1])) {
 
3450
            bp = PARTITION_SPLIT;
 
3451
            decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
 
3452
            decode_sb(ctx, row, col + hbs, lflvl,
 
3453
                      yoff + 8 * hbs * bytesperpixel,
 
3454
                      uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
 
3455
        } else {
 
3456
            bp = PARTITION_H;
 
3457
            decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
 
3458
        }
 
3459
    } else if (row + hbs < s->rows) { // FIXME why not <=?
 
3460
        if (vp56_rac_get_prob_branchy(&s->c, p[2])) {
 
3461
            bp = PARTITION_SPLIT;
 
3462
            decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
 
3463
            yoff  += hbs * 8 * y_stride;
 
3464
            uvoff += hbs * 8 * uv_stride >> s->ss_v;
 
3465
            decode_sb(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
 
3466
        } else {
 
3467
            bp = PARTITION_V;
 
3468
            decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
 
3469
        }
 
3470
    } else {
 
3471
        bp = PARTITION_SPLIT;
 
3472
        decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
 
3473
    }
 
3474
    s->counts.partition[bl][c][bp]++;
 
3475
}
 
3476
 
 
3477
static void decode_sb_mem(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl,
 
3478
                          ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
 
3479
{
 
3480
    VP9Context *s = ctx->priv_data;
 
3481
    VP9Block *b = s->b;
 
3482
    ptrdiff_t hbs = 4 >> bl;
 
3483
    AVFrame *f = s->frames[CUR_FRAME].tf.f;
 
3484
    ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
 
3485
    int bytesperpixel = s->bytesperpixel;
 
3486
 
 
3487
    if (bl == BL_8X8) {
 
3488
        av_assert2(b->bl == BL_8X8);
 
3489
        decode_b(ctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
 
3490
    } else if (s->b->bl == bl) {
 
3491
        decode_b(ctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
 
3492
        if (b->bp == PARTITION_H && row + hbs < s->rows) {
 
3493
            yoff  += hbs * 8 * y_stride;
 
3494
            uvoff += hbs * 8 * uv_stride >> s->ss_v;
 
3495
            decode_b(ctx, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
 
3496
        } else if (b->bp == PARTITION_V && col + hbs < s->cols) {
 
3497
            yoff  += hbs * 8 * bytesperpixel;
 
3498
            uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
 
3499
            decode_b(ctx, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
 
3500
        }
 
3501
    } else {
 
3502
        decode_sb_mem(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
 
3503
        if (col + hbs < s->cols) { // FIXME why not <=?
 
3504
            if (row + hbs < s->rows) {
 
3505
                decode_sb_mem(ctx, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
 
3506
                              uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
 
3507
                yoff  += hbs * 8 * y_stride;
 
3508
                uvoff += hbs * 8 * uv_stride >> s->ss_v;
 
3509
                decode_sb_mem(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
 
3510
                decode_sb_mem(ctx, row + hbs, col + hbs, lflvl,
 
3511
                              yoff + 8 * hbs * bytesperpixel,
 
3512
                              uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
 
3513
            } else {
 
3514
                yoff  += hbs * 8 * bytesperpixel;
 
3515
                uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
 
3516
                decode_sb_mem(ctx, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
 
3517
            }
 
3518
        } else if (row + hbs < s->rows) {
 
3519
            yoff  += hbs * 8 * y_stride;
 
3520
            uvoff += hbs * 8 * uv_stride >> s->ss_v;
 
3521
            decode_sb_mem(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
 
3522
        }
 
3523
    }
 
3524
}
 
3525
 
 
3526
static av_always_inline void filter_plane_cols(VP9Context *s, int col, int ss_h, int ss_v,
 
3527
                                               uint8_t *lvl, uint8_t (*mask)[4],
 
3528
                                               uint8_t *dst, ptrdiff_t ls)
 
3529
{
 
3530
    int y, x, bytesperpixel = s->bytesperpixel;
 
3531
 
 
3532
    // filter edges between columns (e.g. block1 | block2)
 
3533
    for (y = 0; y < 8; y += 2 << ss_v, dst += 16 * ls, lvl += 16 << ss_v) {
 
3534
        uint8_t *ptr = dst, *l = lvl, *hmask1 = mask[y], *hmask2 = mask[y + 1 + ss_v];
 
3535
        unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2], hm13 = hmask1[3];
 
3536
        unsigned hm2 = hmask2[1] | hmask2[2], hm23 = hmask2[3];
 
3537
        unsigned hm = hm1 | hm2 | hm13 | hm23;
 
3538
 
 
3539
        for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 8 * bytesperpixel >> ss_h) {
 
3540
            if (col || x > 1) {
 
3541
                if (hm1 & x) {
 
3542
                    int L = *l, H = L >> 4;
 
3543
                    int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
 
3544
 
 
3545
                    if (hmask1[0] & x) {
 
3546
                        if (hmask2[0] & x) {
 
3547
                            av_assert2(l[8 << ss_v] == L);
 
3548
                            s->dsp.loop_filter_16[0](ptr, ls, E, I, H);
 
3549
                        } else {
 
3550
                            s->dsp.loop_filter_8[2][0](ptr, ls, E, I, H);
 
3551
                        }
 
3552
                    } else if (hm2 & x) {
 
3553
                        L = l[8 << ss_v];
 
3554
                        H |= (L >> 4) << 8;
 
3555
                        E |= s->filter.mblim_lut[L] << 8;
 
3556
                        I |= s->filter.lim_lut[L] << 8;
 
3557
                        s->dsp.loop_filter_mix2[!!(hmask1[1] & x)]
 
3558
                                               [!!(hmask2[1] & x)]
 
3559
                                               [0](ptr, ls, E, I, H);
 
3560
                    } else {
 
3561
                        s->dsp.loop_filter_8[!!(hmask1[1] & x)]
 
3562
                                            [0](ptr, ls, E, I, H);
 
3563
                    }
 
3564
                } else if (hm2 & x) {
 
3565
                    int L = l[8 << ss_v], H = L >> 4;
 
3566
                    int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
 
3567
 
 
3568
                    s->dsp.loop_filter_8[!!(hmask2[1] & x)]
 
3569
                                        [0](ptr + 8 * ls, ls, E, I, H);
 
3570
                }
 
3571
            }
 
3572
            if (ss_h) {
 
3573
                if (x & 0xAA)
 
3574
                    l += 2;
 
3575
            } else {
 
3576
                if (hm13 & x) {
 
3577
                    int L = *l, H = L >> 4;
 
3578
                    int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
 
3579
 
 
3580
                    if (hm23 & x) {
 
3581
                        L = l[8 << ss_v];
 
3582
                        H |= (L >> 4) << 8;
 
3583
                        E |= s->filter.mblim_lut[L] << 8;
 
3584
                        I |= s->filter.lim_lut[L] << 8;
 
3585
                        s->dsp.loop_filter_mix2[0][0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
 
3586
                    } else {
 
3587
                        s->dsp.loop_filter_8[0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
 
3588
                    }
 
3589
                } else if (hm23 & x) {
 
3590
                    int L = l[8 << ss_v], H = L >> 4;
 
3591
                    int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
 
3592
 
 
3593
                    s->dsp.loop_filter_8[0][0](ptr + 8 * ls + 4 * bytesperpixel, ls, E, I, H);
 
3594
                }
 
3595
                l++;
 
3596
            }
 
3597
        }
 
3598
    }
 
3599
}
 
3600
 
 
3601
static av_always_inline void filter_plane_rows(VP9Context *s, int row, int ss_h, int ss_v,
 
3602
                                               uint8_t *lvl, uint8_t (*mask)[4],
 
3603
                                               uint8_t *dst, ptrdiff_t ls)
 
3604
{
 
3605
    int y, x, bytesperpixel = s->bytesperpixel;
 
3606
 
 
3607
    //                                 block1
 
3608
    // filter edges between rows (e.g. ------)
 
3609
    //                                 block2
 
3610
    for (y = 0; y < 8; y++, dst += 8 * ls >> ss_v) {
 
3611
        uint8_t *ptr = dst, *l = lvl, *vmask = mask[y];
 
3612
        unsigned vm = vmask[0] | vmask[1] | vmask[2], vm3 = vmask[3];
 
3613
 
 
3614
        for (x = 1; vm & ~(x - 1); x <<= (2 << ss_h), ptr += 16 * bytesperpixel, l += 2 << ss_h) {
 
3615
            if (row || y) {
 
3616
                if (vm & x) {
 
3617
                    int L = *l, H = L >> 4;
 
3618
                    int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
 
3619
 
 
3620
                    if (vmask[0] & x) {
 
3621
                        if (vmask[0] & (x << (1 + ss_h))) {
 
3622
                            av_assert2(l[1 + ss_h] == L);
 
3623
                            s->dsp.loop_filter_16[1](ptr, ls, E, I, H);
 
3624
                        } else {
 
3625
                            s->dsp.loop_filter_8[2][1](ptr, ls, E, I, H);
 
3626
                        }
 
3627
                    } else if (vm & (x << (1 + ss_h))) {
 
3628
                        L = l[1 + ss_h];
 
3629
                        H |= (L >> 4) << 8;
 
3630
                        E |= s->filter.mblim_lut[L] << 8;
 
3631
                        I |= s->filter.lim_lut[L] << 8;
 
3632
                        s->dsp.loop_filter_mix2[!!(vmask[1] &  x)]
 
3633
                                               [!!(vmask[1] & (x << (1 + ss_h)))]
 
3634
                                               [1](ptr, ls, E, I, H);
 
3635
                    } else {
 
3636
                        s->dsp.loop_filter_8[!!(vmask[1] & x)]
 
3637
                                            [1](ptr, ls, E, I, H);
 
3638
                    }
 
3639
                } else if (vm & (x << (1 + ss_h))) {
 
3640
                    int L = l[1 + ss_h], H = L >> 4;
 
3641
                    int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
 
3642
 
 
3643
                    s->dsp.loop_filter_8[!!(vmask[1] & (x << (1 + ss_h)))]
 
3644
                                        [1](ptr + 8 * bytesperpixel, ls, E, I, H);
 
3645
                }
 
3646
            }
 
3647
            if (!ss_v) {
 
3648
                if (vm3 & x) {
 
3649
                    int L = *l, H = L >> 4;
 
3650
                    int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
 
3651
 
 
3652
                    if (vm3 & (x << (1 + ss_h))) {
 
3653
                        L = l[1 + ss_h];
 
3654
                        H |= (L >> 4) << 8;
 
3655
                        E |= s->filter.mblim_lut[L] << 8;
 
3656
                        I |= s->filter.lim_lut[L] << 8;
 
3657
                        s->dsp.loop_filter_mix2[0][0][1](ptr + ls * 4, ls, E, I, H);
 
3658
                    } else {
 
3659
                        s->dsp.loop_filter_8[0][1](ptr + ls * 4, ls, E, I, H);
 
3660
                    }
 
3661
                } else if (vm3 & (x << (1 + ss_h))) {
 
3662
                    int L = l[1 + ss_h], H = L >> 4;
 
3663
                    int E = s->filter.mblim_lut[L], I = s->filter.lim_lut[L];
 
3664
 
 
3665
                    s->dsp.loop_filter_8[0][1](ptr + ls * 4 + 8 * bytesperpixel, ls, E, I, H);
 
3666
                }
 
3667
            }
 
3668
        }
 
3669
        if (ss_v) {
 
3670
            if (y & 1)
 
3671
                lvl += 16;
 
3672
        } else {
 
3673
            lvl += 8;
 
3674
        }
 
3675
    }
 
3676
}
 
3677
 
 
3678
static void loopfilter_sb(AVCodecContext *ctx, struct VP9Filter *lflvl,
 
3679
                          int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
 
3680
{
 
3681
    VP9Context *s = ctx->priv_data;
 
3682
    AVFrame *f = s->frames[CUR_FRAME].tf.f;
 
3683
    uint8_t *dst = f->data[0] + yoff;
 
3684
    ptrdiff_t ls_y = f->linesize[0], ls_uv = f->linesize[1];
 
3685
    uint8_t (*uv_masks)[8][4] = lflvl->mask[s->ss_h | s->ss_v];
 
3686
    int p;
 
3687
 
 
3688
    // FIXME in how far can we interleave the v/h loopfilter calls? E.g.
 
3689
    // if you think of them as acting on a 8x8 block max, we can interleave
 
3690
    // each v/h within the single x loop, but that only works if we work on
 
3691
    // 8 pixel blocks, and we won't always do that (we want at least 16px
 
3692
    // to use SSE2 optimizations, perhaps 32 for AVX2)
 
3693
 
 
3694
    filter_plane_cols(s, col, 0, 0, lflvl->level, lflvl->mask[0][0], dst, ls_y);
 
3695
    filter_plane_rows(s, row, 0, 0, lflvl->level, lflvl->mask[0][1], dst, ls_y);
 
3696
 
 
3697
    for (p = 0; p < 2; p++) {
 
3698
        dst = f->data[1 + p] + uvoff;
 
3699
        filter_plane_cols(s, col, s->ss_h, s->ss_v, lflvl->level, uv_masks[0], dst, ls_uv);
 
3700
        filter_plane_rows(s, row, s->ss_h, s->ss_v, lflvl->level, uv_masks[1], dst, ls_uv);
 
3701
    }
 
3702
}
 
3703
 
 
3704
static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
 
3705
{
 
3706
    int sb_start = ( idx      * n) >> log2_n;
 
3707
    int sb_end   = ((idx + 1) * n) >> log2_n;
 
3708
    *start = FFMIN(sb_start, n) << 3;
 
3709
    *end   = FFMIN(sb_end,   n) << 3;
 
3710
}
 
3711
 
 
3712
static av_always_inline void adapt_prob(uint8_t *p, unsigned ct0, unsigned ct1,
 
3713
                                        int max_count, int update_factor)
 
3714
{
 
3715
    unsigned ct = ct0 + ct1, p2, p1;
 
3716
 
 
3717
    if (!ct)
 
3718
        return;
 
3719
 
 
3720
    p1 = *p;
 
3721
    p2 = ((ct0 << 8) + (ct >> 1)) / ct;
 
3722
    p2 = av_clip(p2, 1, 255);
 
3723
    ct = FFMIN(ct, max_count);
 
3724
    update_factor = FASTDIV(update_factor * ct, max_count);
 
3725
 
 
3726
    // (p1 * (256 - update_factor) + p2 * update_factor + 128) >> 8
 
3727
    *p = p1 + (((p2 - p1) * update_factor + 128) >> 8);
 
3728
}
 
3729
 
 
3730
static void adapt_probs(VP9Context *s)
 
3731
{
 
3732
    int i, j, k, l, m;
 
3733
    prob_context *p = &s->prob_ctx[s->framectxid].p;
 
3734
    int uf = (s->keyframe || s->intraonly || !s->last_keyframe) ? 112 : 128;
 
3735
 
 
3736
    // coefficients
 
3737
    for (i = 0; i < 4; i++)
 
3738
        for (j = 0; j < 2; j++)
 
3739
            for (k = 0; k < 2; k++)
 
3740
                for (l = 0; l < 6; l++)
 
3741
                    for (m = 0; m < 6; m++) {
 
3742
                        uint8_t *pp = s->prob_ctx[s->framectxid].coef[i][j][k][l][m];
 
3743
                        unsigned *e = s->counts.eob[i][j][k][l][m];
 
3744
                        unsigned *c = s->counts.coef[i][j][k][l][m];
 
3745
 
 
3746
                        if (l == 0 && m >= 3) // dc only has 3 pt
 
3747
                            break;
 
3748
 
 
3749
                        adapt_prob(&pp[0], e[0], e[1], 24, uf);
 
3750
                        adapt_prob(&pp[1], c[0], c[1] + c[2], 24, uf);
 
3751
                        adapt_prob(&pp[2], c[1], c[2], 24, uf);
 
3752
                    }
 
3753
 
 
3754
    if (s->keyframe || s->intraonly) {
 
3755
        memcpy(p->skip,  s->prob.p.skip,  sizeof(p->skip));
 
3756
        memcpy(p->tx32p, s->prob.p.tx32p, sizeof(p->tx32p));
 
3757
        memcpy(p->tx16p, s->prob.p.tx16p, sizeof(p->tx16p));
 
3758
        memcpy(p->tx8p,  s->prob.p.tx8p,  sizeof(p->tx8p));
 
3759
        return;
 
3760
    }
 
3761
 
 
3762
    // skip flag
 
3763
    for (i = 0; i < 3; i++)
 
3764
        adapt_prob(&p->skip[i], s->counts.skip[i][0], s->counts.skip[i][1], 20, 128);
 
3765
 
 
3766
    // intra/inter flag
 
3767
    for (i = 0; i < 4; i++)
 
3768
        adapt_prob(&p->intra[i], s->counts.intra[i][0], s->counts.intra[i][1], 20, 128);
 
3769
 
 
3770
    // comppred flag
 
3771
    if (s->comppredmode == PRED_SWITCHABLE) {
 
3772
      for (i = 0; i < 5; i++)
 
3773
          adapt_prob(&p->comp[i], s->counts.comp[i][0], s->counts.comp[i][1], 20, 128);
 
3774
    }
 
3775
 
 
3776
    // reference frames
 
3777
    if (s->comppredmode != PRED_SINGLEREF) {
 
3778
      for (i = 0; i < 5; i++)
 
3779
          adapt_prob(&p->comp_ref[i], s->counts.comp_ref[i][0],
 
3780
                     s->counts.comp_ref[i][1], 20, 128);
 
3781
    }
 
3782
 
 
3783
    if (s->comppredmode != PRED_COMPREF) {
 
3784
      for (i = 0; i < 5; i++) {
 
3785
          uint8_t *pp = p->single_ref[i];
 
3786
          unsigned (*c)[2] = s->counts.single_ref[i];
 
3787
 
 
3788
          adapt_prob(&pp[0], c[0][0], c[0][1], 20, 128);
 
3789
          adapt_prob(&pp[1], c[1][0], c[1][1], 20, 128);
 
3790
      }
 
3791
    }
 
3792
 
 
3793
    // block partitioning
 
3794
    for (i = 0; i < 4; i++)
 
3795
        for (j = 0; j < 4; j++) {
 
3796
            uint8_t *pp = p->partition[i][j];
 
3797
            unsigned *c = s->counts.partition[i][j];
 
3798
 
 
3799
            adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
 
3800
            adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
 
3801
            adapt_prob(&pp[2], c[2], c[3], 20, 128);
 
3802
        }
 
3803
 
 
3804
    // tx size
 
3805
    if (s->txfmmode == TX_SWITCHABLE) {
 
3806
      for (i = 0; i < 2; i++) {
 
3807
          unsigned *c16 = s->counts.tx16p[i], *c32 = s->counts.tx32p[i];
 
3808
 
 
3809
          adapt_prob(&p->tx8p[i], s->counts.tx8p[i][0], s->counts.tx8p[i][1], 20, 128);
 
3810
          adapt_prob(&p->tx16p[i][0], c16[0], c16[1] + c16[2], 20, 128);
 
3811
          adapt_prob(&p->tx16p[i][1], c16[1], c16[2], 20, 128);
 
3812
          adapt_prob(&p->tx32p[i][0], c32[0], c32[1] + c32[2] + c32[3], 20, 128);
 
3813
          adapt_prob(&p->tx32p[i][1], c32[1], c32[2] + c32[3], 20, 128);
 
3814
          adapt_prob(&p->tx32p[i][2], c32[2], c32[3], 20, 128);
 
3815
      }
 
3816
    }
 
3817
 
 
3818
    // interpolation filter
 
3819
    if (s->filtermode == FILTER_SWITCHABLE) {
 
3820
        for (i = 0; i < 4; i++) {
 
3821
            uint8_t *pp = p->filter[i];
 
3822
            unsigned *c = s->counts.filter[i];
 
3823
 
 
3824
            adapt_prob(&pp[0], c[0], c[1] + c[2], 20, 128);
 
3825
            adapt_prob(&pp[1], c[1], c[2], 20, 128);
 
3826
        }
 
3827
    }
 
3828
 
 
3829
    // inter modes
 
3830
    for (i = 0; i < 7; i++) {
 
3831
        uint8_t *pp = p->mv_mode[i];
 
3832
        unsigned *c = s->counts.mv_mode[i];
 
3833
 
 
3834
        adapt_prob(&pp[0], c[2], c[1] + c[0] + c[3], 20, 128);
 
3835
        adapt_prob(&pp[1], c[0], c[1] + c[3], 20, 128);
 
3836
        adapt_prob(&pp[2], c[1], c[3], 20, 128);
 
3837
    }
 
3838
 
 
3839
    // mv joints
 
3840
    {
 
3841
        uint8_t *pp = p->mv_joint;
 
3842
        unsigned *c = s->counts.mv_joint;
 
3843
 
 
3844
        adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
 
3845
        adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
 
3846
        adapt_prob(&pp[2], c[2], c[3], 20, 128);
 
3847
    }
 
3848
 
 
3849
    // mv components
 
3850
    for (i = 0; i < 2; i++) {
 
3851
        uint8_t *pp;
 
3852
        unsigned *c, (*c2)[2], sum;
 
3853
 
 
3854
        adapt_prob(&p->mv_comp[i].sign, s->counts.mv_comp[i].sign[0],
 
3855
                   s->counts.mv_comp[i].sign[1], 20, 128);
 
3856
 
 
3857
        pp = p->mv_comp[i].classes;
 
3858
        c = s->counts.mv_comp[i].classes;
 
3859
        sum = c[1] + c[2] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9] + c[10];
 
3860
        adapt_prob(&pp[0], c[0], sum, 20, 128);
 
3861
        sum -= c[1];
 
3862
        adapt_prob(&pp[1], c[1], sum, 20, 128);
 
3863
        sum -= c[2] + c[3];
 
3864
        adapt_prob(&pp[2], c[2] + c[3], sum, 20, 128);
 
3865
        adapt_prob(&pp[3], c[2], c[3], 20, 128);
 
3866
        sum -= c[4] + c[5];
 
3867
        adapt_prob(&pp[4], c[4] + c[5], sum, 20, 128);
 
3868
        adapt_prob(&pp[5], c[4], c[5], 20, 128);
 
3869
        sum -= c[6];
 
3870
        adapt_prob(&pp[6], c[6], sum, 20, 128);
 
3871
        adapt_prob(&pp[7], c[7] + c[8], c[9] + c[10], 20, 128);
 
3872
        adapt_prob(&pp[8], c[7], c[8], 20, 128);
 
3873
        adapt_prob(&pp[9], c[9], c[10], 20, 128);
 
3874
 
 
3875
        adapt_prob(&p->mv_comp[i].class0, s->counts.mv_comp[i].class0[0],
 
3876
                   s->counts.mv_comp[i].class0[1], 20, 128);
 
3877
        pp = p->mv_comp[i].bits;
 
3878
        c2 = s->counts.mv_comp[i].bits;
 
3879
        for (j = 0; j < 10; j++)
 
3880
            adapt_prob(&pp[j], c2[j][0], c2[j][1], 20, 128);
 
3881
 
 
3882
        for (j = 0; j < 2; j++) {
 
3883
            pp = p->mv_comp[i].class0_fp[j];
 
3884
            c = s->counts.mv_comp[i].class0_fp[j];
 
3885
            adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
 
3886
            adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
 
3887
            adapt_prob(&pp[2], c[2], c[3], 20, 128);
 
3888
        }
 
3889
        pp = p->mv_comp[i].fp;
 
3890
        c = s->counts.mv_comp[i].fp;
 
3891
        adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
 
3892
        adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
 
3893
        adapt_prob(&pp[2], c[2], c[3], 20, 128);
 
3894
 
 
3895
        if (s->highprecisionmvs) {
 
3896
            adapt_prob(&p->mv_comp[i].class0_hp, s->counts.mv_comp[i].class0_hp[0],
 
3897
                       s->counts.mv_comp[i].class0_hp[1], 20, 128);
 
3898
            adapt_prob(&p->mv_comp[i].hp, s->counts.mv_comp[i].hp[0],
 
3899
                       s->counts.mv_comp[i].hp[1], 20, 128);
 
3900
        }
 
3901
    }
 
3902
 
 
3903
    // y intra modes
 
3904
    for (i = 0; i < 4; i++) {
 
3905
        uint8_t *pp = p->y_mode[i];
 
3906
        unsigned *c = s->counts.y_mode[i], sum, s2;
 
3907
 
 
3908
        sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
 
3909
        adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
 
3910
        sum -= c[TM_VP8_PRED];
 
3911
        adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
 
3912
        sum -= c[VERT_PRED];
 
3913
        adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
 
3914
        s2 = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
 
3915
        sum -= s2;
 
3916
        adapt_prob(&pp[3], s2, sum, 20, 128);
 
3917
        s2 -= c[HOR_PRED];
 
3918
        adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
 
3919
        adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED], 20, 128);
 
3920
        sum -= c[DIAG_DOWN_LEFT_PRED];
 
3921
        adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
 
3922
        sum -= c[VERT_LEFT_PRED];
 
3923
        adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
 
3924
        adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
 
3925
    }
 
3926
 
 
3927
    // uv intra modes
 
3928
    for (i = 0; i < 10; i++) {
 
3929
        uint8_t *pp = p->uv_mode[i];
 
3930
        unsigned *c = s->counts.uv_mode[i], sum, s2;
 
3931
 
 
3932
        sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
 
3933
        adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
 
3934
        sum -= c[TM_VP8_PRED];
 
3935
        adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
 
3936
        sum -= c[VERT_PRED];
 
3937
        adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
 
3938
        s2 = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
 
3939
        sum -= s2;
 
3940
        adapt_prob(&pp[3], s2, sum, 20, 128);
 
3941
        s2 -= c[HOR_PRED];
 
3942
        adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
 
3943
        adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED], 20, 128);
 
3944
        sum -= c[DIAG_DOWN_LEFT_PRED];
 
3945
        adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
 
3946
        sum -= c[VERT_LEFT_PRED];
 
3947
        adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
 
3948
        adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
 
3949
    }
 
3950
}
 
3951
 
 
3952
static void free_buffers(VP9Context *s)
 
3953
{
 
3954
    av_freep(&s->intra_pred_data[0]);
 
3955
    av_freep(&s->b_base);
 
3956
    av_freep(&s->block_base);
 
3957
}
 
3958
 
 
3959
static av_cold int vp9_decode_free(AVCodecContext *ctx)
 
3960
{
 
3961
    VP9Context *s = ctx->priv_data;
 
3962
    int i;
 
3963
 
 
3964
    for (i = 0; i < 3; i++) {
 
3965
        if (s->frames[i].tf.f->data[0])
 
3966
            vp9_unref_frame(ctx, &s->frames[i]);
 
3967
        av_frame_free(&s->frames[i].tf.f);
 
3968
    }
 
3969
    for (i = 0; i < 8; i++) {
 
3970
        if (s->refs[i].f->data[0])
 
3971
            ff_thread_release_buffer(ctx, &s->refs[i]);
 
3972
        av_frame_free(&s->refs[i].f);
 
3973
        if (s->next_refs[i].f->data[0])
 
3974
            ff_thread_release_buffer(ctx, &s->next_refs[i]);
 
3975
        av_frame_free(&s->next_refs[i].f);
 
3976
    }
 
3977
    free_buffers(s);
 
3978
    av_freep(&s->c_b);
 
3979
    s->c_b_size = 0;
 
3980
 
 
3981
    return 0;
 
3982
}
 
3983
 
 
3984
 
 
3985
static int vp9_decode_frame(AVCodecContext *ctx, void *frame,
 
3986
                            int *got_frame, AVPacket *pkt)
 
3987
{
 
3988
    const uint8_t *data = pkt->data;
 
3989
    int size = pkt->size;
 
3990
    VP9Context *s = ctx->priv_data;
 
3991
    int res, tile_row, tile_col, i, ref, row, col;
 
3992
    int retain_segmap_ref = s->segmentation.enabled && !s->segmentation.update_map
 
3993
                            && s->frames[REF_FRAME_SEGMAP].segmentation_map;
 
3994
    ptrdiff_t yoff, uvoff, ls_y, ls_uv;
 
3995
    AVFrame *f;
 
3996
    int bytesperpixel;
 
3997
 
 
3998
    if ((res = decode_frame_header(ctx, data, size, &ref)) < 0) {
 
3999
        return res;
 
4000
    } else if (res == 0) {
 
4001
        if (!s->refs[ref].f->data[0]) {
 
4002
            av_log(ctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
 
4003
            return AVERROR_INVALIDDATA;
 
4004
        }
 
4005
        if ((res = av_frame_ref(frame, s->refs[ref].f)) < 0)
 
4006
            return res;
 
4007
        ((AVFrame *)frame)->pkt_pts = pkt->pts;
 
4008
        ((AVFrame *)frame)->pkt_dts = pkt->dts;
 
4009
        for (i = 0; i < 8; i++) {
 
4010
            if (s->next_refs[i].f->data[0])
 
4011
                ff_thread_release_buffer(ctx, &s->next_refs[i]);
 
4012
            if (s->refs[i].f->data[0] &&
 
4013
                (res = ff_thread_ref_frame(&s->next_refs[i], &s->refs[i])) < 0)
 
4014
                return res;
 
4015
        }
 
4016
        *got_frame = 1;
 
4017
        return pkt->size;
 
4018
    }
 
4019
    data += res;
 
4020
    size -= res;
 
4021
 
 
4022
    if (!retain_segmap_ref) {
 
4023
        if (s->frames[REF_FRAME_SEGMAP].tf.f->data[0])
 
4024
            vp9_unref_frame(ctx, &s->frames[REF_FRAME_SEGMAP]);
 
4025
        if (!s->keyframe && !s->intraonly && !s->errorres && s->frames[CUR_FRAME].tf.f->data[0] &&
 
4026
            (res = vp9_ref_frame(ctx, &s->frames[REF_FRAME_SEGMAP], &s->frames[CUR_FRAME])) < 0)
 
4027
            return res;
 
4028
    }
 
4029
    if (s->frames[REF_FRAME_MVPAIR].tf.f->data[0])
 
4030
        vp9_unref_frame(ctx, &s->frames[REF_FRAME_MVPAIR]);
 
4031
    if (!s->intraonly && !s->keyframe && !s->errorres && s->frames[CUR_FRAME].tf.f->data[0] &&
 
4032
        (res = vp9_ref_frame(ctx, &s->frames[REF_FRAME_MVPAIR], &s->frames[CUR_FRAME])) < 0)
 
4033
        return res;
 
4034
    if (s->frames[CUR_FRAME].tf.f->data[0])
 
4035
        vp9_unref_frame(ctx, &s->frames[CUR_FRAME]);
 
4036
    if ((res = vp9_alloc_frame(ctx, &s->frames[CUR_FRAME])) < 0)
 
4037
        return res;
 
4038
    f = s->frames[CUR_FRAME].tf.f;
 
4039
    f->key_frame = s->keyframe;
 
4040
    f->pict_type = (s->keyframe || s->intraonly) ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
 
4041
    ls_y = f->linesize[0];
 
4042
    ls_uv =f->linesize[1];
 
4043
 
 
4044
    // ref frame setup
 
4045
    for (i = 0; i < 8; i++) {
 
4046
        if (s->next_refs[i].f->data[0])
 
4047
            ff_thread_release_buffer(ctx, &s->next_refs[i]);
 
4048
        if (s->refreshrefmask & (1 << i)) {
 
4049
            res = ff_thread_ref_frame(&s->next_refs[i], &s->frames[CUR_FRAME].tf);
 
4050
        } else if (s->refs[i].f->data[0]) {
 
4051
            res = ff_thread_ref_frame(&s->next_refs[i], &s->refs[i]);
 
4052
        }
 
4053
        if (res < 0)
 
4054
            return res;
 
4055
    }
 
4056
 
 
4057
    // main tile decode loop
 
4058
    bytesperpixel = s->bytesperpixel;
 
4059
    memset(s->above_partition_ctx, 0, s->cols);
 
4060
    memset(s->above_skip_ctx, 0, s->cols);
 
4061
    if (s->keyframe || s->intraonly) {
 
4062
        memset(s->above_mode_ctx, DC_PRED, s->cols * 2);
 
4063
    } else {
 
4064
        memset(s->above_mode_ctx, NEARESTMV, s->cols);
 
4065
    }
 
4066
    memset(s->above_y_nnz_ctx, 0, s->sb_cols * 16);
 
4067
    memset(s->above_uv_nnz_ctx[0], 0, s->sb_cols * 16 >> s->ss_h);
 
4068
    memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);
 
4069
    memset(s->above_segpred_ctx, 0, s->cols);
 
4070
    s->pass = s->frames[CUR_FRAME].uses_2pass =
 
4071
        ctx->active_thread_type == FF_THREAD_FRAME && s->refreshctx && !s->parallelmode;
 
4072
    if ((res = update_block_buffers(ctx)) < 0) {
 
4073
        av_log(ctx, AV_LOG_ERROR,
 
4074
               "Failed to allocate block buffers\n");
 
4075
        return res;
 
4076
    }
 
4077
    if (s->refreshctx && s->parallelmode) {
 
4078
        int j, k, l, m;
 
4079
 
 
4080
        for (i = 0; i < 4; i++) {
 
4081
            for (j = 0; j < 2; j++)
 
4082
                for (k = 0; k < 2; k++)
 
4083
                    for (l = 0; l < 6; l++)
 
4084
                        for (m = 0; m < 6; m++)
 
4085
                            memcpy(s->prob_ctx[s->framectxid].coef[i][j][k][l][m],
 
4086
                                   s->prob.coef[i][j][k][l][m], 3);
 
4087
            if (s->txfmmode == i)
 
4088
                break;
 
4089
        }
 
4090
        s->prob_ctx[s->framectxid].p = s->prob.p;
 
4091
        ff_thread_finish_setup(ctx);
 
4092
    } else if (!s->refreshctx) {
 
4093
        ff_thread_finish_setup(ctx);
 
4094
    }
 
4095
 
 
4096
    do {
 
4097
        yoff = uvoff = 0;
 
4098
        s->b = s->b_base;
 
4099
        s->block = s->block_base;
 
4100
        s->uvblock[0] = s->uvblock_base[0];
 
4101
        s->uvblock[1] = s->uvblock_base[1];
 
4102
        s->eob = s->eob_base;
 
4103
        s->uveob[0] = s->uveob_base[0];
 
4104
        s->uveob[1] = s->uveob_base[1];
 
4105
 
 
4106
        for (tile_row = 0; tile_row < s->tiling.tile_rows; tile_row++) {
 
4107
            set_tile_offset(&s->tiling.tile_row_start, &s->tiling.tile_row_end,
 
4108
                            tile_row, s->tiling.log2_tile_rows, s->sb_rows);
 
4109
            if (s->pass != 2) {
 
4110
                for (tile_col = 0; tile_col < s->tiling.tile_cols; tile_col++) {
 
4111
                    int64_t tile_size;
 
4112
 
 
4113
                    if (tile_col == s->tiling.tile_cols - 1 &&
 
4114
                        tile_row == s->tiling.tile_rows - 1) {
 
4115
                        tile_size = size;
 
4116
                    } else {
 
4117
                        tile_size = AV_RB32(data);
 
4118
                        data += 4;
 
4119
                        size -= 4;
 
4120
                    }
 
4121
                    if (tile_size > size) {
 
4122
                        ff_thread_report_progress(&s->frames[CUR_FRAME].tf, INT_MAX, 0);
 
4123
                        return AVERROR_INVALIDDATA;
 
4124
                    }
 
4125
                    ff_vp56_init_range_decoder(&s->c_b[tile_col], data, tile_size);
 
4126
                    if (vp56_rac_get_prob_branchy(&s->c_b[tile_col], 128)) { // marker bit
 
4127
                        ff_thread_report_progress(&s->frames[CUR_FRAME].tf, INT_MAX, 0);
 
4128
                        return AVERROR_INVALIDDATA;
 
4129
                    }
 
4130
                    data += tile_size;
 
4131
                    size -= tile_size;
 
4132
                }
 
4133
            }
 
4134
 
 
4135
            for (row = s->tiling.tile_row_start; row < s->tiling.tile_row_end;
 
4136
                 row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
 
4137
                struct VP9Filter *lflvl_ptr = s->lflvl;
 
4138
                ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
 
4139
 
 
4140
                for (tile_col = 0; tile_col < s->tiling.tile_cols; tile_col++) {
 
4141
                    set_tile_offset(&s->tiling.tile_col_start, &s->tiling.tile_col_end,
 
4142
                                    tile_col, s->tiling.log2_tile_cols, s->sb_cols);
 
4143
 
 
4144
                    if (s->pass != 2) {
 
4145
                        memset(s->left_partition_ctx, 0, 8);
 
4146
                        memset(s->left_skip_ctx, 0, 8);
 
4147
                        if (s->keyframe || s->intraonly) {
 
4148
                            memset(s->left_mode_ctx, DC_PRED, 16);
 
4149
                        } else {
 
4150
                            memset(s->left_mode_ctx, NEARESTMV, 8);
 
4151
                        }
 
4152
                        memset(s->left_y_nnz_ctx, 0, 16);
 
4153
                        memset(s->left_uv_nnz_ctx, 0, 32);
 
4154
                        memset(s->left_segpred_ctx, 0, 8);
 
4155
 
 
4156
                        memcpy(&s->c, &s->c_b[tile_col], sizeof(s->c));
 
4157
                    }
 
4158
 
 
4159
                    for (col = s->tiling.tile_col_start;
 
4160
                         col < s->tiling.tile_col_end;
 
4161
                         col += 8, yoff2 += 64 * bytesperpixel,
 
4162
                         uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
 
4163
                        // FIXME integrate with lf code (i.e. zero after each
 
4164
                        // use, similar to invtxfm coefficients, or similar)
 
4165
                        if (s->pass != 1) {
 
4166
                            memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
 
4167
                        }
 
4168
 
 
4169
                        if (s->pass == 2) {
 
4170
                            decode_sb_mem(ctx, row, col, lflvl_ptr,
 
4171
                                          yoff2, uvoff2, BL_64X64);
 
4172
                        } else {
 
4173
                            decode_sb(ctx, row, col, lflvl_ptr,
 
4174
                                      yoff2, uvoff2, BL_64X64);
 
4175
                        }
 
4176
                    }
 
4177
                    if (s->pass != 2) {
 
4178
                        memcpy(&s->c_b[tile_col], &s->c, sizeof(s->c));
 
4179
                    }
 
4180
                }
 
4181
 
 
4182
                if (s->pass == 1) {
 
4183
                    continue;
 
4184
                }
 
4185
 
 
4186
                // backup pre-loopfilter reconstruction data for intra
 
4187
                // prediction of next row of sb64s
 
4188
                if (row + 8 < s->rows) {
 
4189
                    memcpy(s->intra_pred_data[0],
 
4190
                           f->data[0] + yoff + 63 * ls_y,
 
4191
                           8 * s->cols * bytesperpixel);
 
4192
                    memcpy(s->intra_pred_data[1],
 
4193
                           f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
 
4194
                           8 * s->cols * bytesperpixel >> s->ss_h);
 
4195
                    memcpy(s->intra_pred_data[2],
 
4196
                           f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
 
4197
                           8 * s->cols * bytesperpixel >> s->ss_h);
 
4198
                }
 
4199
 
 
4200
                // loopfilter one row
 
4201
                if (s->filter.level) {
 
4202
                    yoff2 = yoff;
 
4203
                    uvoff2 = uvoff;
 
4204
                    lflvl_ptr = s->lflvl;
 
4205
                    for (col = 0; col < s->cols;
 
4206
                         col += 8, yoff2 += 64 * bytesperpixel,
 
4207
                         uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
 
4208
                        loopfilter_sb(ctx, lflvl_ptr, row, col, yoff2, uvoff2);
 
4209
                    }
 
4210
                }
 
4211
 
 
4212
                // FIXME maybe we can make this more finegrained by running the
 
4213
                // loopfilter per-block instead of after each sbrow
 
4214
                // In fact that would also make intra pred left preparation easier?
 
4215
                ff_thread_report_progress(&s->frames[CUR_FRAME].tf, row >> 3, 0);
 
4216
            }
 
4217
        }
 
4218
 
 
4219
        if (s->pass < 2 && s->refreshctx && !s->parallelmode) {
 
4220
            adapt_probs(s);
 
4221
            ff_thread_finish_setup(ctx);
 
4222
        }
 
4223
    } while (s->pass++ == 1);
 
4224
    ff_thread_report_progress(&s->frames[CUR_FRAME].tf, INT_MAX, 0);
 
4225
 
 
4226
    // ref frame setup
 
4227
    for (i = 0; i < 8; i++) {
 
4228
        if (s->refs[i].f->data[0])
 
4229
            ff_thread_release_buffer(ctx, &s->refs[i]);
 
4230
        ff_thread_ref_frame(&s->refs[i], &s->next_refs[i]);
 
4231
    }
 
4232
 
 
4233
    if (!s->invisible) {
 
4234
        if ((res = av_frame_ref(frame, s->frames[CUR_FRAME].tf.f)) < 0)
 
4235
            return res;
 
4236
        *got_frame = 1;
 
4237
    }
 
4238
 
 
4239
    return pkt->size;
 
4240
}
 
4241
 
 
4242
static void vp9_decode_flush(AVCodecContext *ctx)
 
4243
{
 
4244
    VP9Context *s = ctx->priv_data;
 
4245
    int i;
 
4246
 
 
4247
    for (i = 0; i < 3; i++)
 
4248
        vp9_unref_frame(ctx, &s->frames[i]);
 
4249
    for (i = 0; i < 8; i++)
 
4250
        ff_thread_release_buffer(ctx, &s->refs[i]);
 
4251
}
 
4252
 
 
4253
static int init_frames(AVCodecContext *ctx)
 
4254
{
 
4255
    VP9Context *s = ctx->priv_data;
 
4256
    int i;
 
4257
 
 
4258
    for (i = 0; i < 3; i++) {
 
4259
        s->frames[i].tf.f = av_frame_alloc();
 
4260
        if (!s->frames[i].tf.f) {
 
4261
            vp9_decode_free(ctx);
 
4262
            av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
 
4263
            return AVERROR(ENOMEM);
 
4264
        }
 
4265
    }
 
4266
    for (i = 0; i < 8; i++) {
 
4267
        s->refs[i].f = av_frame_alloc();
 
4268
        s->next_refs[i].f = av_frame_alloc();
 
4269
        if (!s->refs[i].f || !s->next_refs[i].f) {
 
4270
            vp9_decode_free(ctx);
 
4271
            av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
 
4272
            return AVERROR(ENOMEM);
 
4273
        }
 
4274
    }
 
4275
 
 
4276
    return 0;
 
4277
}
 
4278
 
 
4279
static av_cold int vp9_decode_init(AVCodecContext *ctx)
 
4280
{
 
4281
    VP9Context *s = ctx->priv_data;
 
4282
 
 
4283
    ctx->internal->allocate_progress = 1;
 
4284
    s->last_bpp = 0;
 
4285
    s->filter.sharpness = -1;
 
4286
 
 
4287
    return init_frames(ctx);
 
4288
}
 
4289
 
 
4290
static av_cold int vp9_decode_init_thread_copy(AVCodecContext *avctx)
 
4291
{
 
4292
    return init_frames(avctx);
 
4293
}
 
4294
 
 
4295
static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
 
4296
{
 
4297
    int i, res;
 
4298
    VP9Context *s = dst->priv_data, *ssrc = src->priv_data;
 
4299
 
 
4300
    // detect size changes in other threads
 
4301
    if (s->intra_pred_data[0] &&
 
4302
        (!ssrc->intra_pred_data[0] || s->cols != ssrc->cols || s->rows != ssrc->rows)) {
 
4303
        free_buffers(s);
 
4304
    }
 
4305
 
 
4306
    for (i = 0; i < 3; i++) {
 
4307
        if (s->frames[i].tf.f->data[0])
 
4308
            vp9_unref_frame(dst, &s->frames[i]);
 
4309
        if (ssrc->frames[i].tf.f->data[0]) {
 
4310
            if ((res = vp9_ref_frame(dst, &s->frames[i], &ssrc->frames[i])) < 0)
 
4311
                return res;
 
4312
        }
 
4313
    }
 
4314
    for (i = 0; i < 8; i++) {
 
4315
        if (s->refs[i].f->data[0])
 
4316
            ff_thread_release_buffer(dst, &s->refs[i]);
 
4317
        if (ssrc->next_refs[i].f->data[0]) {
 
4318
            if ((res = ff_thread_ref_frame(&s->refs[i], &ssrc->next_refs[i])) < 0)
 
4319
                return res;
 
4320
        }
 
4321
    }
 
4322
 
 
4323
    s->invisible = ssrc->invisible;
 
4324
    s->keyframe = ssrc->keyframe;
 
4325
    s->ss_v = ssrc->ss_v;
 
4326
    s->ss_h = ssrc->ss_h;
 
4327
    s->segmentation.enabled = ssrc->segmentation.enabled;
 
4328
    s->segmentation.update_map = ssrc->segmentation.update_map;
 
4329
    s->bytesperpixel = ssrc->bytesperpixel;
 
4330
    s->bpp = ssrc->bpp;
 
4331
    s->bpp_index = ssrc->bpp_index;
 
4332
    memcpy(&s->prob_ctx, &ssrc->prob_ctx, sizeof(s->prob_ctx));
 
4333
    memcpy(&s->lf_delta, &ssrc->lf_delta, sizeof(s->lf_delta));
 
4334
    if (ssrc->segmentation.enabled) {
 
4335
        memcpy(&s->segmentation.feat, &ssrc->segmentation.feat,
 
4336
               sizeof(s->segmentation.feat));
 
4337
    }
 
4338
 
 
4339
    return 0;
 
4340
}
 
4341
 
 
4342
static const AVProfile profiles[] = {
 
4343
    { FF_PROFILE_VP9_0, "Profile 0" },
 
4344
    { FF_PROFILE_VP9_1, "Profile 1" },
 
4345
    { FF_PROFILE_VP9_2, "Profile 2" },
 
4346
    { FF_PROFILE_VP9_3, "Profile 3" },
 
4347
    { FF_PROFILE_UNKNOWN },
 
4348
};
 
4349
 
 
4350
AVCodec ff_vp9_decoder = {
 
4351
    .name                  = "vp9",
 
4352
    .long_name             = NULL_IF_CONFIG_SMALL("Google VP9"),
 
4353
    .type                  = AVMEDIA_TYPE_VIDEO,
 
4354
    .id                    = AV_CODEC_ID_VP9,
 
4355
    .priv_data_size        = sizeof(VP9Context),
 
4356
    .init                  = vp9_decode_init,
 
4357
    .close                 = vp9_decode_free,
 
4358
    .decode                = vp9_decode_frame,
 
4359
    .capabilities          = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
 
4360
    .flush                 = vp9_decode_flush,
 
4361
    .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp9_decode_init_thread_copy),
 
4362
    .update_thread_context = ONLY_IF_THREADS_ENABLED(vp9_decode_update_thread_context),
 
4363
    .profiles              = NULL_IF_CONFIG_SMALL(profiles),
 
4364
};