FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/vp9lpf.c
Date: 2022-12-09 07:38:14
Exec Total Coverage
Lines: 112 112 100.0%
Functions: 3 3 100.0%
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 144708 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 144708 int y, x, bytesperpixel = s->bytesperpixel;
31
32 // filter edges between columns (e.g. block1 | block2)
33
2/2
✓ Branch 0 taken 389200 times.
✓ Branch 1 taken 144708 times.
 533908 for (y = 0; y < 8; y += 2 << ss_v, dst += 16 * ls, lvl += 16 << ss_v) {
34 389200 uint8_t *ptr = dst, *l = lvl, *hmask1 = mask[y], *hmask2 = mask[y + 1 + ss_v];
35 389200 unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2], hm13 = hmask1[3];
36 389200 unsigned hm2 = hmask2[1] | hmask2[2], hm23 = hmask2[3];
37 389200 unsigned hm = hm1 | hm2 | hm13 | hm23;
38
39
2/2
✓ Branch 0 taken 1725401 times.
✓ Branch 1 taken 389200 times.
 2114601 for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 8 * bytesperpixel >> ss_h) {
40
4/4
✓ Branch 0 taken 284351 times.
✓ Branch 1 taken 1441050 times.
✓ Branch 2 taken 231590 times.
✓ Branch 3 taken 52761 times.
 1725401 if (col || x > 1) {
41
2/2
✓ Branch 0 taken 1136691 times.
✓ Branch 1 taken 535949 times.
 1672640 if (hm1 & x) {
42 1136691 int L = *l, H = L >> 4;
43 1136691 int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
44
45
2/2
✓ Branch 0 taken 329699 times.
✓ Branch 1 taken 806992 times.
 1136691 if (hmask1[0] & x) {
46
2/2
✓ Branch 0 taken 328091 times.
✓ Branch 1 taken 1608 times.
 329699 if (hmask2[0] & x) {
47 av_assert2(l[8 << ss_v] == L);
48 328091 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
2/2
✓ Branch 0 taken 743429 times.
✓ Branch 1 taken 63563 times.
 806992 } else if (hm2 & x) {
53 743429 L = l[8 << ss_v];
54 743429 H |= (L >> 4) << 8;
55 743429 E |= s->filter_lut.mblim_lut[L] << 8;
56 743429 I |= s->filter_lut.lim_lut[L] << 8;
57 743429 s->dsp.loop_filter_mix2[!!(hmask1[1] & x)]
58 743429 [!!(hmask2[1] & x)]
59 743429 [0](ptr, ls, E, I, H);
60 } else {
61 63563 s->dsp.loop_filter_8[!!(hmask1[1] & x)]
62 63563 [0](ptr, ls, E, I, H);
63 }
64
2/2
✓ Branch 0 taken 31642 times.
✓ Branch 1 taken 504307 times.
 535949 } else if (hm2 & x) {
65 31642 int L = l[8 << ss_v], H = L >> 4;
66 31642 int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
67
68 31642 s->dsp.loop_filter_8[!!(hmask2[1] & x)]
69 31642 [0](ptr + 8 * ls, ls, E, I, H);
70 }
71 }
72
2/2
✓ Branch 0 taken 837672 times.
✓ Branch 1 taken 887729 times.
 1725401 if (ss_h) {
73
2/2
✓ Branch 0 taken 349932 times.
✓ Branch 1 taken 487740 times.
 837672 if (x & 0xAA)
74 349932 l += 2;
75 } else {
76
2/2
✓ Branch 0 taken 112721 times.
✓ Branch 1 taken 775008 times.
 887729 if (hm13 & x) {
77 112721 int L = *l, H = L >> 4;
78 112721 int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
79
80
2/2
✓ Branch 0 taken 65900 times.
✓ Branch 1 taken 46821 times.
 112721 if (hm23 & x) {
81 65900 L = l[8 << ss_v];
82 65900 H |= (L >> 4) << 8;
83 65900 E |= s->filter_lut.mblim_lut[L] << 8;
84 65900 I |= s->filter_lut.lim_lut[L] << 8;
85 65900 s->dsp.loop_filter_mix2[0][0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
86 } else {
87 46821 s->dsp.loop_filter_8[0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
88 }
89
2/2
✓ Branch 0 taken 38338 times.
✓ Branch 1 taken 736670 times.
 775008 } else if (hm23 & x) {
90 38338 int L = l[8 << ss_v], H = L >> 4;
91 38338 int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
92
93 38338 s->dsp.loop_filter_8[0][0](ptr + 8 * ls + 4 * bytesperpixel, ls, E, I, H);
94 }
95 887729 l++;
96 }
97 }
98 }
99 144708 }
100
101 144708 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 144708 int y, x, bytesperpixel = s->bytesperpixel;
106
107 // block1
108 // filter edges between rows (e.g. ------)
109 // block2
110
2/2
✓ Branch 0 taken 1157664 times.
✓ Branch 1 taken 144708 times.
 1302372 for (y = 0; y < 8; y++, dst += 8 * ls >> ss_v) {
111 1157664 uint8_t *ptr = dst, *l = lvl, *vmask = mask[y];
112 1157664 unsigned vm = vmask[0] | vmask[1] | vmask[2], vm3 = vmask[3];
113
114
2/2
✓ Branch 0 taken 1338515 times.
✓ Branch 1 taken 1157664 times.
 2496179 for (x = 1; vm & ~(x - 1); x <<= (2 << ss_h), ptr += 16 * bytesperpixel, l += 2 << ss_h) {
115
4/4
✓ Branch 0 taken 289757 times.
✓ Branch 1 taken 1048758 times.
✓ Branch 2 taken 222374 times.
✓ Branch 3 taken 67383 times.
 1338515 if (row || y) {
116
2/2
✓ Branch 0 taken 1129385 times.
✓ Branch 1 taken 141747 times.
 1271132 if (vm & x) {
117 1129385 int L = *l, H = L >> 4;
118 1129385 int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
119
120
2/2
✓ Branch 0 taken 332376 times.
✓ Branch 1 taken 797009 times.
 1129385 if (vmask[0] & x) {
121
2/2
✓ Branch 0 taken 332057 times.
✓ Branch 1 taken 319 times.
 332376 if (vmask[0] & (x << (1 + ss_h))) {
122 av_assert2(l[1 + ss_h] == L);
123 332057 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
2/2
✓ Branch 0 taken 731086 times.
✓ Branch 1 taken 65923 times.
 797009 } else if (vm & (x << (1 + ss_h))) {
128 731086 L = l[1 + ss_h];
129 731086 H |= (L >> 4) << 8;
130 731086 E |= s->filter_lut.mblim_lut[L] << 8;
131 731086 I |= s->filter_lut.lim_lut[L] << 8;
132 731086 s->dsp.loop_filter_mix2[!!(vmask[1] & x)]
133 731086 [!!(vmask[1] & (x << (1 + ss_h)))]
134 731086 [1](ptr, ls, E, I, H);
135 } else {
136 65923 s->dsp.loop_filter_8[!!(vmask[1] & x)]
137 65923 [1](ptr, ls, E, I, H);
138 }
139
2/2
✓ Branch 0 taken 34138 times.
✓ Branch 1 taken 107609 times.
 141747 } else if (vm & (x << (1 + ss_h))) {
140 34138 int L = l[1 + ss_h], H = L >> 4;
141 34138 int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
142
143 34138 s->dsp.loop_filter_8[!!(vmask[1] & (x << (1 + ss_h)))]
144 34138 [1](ptr + 8 * bytesperpixel, ls, E, I, H);
145 }
146 }
147
2/2
✓ Branch 0 taken 729973 times.
✓ Branch 1 taken 608542 times.
 1338515 if (!ss_v) {
148
2/2
✓ Branch 0 taken 107657 times.
✓ Branch 1 taken 622316 times.
 729973 if (vm3 & x) {
149 107657 int L = *l, H = L >> 4;
150 107657 int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
151
152
2/2
✓ Branch 0 taken 64168 times.
✓ Branch 1 taken 43489 times.
 107657 if (vm3 & (x << (1 + ss_h))) {
153 64168 L = l[1 + ss_h];
154 64168 H |= (L >> 4) << 8;
155 64168 E |= s->filter_lut.mblim_lut[L] << 8;
156 64168 I |= s->filter_lut.lim_lut[L] << 8;
157 64168 s->dsp.loop_filter_mix2[0][0][1](ptr + ls * 4, ls, E, I, H);
158 } else {
159 43489 s->dsp.loop_filter_8[0][1](ptr + ls * 4, ls, E, I, H);
160 }
161
2/2
✓ Branch 0 taken 41364 times.
✓ Branch 1 taken 580952 times.
 622316 } else if (vm3 & (x << (1 + ss_h))) {
162 41364 int L = l[1 + ss_h], H = L >> 4;
163 41364 int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
164
165 41364 s->dsp.loop_filter_8[0][1](ptr + ls * 4 + 8 * bytesperpixel, ls, E, I, H);
166 }
167 }
168 }
169
2/2
✓ Branch 0 taken 758528 times.
✓ Branch 1 taken 399136 times.
 1157664 if (ss_v) {
170
2/2
✓ Branch 0 taken 379264 times.
✓ Branch 1 taken 379264 times.
 758528 if (y & 1)
171 379264 lvl += 16;
172 } else {
173 399136 lvl += 8;
174 }
175 }
176 144708 }
177
178 48236 void ff_vp9_loopfilter_sb(AVCodecContext *avctx, VP9Filter *lflvl,
179 int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
180 {
181 48236 VP9Context *s = avctx->priv_data;
182 48236 AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
183 48236 uint8_t *dst = f->data[0] + yoff;
184 48236 ptrdiff_t ls_y = f->linesize[0], ls_uv = f->linesize[1];
185 48236 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 48236 filter_plane_cols(s, col, 0, 0, lflvl->level, lflvl->mask[0][0], dst, ls_y);
195 48236 filter_plane_rows(s, row, 0, 0, lflvl->level, lflvl->mask[0][1], dst, ls_y);
196
197
2/2
✓ Branch 0 taken 96472 times.
✓ Branch 1 taken 48236 times.
 144708 for (p = 0; p < 2; p++) {
198 96472 dst = f->data[1 + p] + uvoff;
199 96472 filter_plane_cols(s, col, s->ss_h, s->ss_v, lflvl->level, uv_masks[0], dst, ls_uv);
200 96472 filter_plane_rows(s, row, s->ss_h, s->ss_v, lflvl->level, uv_masks[1], dst, ls_uv);
201 }
202 48236 }
203