GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/vp9lpf.c Lines: 112 112 100.0 %
Date: 2020-09-25 23:16:12 Branches: 60 60 100.0 %

Line Branch Exec Source
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 "vp9dec.h"
25
26
144510
static av_always_inline void filter_plane_cols(VP9Context *s, int col, int ss_h, int ss_v,
27
                                               uint8_t *lvl, uint8_t (*mask)[4],
28
                                               uint8_t *dst, ptrdiff_t ls)
29
{
30
144510
    int y, x, bytesperpixel = s->bytesperpixel;
31
32
    // filter edges between columns (e.g. block1 | block2)
33
532918
    for (y = 0; y < 8; y += 2 << ss_v, dst += 16 * ls, lvl += 16 << ss_v) {
34
388408
        uint8_t *ptr = dst, *l = lvl, *hmask1 = mask[y], *hmask2 = mask[y + 1 + ss_v];
35
388408
        unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2], hm13 = hmask1[3];
36
388408
        unsigned hm2 = hmask2[1] | hmask2[2], hm23 = hmask2[3];
37
388408
        unsigned hm = hm1 | hm2 | hm13 | hm23;
38
39
2110313
        for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 8 * bytesperpixel >> ss_h) {
40

1721905
            if (col || x > 1) {
41
1669342
                if (hm1 & x) {
42
1134170
                    int L = *l, H = L >> 4;
43
1134170
                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
44
45
1134170
                    if (hmask1[0] & x) {
46
329527
                        if (hmask2[0] & x) {
47
                            av_assert2(l[8 << ss_v] == L);
48
327919
                            s->dsp.loop_filter_16[0](ptr, ls, E, I, H);
49
                        } else {
50
1608
                            s->dsp.loop_filter_8[2][0](ptr, ls, E, I, H);
51
                        }
52
804643
                    } else if (hm2 & x) {
53
741230
                        L = l[8 << ss_v];
54
741230
                        H |= (L >> 4) << 8;
55
741230
                        E |= s->filter_lut.mblim_lut[L] << 8;
56
741230
                        I |= s->filter_lut.lim_lut[L] << 8;
57
741230
                        s->dsp.loop_filter_mix2[!!(hmask1[1] & x)]
58
741230
                                               [!!(hmask2[1] & x)]
59
741230
                                               [0](ptr, ls, E, I, H);
60
                    } else {
61
63413
                        s->dsp.loop_filter_8[!!(hmask1[1] & x)]
62
63413
                                            [0](ptr, ls, E, I, H);
63
                    }
64
535172
                } else if (hm2 & x) {
65
31566
                    int L = l[8 << ss_v], H = L >> 4;
66
31566
                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
67
68
31566
                    s->dsp.loop_filter_8[!!(hmask2[1] & x)]
69
31566
                                        [0](ptr + 8 * ls, ls, E, I, H);
70
                }
71
            }
72
1721905
            if (ss_h) {
73
835364
                if (x & 0xAA)
74
348876
                    l += 2;
75
            } else {
76
886541
                if (hm13 & x) {
77
112338
                    int L = *l, H = L >> 4;
78
112338
                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
79
80
112338
                    if (hm23 & x) {
81
65684
                        L = l[8 << ss_v];
82
65684
                        H |= (L >> 4) << 8;
83
65684
                        E |= s->filter_lut.mblim_lut[L] << 8;
84
65684
                        I |= s->filter_lut.lim_lut[L] << 8;
85
65684
                        s->dsp.loop_filter_mix2[0][0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
86
                    } else {
87
46654
                        s->dsp.loop_filter_8[0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
88
                    }
89
774203
                } else if (hm23 & x) {
90
38258
                    int L = l[8 << ss_v], H = L >> 4;
91
38258
                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
92
93
38258
                    s->dsp.loop_filter_8[0][0](ptr + 8 * ls + 4 * bytesperpixel, ls, E, I, H);
94
                }
95
886541
                l++;
96
            }
97
        }
98
    }
99
144510
}
100
101
144510
static av_always_inline void filter_plane_rows(VP9Context *s, int row, int ss_h, int ss_v,
102
                                               uint8_t *lvl, uint8_t (*mask)[4],
103
                                               uint8_t *dst, ptrdiff_t ls)
104
{
105
144510
    int y, x, bytesperpixel = s->bytesperpixel;
106
107
    //                                 block1
108
    // filter edges between rows (e.g. ------)
109
    //                                 block2
110
1300590
    for (y = 0; y < 8; y++, dst += 8 * ls >> ss_v) {
111
1156080
        uint8_t *ptr = dst, *l = lvl, *vmask = mask[y];
112
1156080
        unsigned vm = vmask[0] | vmask[1] | vmask[2], vm3 = vmask[3];
113
114
2492214
        for (x = 1; vm & ~(x - 1); x <<= (2 << ss_h), ptr += 16 * bytesperpixel, l += 2 << ss_h) {
115

1336134
            if (row || y) {
116
1268971
                if (vm & x) {
117
1127528
                    int L = *l, H = L >> 4;
118
1127528
                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
119
120
1127528
                    if (vmask[0] & x) {
121
332213
                        if (vmask[0] & (x << (1 + ss_h))) {
122
                            av_assert2(l[1 + ss_h] == L);
123
331894
                            s->dsp.loop_filter_16[1](ptr, ls, E, I, H);
124
                        } else {
125
319
                            s->dsp.loop_filter_8[2][1](ptr, ls, E, I, H);
126
                        }
127
795315
                    } else if (vm & (x << (1 + ss_h))) {
128
729522
                        L = l[1 + ss_h];
129
729522
                        H |= (L >> 4) << 8;
130
729522
                        E |= s->filter_lut.mblim_lut[L] << 8;
131
729522
                        I |= s->filter_lut.lim_lut[L] << 8;
132
729522
                        s->dsp.loop_filter_mix2[!!(vmask[1] &  x)]
133
729522
                                               [!!(vmask[1] & (x << (1 + ss_h)))]
134
729522
                                               [1](ptr, ls, E, I, H);
135
                    } else {
136
65793
                        s->dsp.loop_filter_8[!!(vmask[1] & x)]
137
65793
                                            [1](ptr, ls, E, I, H);
138
                    }
139
141443
                } else if (vm & (x << (1 + ss_h))) {
140
34016
                    int L = l[1 + ss_h], H = L >> 4;
141
34016
                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
142
143
34016
                    s->dsp.loop_filter_8[!!(vmask[1] & (x << (1 + ss_h)))]
144
34016
                                        [1](ptr + 8 * bytesperpixel, ls, E, I, H);
145
                }
146
            }
147
1336134
            if (!ss_v) {
148
727592
                if (vm3 & x) {
149
106915
                    int L = *l, H = L >> 4;
150
106915
                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
151
152
106915
                    if (vm3 & (x << (1 + ss_h))) {
153
63766
                        L = l[1 + ss_h];
154
63766
                        H |= (L >> 4) << 8;
155
63766
                        E |= s->filter_lut.mblim_lut[L] << 8;
156
63766
                        I |= s->filter_lut.lim_lut[L] << 8;
157
63766
                        s->dsp.loop_filter_mix2[0][0][1](ptr + ls * 4, ls, E, I, H);
158
                    } else {
159
43149
                        s->dsp.loop_filter_8[0][1](ptr + ls * 4, ls, E, I, H);
160
                    }
161
620677
                } else if (vm3 & (x << (1 + ss_h))) {
162
40931
                    int L = l[1 + ss_h], H = L >> 4;
163
40931
                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
164
165
40931
                    s->dsp.loop_filter_8[0][1](ptr + ls * 4 + 8 * bytesperpixel, ls, E, I, H);
166
                }
167
            }
168
        }
169
1156080
        if (ss_v) {
170
758528
            if (y & 1)
171
379264
                lvl += 16;
172
        } else {
173
397552
            lvl += 8;
174
        }
175
    }
176
144510
}
177
178
48170
void ff_vp9_loopfilter_sb(AVCodecContext *avctx, VP9Filter *lflvl,
179
                          int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
180
{
181
48170
    VP9Context *s = avctx->priv_data;
182
48170
    AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
183
48170
    uint8_t *dst = f->data[0] + yoff;
184
48170
    ptrdiff_t ls_y = f->linesize[0], ls_uv = f->linesize[1];
185
48170
    uint8_t (*uv_masks)[8][4] = lflvl->mask[s->ss_h | s->ss_v];
186
    int p;
187
188
    /* FIXME: In how far can we interleave the v/h loopfilter calls? E.g.
189
     * if you think of them as acting on a 8x8 block max, we can interleave
190
     * each v/h within the single x loop, but that only works if we work on
191
     * 8 pixel blocks, and we won't always do that (we want at least 16px
192
     * to use SSE2 optimizations, perhaps 32 for AVX2) */
193
194
48170
    filter_plane_cols(s, col, 0, 0, lflvl->level, lflvl->mask[0][0], dst, ls_y);
195
48170
    filter_plane_rows(s, row, 0, 0, lflvl->level, lflvl->mask[0][1], dst, ls_y);
196
197
144510
    for (p = 0; p < 2; p++) {
198
96340
        dst = f->data[1 + p] + uvoff;
199
96340
        filter_plane_cols(s, col, s->ss_h, s->ss_v, lflvl->level, uv_masks[0], dst, ls_uv);
200
96340
        filter_plane_rows(s, row, s->ss_h, s->ss_v, lflvl->level, uv_masks[1], dst, ls_uv);
201
    }
202
48170
}