| GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
| Line | Branch | Exec | Source |
1 |
/* |
||
2 |
* H.26L/H.264/AVC/JVT/14496-10/... loop filter |
||
3 |
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> |
||
4 |
* |
||
5 |
* This file is part of FFmpeg. |
||
6 |
* |
||
7 |
* FFmpeg is free software; you can redistribute it and/or |
||
8 |
* modify it under the terms of the GNU Lesser General Public |
||
9 |
* License as published by the Free Software Foundation; either |
||
10 |
* version 2.1 of the License, or (at your option) any later version. |
||
11 |
* |
||
12 |
* FFmpeg is distributed in the hope that it will be useful, |
||
13 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
14 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
15 |
* Lesser General Public License for more details. |
||
16 |
* |
||
17 |
* You should have received a copy of the GNU Lesser General Public |
||
18 |
* License along with FFmpeg; if not, write to the Free Software |
||
19 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
20 |
*/ |
||
21 |
|||
22 |
/** |
||
23 |
* @file |
||
24 |
* H.264 / AVC / MPEG-4 part10 loop filter. |
||
25 |
* @author Michael Niedermayer <michaelni@gmx.at> |
||
26 |
*/ |
||
27 |
|||
28 |
#include "libavutil/internal.h" |
||
29 |
#include "libavutil/intreadwrite.h" |
||
30 |
#include "internal.h" |
||
31 |
#include "avcodec.h" |
||
32 |
#include "h264dec.h" |
||
33 |
#include "h264_ps.h" |
||
34 |
#include "mathops.h" |
||
35 |
#include "mpegutils.h" |
||
36 |
#include "rectangle.h" |
||
37 |
|||
38 |
/* Deblocking filter (p153) */ |
||
39 |
static const uint8_t alpha_table[52*3] = { |
||
40 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
41 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
42 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
43 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
44 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
45 |
0, 0, 0, 0, 0, 0, 4, 4, 5, 6, |
||
46 |
7, 8, 9, 10, 12, 13, 15, 17, 20, 22, |
||
47 |
25, 28, 32, 36, 40, 45, 50, 56, 63, 71, |
||
48 |
80, 90,101,113,127,144,162,182,203,226, |
||
49 |
255,255, |
||
50 |
255,255,255,255,255,255,255,255,255,255,255,255,255, |
||
51 |
255,255,255,255,255,255,255,255,255,255,255,255,255, |
||
52 |
255,255,255,255,255,255,255,255,255,255,255,255,255, |
||
53 |
255,255,255,255,255,255,255,255,255,255,255,255,255, |
||
54 |
}; |
||
55 |
static const uint8_t beta_table[52*3] = { |
||
56 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
57 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
58 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
59 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
60 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
61 |
0, 0, 0, 0, 0, 0, 2, 2, 2, 3, |
||
62 |
3, 3, 3, 4, 4, 4, 6, 6, 7, 7, |
||
63 |
8, 8, 9, 9, 10, 10, 11, 11, 12, 12, |
||
64 |
13, 13, 14, 14, 15, 15, 16, 16, 17, 17, |
||
65 |
18, 18, |
||
66 |
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, |
||
67 |
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, |
||
68 |
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, |
||
69 |
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, |
||
70 |
}; |
||
71 |
static const uint8_t tc0_table[52*3][4] = { |
||
72 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, |
||
73 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, |
||
74 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, |
||
75 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, |
||
76 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, |
||
77 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, |
||
78 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, |
||
79 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, |
||
80 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, |
||
81 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, |
||
82 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, |
||
83 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 1 }, |
||
84 |
{-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 1, 1 }, {-1, 0, 1, 1 }, {-1, 1, 1, 1 }, |
||
85 |
{-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 }, |
||
86 |
{-1, 1, 1, 2 }, {-1, 1, 2, 3 }, {-1, 1, 2, 3 }, {-1, 2, 2, 3 }, {-1, 2, 2, 4 }, {-1, 2, 3, 4 }, |
||
87 |
{-1, 2, 3, 4 }, {-1, 3, 3, 5 }, {-1, 3, 4, 6 }, {-1, 3, 4, 6 }, {-1, 4, 5, 7 }, {-1, 4, 5, 8 }, |
||
88 |
{-1, 4, 6, 9 }, {-1, 5, 7,10 }, {-1, 6, 8,11 }, {-1, 6, 8,13 }, {-1, 7,10,14 }, {-1, 8,11,16 }, |
||
89 |
{-1, 9,12,18 }, {-1,10,13,20 }, {-1,11,15,23 }, {-1,13,17,25 }, |
||
90 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, |
||
91 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, |
||
92 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, |
||
93 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, |
||
94 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, |
||
95 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, |
||
96 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, |
||
97 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, |
||
98 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, |
||
99 |
}; |
||
100 |
|||
101 |
/* intra: 0 if this loopfilter call is guaranteed to be inter (bS < 4), 1 if it might be intra (bS == 4) */ |
||
102 |
21195322 |
static av_always_inline void filter_mb_edgev(uint8_t *pix, int stride, |
|
103 |
const int16_t bS[4], |
||
104 |
unsigned int qp, int a, int b, |
||
105 |
const H264Context *h, int intra) |
||
106 |
{ |
||
107 |
21195322 |
const unsigned int index_a = qp + a; |
|
108 |
21195322 |
const int alpha = alpha_table[index_a]; |
|
109 |
21195322 |
const int beta = beta_table[qp + b]; |
|
110 |
✓✓✗✓ |
21195322 |
if (alpha ==0 || beta == 0) return; |
111 |
|||
112 |
✓✓✗✓ |
38893251 |
if( bS[0] < 4 || !intra ) { |
113 |
int8_t tc[4]; |
||
114 |
17992775 |
tc[0] = tc0_table[index_a][bS[0]]; |
|
115 |
17992775 |
tc[1] = tc0_table[index_a][bS[1]]; |
|
116 |
17992775 |
tc[2] = tc0_table[index_a][bS[2]]; |
|
117 |
17992775 |
tc[3] = tc0_table[index_a][bS[3]]; |
|
118 |
17992775 |
h->h264dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
|
119 |
} else { |
||
120 |
2907701 |
h->h264dsp.h264_h_loop_filter_luma_intra(pix, stride, alpha, beta); |
|
121 |
} |
||
122 |
} |
||
123 |
|||
124 |
25710672 |
static av_always_inline void filter_mb_edgecv(uint8_t *pix, int stride, |
|
125 |
const int16_t bS[4], |
||
126 |
unsigned int qp, int a, int b, |
||
127 |
const H264Context *h, int intra) |
||
128 |
{ |
||
129 |
25710672 |
const unsigned int index_a = qp + a; |
|
130 |
25710672 |
const int alpha = alpha_table[index_a]; |
|
131 |
25710672 |
const int beta = beta_table[qp + b]; |
|
132 |
✓✓✗✓ |
25710672 |
if (alpha ==0 || beta == 0) return; |
133 |
|||
134 |
✓✓✗✓ |
44701569 |
if( bS[0] < 4 || !intra ) { |
135 |
int8_t tc[4]; |
||
136 |
19519713 |
tc[0] = tc0_table[index_a][bS[0]]+1; |
|
137 |
19519713 |
tc[1] = tc0_table[index_a][bS[1]]+1; |
|
138 |
19519713 |
tc[2] = tc0_table[index_a][bS[2]]+1; |
|
139 |
19519713 |
tc[3] = tc0_table[index_a][bS[3]]+1; |
|
140 |
19519713 |
h->h264dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
|
141 |
} else { |
||
142 |
5662143 |
h->h264dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta); |
|
143 |
} |
||
144 |
} |
||
145 |
|||
146 |
686076 |
static av_always_inline void filter_mb_mbaff_edgev(const H264Context *h, uint8_t *pix, |
|
147 |
int stride, |
||
148 |
const int16_t bS[7], int bsi, |
||
149 |
int qp, int a, int b, |
||
150 |
int intra) |
||
151 |
{ |
||
152 |
686076 |
const unsigned int index_a = qp + a; |
|
153 |
686076 |
const int alpha = alpha_table[index_a]; |
|
154 |
686076 |
const int beta = beta_table[qp + b]; |
|
155 |
✓✓✗✓ |
686076 |
if (alpha ==0 || beta == 0) return; |
156 |
|||
157 |
✓✓✗✓ |
967749 |
if( bS[0] < 4 || !intra ) { |
158 |
int8_t tc[4]; |
||
159 |
299912 |
tc[0] = tc0_table[index_a][bS[0*bsi]]; |
|
160 |
299912 |
tc[1] = tc0_table[index_a][bS[1*bsi]]; |
|
161 |
299912 |
tc[2] = tc0_table[index_a][bS[2*bsi]]; |
|
162 |
299912 |
tc[3] = tc0_table[index_a][bS[3*bsi]]; |
|
163 |
299912 |
h->h264dsp.h264_h_loop_filter_luma_mbaff(pix, stride, alpha, beta, tc); |
|
164 |
} else { |
||
165 |
367925 |
h->h264dsp.h264_h_loop_filter_luma_mbaff_intra(pix, stride, alpha, beta); |
|
166 |
} |
||
167 |
} |
||
168 |
|||
169 |
1372152 |
static av_always_inline void filter_mb_mbaff_edgecv(const H264Context *h, |
|
170 |
uint8_t *pix, int stride, |
||
171 |
const int16_t bS[7], |
||
172 |
int bsi, int qp, int a, |
||
173 |
int b, int intra) |
||
174 |
{ |
||
175 |
1372152 |
const unsigned int index_a = qp + a; |
|
176 |
1372152 |
const int alpha = alpha_table[index_a]; |
|
177 |
1372152 |
const int beta = beta_table[qp + b]; |
|
178 |
✓✓✗✓ |
1372152 |
if (alpha ==0 || beta == 0) return; |
179 |
|||
180 |
✓✓✗✓ |
1934448 |
if( bS[0] < 4 || !intra ) { |
181 |
int8_t tc[4]; |
||
182 |
599366 |
tc[0] = tc0_table[index_a][bS[0*bsi]] + 1; |
|
183 |
599366 |
tc[1] = tc0_table[index_a][bS[1*bsi]] + 1; |
|
184 |
599366 |
tc[2] = tc0_table[index_a][bS[2*bsi]] + 1; |
|
185 |
599366 |
tc[3] = tc0_table[index_a][bS[3*bsi]] + 1; |
|
186 |
599366 |
h->h264dsp.h264_h_loop_filter_chroma_mbaff(pix, stride, alpha, beta, tc); |
|
187 |
} else { |
||
188 |
735716 |
h->h264dsp.h264_h_loop_filter_chroma_mbaff_intra(pix, stride, alpha, beta); |
|
189 |
} |
||
190 |
} |
||
191 |
|||
192 |
21439852 |
static av_always_inline void filter_mb_edgeh(uint8_t *pix, int stride, |
|
193 |
const int16_t bS[4], |
||
194 |
unsigned int qp, int a, int b, |
||
195 |
const H264Context *h, int intra) |
||
196 |
{ |
||
197 |
21439852 |
const unsigned int index_a = qp + a; |
|
198 |
21439852 |
const int alpha = alpha_table[index_a]; |
|
199 |
21439852 |
const int beta = beta_table[qp + b]; |
|
200 |
✓✓✗✓ |
21439852 |
if (alpha ==0 || beta == 0) return; |
201 |
|||
202 |
✓✓✗✓ |
39931429 |
if( bS[0] < 4 || !intra ) { |
203 |
int8_t tc[4]; |
||
204 |
18805394 |
tc[0] = tc0_table[index_a][bS[0]]; |
|
205 |
18805394 |
tc[1] = tc0_table[index_a][bS[1]]; |
|
206 |
18805394 |
tc[2] = tc0_table[index_a][bS[2]]; |
|
207 |
18805394 |
tc[3] = tc0_table[index_a][bS[3]]; |
|
208 |
18805394 |
h->h264dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
|
209 |
} else { |
||
210 |
2320641 |
h->h264dsp.h264_v_loop_filter_luma_intra(pix, stride, alpha, beta); |
|
211 |
} |
||
212 |
} |
||
213 |
|||
214 |
28937988 |
static av_always_inline void filter_mb_edgech(uint8_t *pix, int stride, |
|
215 |
const int16_t bS[4], |
||
216 |
unsigned int qp, int a, int b, |
||
217 |
const H264Context *h, int intra) |
||
218 |
{ |
||
219 |
28937988 |
const unsigned int index_a = qp + a; |
|
220 |
28937988 |
const int alpha = alpha_table[index_a]; |
|
221 |
28937988 |
const int beta = beta_table[qp + b]; |
|
222 |
✓✓✗✓ |
28937988 |
if (alpha ==0 || beta == 0) return; |
223 |
|||
224 |
✓✓✗✓ |
52278194 |
if( bS[0] < 4 || !intra ) { |
225 |
int8_t tc[4]; |
||
226 |
23894824 |
tc[0] = tc0_table[index_a][bS[0]]+1; |
|
227 |
23894824 |
tc[1] = tc0_table[index_a][bS[1]]+1; |
|
228 |
23894824 |
tc[2] = tc0_table[index_a][bS[2]]+1; |
|
229 |
23894824 |
tc[3] = tc0_table[index_a][bS[3]]+1; |
|
230 |
23894824 |
h->h264dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
|
231 |
} else { |
||
232 |
4488546 |
h->h264dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta); |
|
233 |
} |
||
234 |
} |
||
235 |
|||
236 |
60584 |
static av_always_inline void h264_filter_mb_fast_internal(const H264Context *h, |
|
237 |
H264SliceContext *sl, |
||
238 |
int mb_x, int mb_y, |
||
239 |
uint8_t *img_y, |
||
240 |
uint8_t *img_cb, |
||
241 |
uint8_t *img_cr, |
||
242 |
unsigned int linesize, |
||
243 |
unsigned int uvlinesize, |
||
244 |
int pixel_shift) |
||
245 |
{ |
||
246 |
60584 |
int chroma = CHROMA(h) && !(CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY)); |
|
247 |
60584 |
int chroma444 = CHROMA444(h); |
|
248 |
60584 |
int chroma422 = CHROMA422(h); |
|
249 |
|||
250 |
60584 |
int mb_xy = sl->mb_xy; |
|
251 |
60584 |
int left_type = sl->left_type[LTOP]; |
|
252 |
60584 |
int top_type = sl->top_type; |
|
253 |
|||
254 |
60584 |
int qp_bd_offset = 6 * (h->ps.sps->bit_depth_luma - 8); |
|
255 |
60584 |
int a = 52 + sl->slice_alpha_c0_offset - qp_bd_offset; |
|
256 |
60584 |
int b = 52 + sl->slice_beta_offset - qp_bd_offset; |
|
257 |
|||
258 |
60584 |
int mb_type = h->cur_pic.mb_type[mb_xy]; |
|
259 |
60584 |
int qp = h->cur_pic.qscale_table[mb_xy]; |
|
260 |
60584 |
int qp0 = h->cur_pic.qscale_table[mb_xy - 1]; |
|
261 |
60584 |
int qp1 = h->cur_pic.qscale_table[sl->top_mb_xy]; |
|
262 |
60584 |
int qpc = get_chroma_qp(h->ps.pps, 0, qp); |
|
263 |
60584 |
int qpc0 = get_chroma_qp(h->ps.pps, 0, qp0); |
|
264 |
60584 |
int qpc1 = get_chroma_qp(h->ps.pps, 0, qp1); |
|
265 |
60584 |
qp0 = (qp + qp0 + 1) >> 1; |
|
266 |
60584 |
qp1 = (qp + qp1 + 1) >> 1; |
|
267 |
60584 |
qpc0 = (qpc + qpc0 + 1) >> 1; |
|
268 |
60584 |
qpc1 = (qpc + qpc1 + 1) >> 1; |
|
269 |
|||
270 |
✓✓ | 60584 |
if( IS_INTRA(mb_type) ) { |
271 |
static const int16_t bS4[4] = {4,4,4,4}; |
||
272 |
static const int16_t bS3[4] = {3,3,3,3}; |
||
273 |
✗✓ | 8397 |
const int16_t *bSH = FIELD_PICTURE(h) ? bS3 : bS4; |
274 |
✓✓ | 8397 |
if(left_type) |
275 |
8033 |
filter_mb_edgev( &img_y[4*0<<pixel_shift], linesize, bS4, qp0, a, b, h, 1); |
|
276 |
✓✓ | 8397 |
if( IS_8x8DCT(mb_type) ) { |
277 |
2687 |
filter_mb_edgev( &img_y[4*2<<pixel_shift], linesize, bS3, qp, a, b, h, 0); |
|
278 |
✓✓ | 2687 |
if(top_type){ |
279 |
2649 |
filter_mb_edgeh( &img_y[4*0*linesize], linesize, bSH, qp1, a, b, h, 1); |
|
280 |
} |
||
281 |
2687 |
filter_mb_edgeh( &img_y[4*2*linesize], linesize, bS3, qp, a, b, h, 0); |
|
282 |
} else { |
||
283 |
5710 |
filter_mb_edgev( &img_y[4*1<<pixel_shift], linesize, bS3, qp, a, b, h, 0); |
|
284 |
5710 |
filter_mb_edgev( &img_y[4*2<<pixel_shift], linesize, bS3, qp, a, b, h, 0); |
|
285 |
5710 |
filter_mb_edgev( &img_y[4*3<<pixel_shift], linesize, bS3, qp, a, b, h, 0); |
|
286 |
✓✓ | 5710 |
if(top_type){ |
287 |
5459 |
filter_mb_edgeh( &img_y[4*0*linesize], linesize, bSH, qp1, a, b, h, 1); |
|
288 |
} |
||
289 |
5710 |
filter_mb_edgeh( &img_y[4*1*linesize], linesize, bS3, qp, a, b, h, 0); |
|
290 |
5710 |
filter_mb_edgeh( &img_y[4*2*linesize], linesize, bS3, qp, a, b, h, 0); |
|
291 |
5710 |
filter_mb_edgeh( &img_y[4*3*linesize], linesize, bS3, qp, a, b, h, 0); |
|
292 |
} |
||
293 |
✓✗ | 8397 |
if(chroma){ |
294 |
✗✓ | 8397 |
if(chroma444){ |
295 |
if(left_type){ |
||
296 |
filter_mb_edgev( &img_cb[4*0<<pixel_shift], linesize, bS4, qpc0, a, b, h, 1); |
||
297 |
filter_mb_edgev( &img_cr[4*0<<pixel_shift], linesize, bS4, qpc0, a, b, h, 1); |
||
298 |
} |
||
299 |
if( IS_8x8DCT(mb_type) ) { |
||
300 |
filter_mb_edgev( &img_cb[4*2<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
301 |
filter_mb_edgev( &img_cr[4*2<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
302 |
if(top_type){ |
||
303 |
filter_mb_edgeh( &img_cb[4*0*linesize], linesize, bSH, qpc1, a, b, h, 1 ); |
||
304 |
filter_mb_edgeh( &img_cr[4*0*linesize], linesize, bSH, qpc1, a, b, h, 1 ); |
||
305 |
} |
||
306 |
filter_mb_edgeh( &img_cb[4*2*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
307 |
filter_mb_edgeh( &img_cr[4*2*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
308 |
} else { |
||
309 |
filter_mb_edgev( &img_cb[4*1<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
310 |
filter_mb_edgev( &img_cr[4*1<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
311 |
filter_mb_edgev( &img_cb[4*2<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
312 |
filter_mb_edgev( &img_cr[4*2<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
313 |
filter_mb_edgev( &img_cb[4*3<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
314 |
filter_mb_edgev( &img_cr[4*3<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
315 |
if(top_type){ |
||
316 |
filter_mb_edgeh( &img_cb[4*0*linesize], linesize, bSH, qpc1, a, b, h, 1); |
||
317 |
filter_mb_edgeh( &img_cr[4*0*linesize], linesize, bSH, qpc1, a, b, h, 1); |
||
318 |
} |
||
319 |
filter_mb_edgeh( &img_cb[4*1*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
320 |
filter_mb_edgeh( &img_cr[4*1*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
321 |
filter_mb_edgeh( &img_cb[4*2*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
322 |
filter_mb_edgeh( &img_cr[4*2*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
323 |
filter_mb_edgeh( &img_cb[4*3*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
324 |
filter_mb_edgeh( &img_cr[4*3*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
325 |
} |
||
326 |
✗✓ | 8397 |
}else if(chroma422){ |
327 |
if(left_type){ |
||
328 |
filter_mb_edgecv(&img_cb[2*0<<pixel_shift], uvlinesize, bS4, qpc0, a, b, h, 1); |
||
329 |
filter_mb_edgecv(&img_cr[2*0<<pixel_shift], uvlinesize, bS4, qpc0, a, b, h, 1); |
||
330 |
} |
||
331 |
filter_mb_edgecv(&img_cb[2*2<<pixel_shift], uvlinesize, bS3, qpc, a, b, h, 0); |
||
332 |
filter_mb_edgecv(&img_cr[2*2<<pixel_shift], uvlinesize, bS3, qpc, a, b, h, 0); |
||
333 |
if(top_type){ |
||
334 |
filter_mb_edgech(&img_cb[4*0*uvlinesize], uvlinesize, bSH, qpc1, a, b, h, 1); |
||
335 |
filter_mb_edgech(&img_cr[4*0*uvlinesize], uvlinesize, bSH, qpc1, a, b, h, 1); |
||
336 |
} |
||
337 |
filter_mb_edgech(&img_cb[4*1*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
338 |
filter_mb_edgech(&img_cr[4*1*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
339 |
filter_mb_edgech(&img_cb[4*2*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
340 |
filter_mb_edgech(&img_cr[4*2*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
341 |
filter_mb_edgech(&img_cb[4*3*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
342 |
filter_mb_edgech(&img_cr[4*3*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
343 |
}else{ |
||
344 |
✓✓ | 8397 |
if(left_type){ |
345 |
8033 |
filter_mb_edgecv( &img_cb[2*0<<pixel_shift], uvlinesize, bS4, qpc0, a, b, h, 1); |
|
346 |
8033 |
filter_mb_edgecv( &img_cr[2*0<<pixel_shift], uvlinesize, bS4, qpc0, a, b, h, 1); |
|
347 |
} |
||
348 |
8397 |
filter_mb_edgecv( &img_cb[2*2<<pixel_shift], uvlinesize, bS3, qpc, a, b, h, 0); |
|
349 |
8397 |
filter_mb_edgecv( &img_cr[2*2<<pixel_shift], uvlinesize, bS3, qpc, a, b, h, 0); |
|
350 |
✓✓ | 8397 |
if(top_type){ |
351 |
8108 |
filter_mb_edgech( &img_cb[2*0*uvlinesize], uvlinesize, bSH, qpc1, a, b, h, 1); |
|
352 |
8108 |
filter_mb_edgech( &img_cr[2*0*uvlinesize], uvlinesize, bSH, qpc1, a, b, h, 1); |
|
353 |
} |
||
354 |
8397 |
filter_mb_edgech( &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
|
355 |
8397 |
filter_mb_edgech( &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
|
356 |
} |
||
357 |
} |
||
358 |
8397 |
return; |
|
359 |
} else { |
||
360 |
52187 |
LOCAL_ALIGNED(8, int16_t, bS, [2], [4][4]); |
|
361 |
int edges; |
||
362 |
✓✓✓✓ ✓✗ |
52187 |
if( IS_8x8DCT(mb_type) && (sl->cbp&7) == 7 && !chroma444 ) { |
363 |
3475 |
edges = 4; |
|
364 |
3475 |
AV_WN64A(bS[0][0], 0x0002000200020002ULL); |
|
365 |
3475 |
AV_WN64A(bS[0][2], 0x0002000200020002ULL); |
|
366 |
3475 |
AV_WN64A(bS[1][0], 0x0002000200020002ULL); |
|
367 |
3475 |
AV_WN64A(bS[1][2], 0x0002000200020002ULL); |
|
368 |
} else { |
||
369 |
48712 |
int mask_edge1 = (3*(((5*mb_type)>>5)&1)) | (mb_type>>4); //(mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : (mb_type & MB_TYPE_16x8) ? 1 : 0; |
|
370 |
48712 |
int mask_edge0 = 3*((mask_edge1>>1) & ((5*left_type)>>5)&1); // (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) && (h->left_type[LTOP] & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : 0; |
|
371 |
48712 |
int step = 1+(mb_type>>24); //IS_8x8DCT(mb_type) ? 2 : 1; |
|
372 |
48712 |
edges = 4 - 3*((mb_type>>3) & !(sl->cbp & 15)); //(mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; |
|
373 |
48712 |
h->h264dsp.h264_loop_filter_strength(bS, sl->non_zero_count_cache, sl->ref_cache, sl->mv_cache, |
|
374 |
48712 |
sl->list_count==2, edges, step, mask_edge0, mask_edge1, FIELD_PICTURE(h)); |
|
375 |
} |
||
376 |
✓✓ | 52187 |
if( IS_INTRA(left_type) ) |
377 |
1764 |
AV_WN64A(bS[0][0], 0x0004000400040004ULL); |
|
378 |
✓✓ | 52187 |
if( IS_INTRA(top_type) ) |
379 |
✗✓ | 1904 |
AV_WN64A(bS[1][0], FIELD_PICTURE(h) ? 0x0003000300030003ULL : 0x0004000400040004ULL); |
380 |
|||
381 |
#define FILTER(hv,dir,edge,intra)\ |
||
382 |
if(AV_RN64A(bS[dir][edge])) { \ |
||
383 |
filter_mb_edge##hv( &img_y[4*edge*(dir?linesize:1<<pixel_shift)], linesize, bS[dir][edge], edge ? qp : qp##dir, a, b, h, intra );\ |
||
384 |
if(chroma){\ |
||
385 |
if(chroma444){\ |
||
386 |
filter_mb_edge##hv( &img_cb[4*edge*(dir?linesize:1<<pixel_shift)], linesize, bS[dir][edge], edge ? qpc : qpc##dir, a, b, h, intra );\ |
||
387 |
filter_mb_edge##hv( &img_cr[4*edge*(dir?linesize:1<<pixel_shift)], linesize, bS[dir][edge], edge ? qpc : qpc##dir, a, b, h, intra );\ |
||
388 |
} else if(!(edge&1)) {\ |
||
389 |
filter_mb_edgec##hv( &img_cb[2*edge*(dir?uvlinesize:1<<pixel_shift)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir, a, b, h, intra );\ |
||
390 |
filter_mb_edgec##hv( &img_cr[2*edge*(dir?uvlinesize:1<<pixel_shift)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir, a, b, h, intra );\ |
||
391 |
}\ |
||
392 |
}\ |
||
393 |
} |
||
394 |
✓✓ | 52187 |
if(left_type) |
395 |
✓✓✓✗ ✗✓ |
50341 |
FILTER(v,0,0,1); |
396 |
✓✓ | 52187 |
if( edges == 1 ) { |
397 |
✓✓ | 29051 |
if(top_type) |
398 |
✓✓✓✗ ✗✓ |
27541 |
FILTER(h,1,0,1); |
399 |
✓✓ | 23136 |
} else if( IS_8x8DCT(mb_type) ) { |
400 |
✓✗✓✗ ✗✓ |
9695 |
FILTER(v,0,2,0); |
401 |
✓✓ | 9695 |
if(top_type) |
402 |
✓✓✓✗ ✗✓ |
9681 |
FILTER(h,1,0,1); |
403 |
✓✗✓✗ ✗✓ |
9695 |
FILTER(h,1,2,0); |
404 |
} else { |
||
405 |
✓✓✓✗ ✗✓ |
13441 |
FILTER(v,0,1,0); |
406 |
✓✓✓✗ ✗✓ |
13441 |
FILTER(v,0,2,0); |
407 |
✓✓✓✗ ✗✓ |
13441 |
FILTER(v,0,3,0); |
408 |
✓✓ | 13441 |
if(top_type) |
409 |
✓✓✓✗ ✗✓ |
12962 |
FILTER(h,1,0,1); |
410 |
✓✓✓✗ ✗✓ |
13441 |
FILTER(h,1,1,0); |
411 |
✓✓✓✗ ✗✓ |
13441 |
FILTER(h,1,2,0); |
412 |
✓✓✓✗ ✗✓ |
13441 |
FILTER(h,1,3,0); |
413 |
} |
||
414 |
#undef FILTER |
||
415 |
} |
||
416 |
} |
||
417 |
|||
418 |
8301751 |
void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, |
|
419 |
int mb_x, int mb_y, uint8_t *img_y, |
||
420 |
uint8_t *img_cb, uint8_t *img_cr, |
||
421 |
unsigned int linesize, unsigned int uvlinesize) |
||
422 |
{ |
||
423 |
av_assert2(!FRAME_MBAFF(h)); |
||
424 |
✓✓✗✓ |
8301751 |
if(!h->h264dsp.h264_loop_filter_strength || h->ps.pps->chroma_qp_diff) { |
425 |
8241167 |
ff_h264_filter_mb(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize); |
|
426 |
8241167 |
return; |
|
427 |
} |
||
428 |
|||
429 |
#if CONFIG_SMALL |
||
430 |
h264_filter_mb_fast_internal(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, h->pixel_shift); |
||
431 |
#else |
||
432 |
✗✓ | 60584 |
if(h->pixel_shift){ |
433 |
h264_filter_mb_fast_internal(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 1); |
||
434 |
}else{ |
||
435 |
60584 |
h264_filter_mb_fast_internal(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 0); |
|
436 |
} |
||
437 |
#endif |
||
438 |
} |
||
439 |
|||
440 |
29010192 |
static int check_mv(H264SliceContext *sl, long b_idx, long bn_idx, int mvy_limit) |
|
441 |
{ |
||
442 |
int v; |
||
443 |
|||
444 |
29010192 |
v = sl->ref_cache[0][b_idx] != sl->ref_cache[0][bn_idx]; |
|
445 |
✓✓✓✓ |
29010192 |
if (!v && sl->ref_cache[0][b_idx] != -1) |
446 |
23148402 |
v = sl->mv_cache[0][b_idx][0] - sl->mv_cache[0][bn_idx][0] + 3 >= 7U | |
|
447 |
23148402 |
FFABS(sl->mv_cache[0][b_idx][1] - sl->mv_cache[0][bn_idx][1]) >= mvy_limit; |
|
448 |
|||
449 |
✓✓ | 29010192 |
if (sl->list_count == 2) { |
450 |
✓✓ | 14732786 |
if(!v) |
451 |
11425317 |
v = sl->ref_cache[1][b_idx] != sl->ref_cache[1][bn_idx] | |
|
452 |
11425317 |
sl->mv_cache[1][b_idx][0] - sl->mv_cache[1][bn_idx][0] + 3 >= 7U | |
|
453 |
11425317 |
FFABS(sl->mv_cache[1][b_idx][1] - sl->mv_cache[1][bn_idx][1]) >= mvy_limit; |
|
454 |
|||
455 |
✓✓ | 14732786 |
if(v){ |
456 |
4733018 |
if (sl->ref_cache[0][b_idx] != sl->ref_cache[1][bn_idx] | |
|
457 |
✓✓ | 4733018 |
sl->ref_cache[1][b_idx] != sl->ref_cache[0][bn_idx]) |
458 |
4376180 |
return 1; |
|
459 |
return |
||
460 |
356838 |
sl->mv_cache[0][b_idx][0] - sl->mv_cache[1][bn_idx][0] + 3 >= 7U | |
|
461 |
356838 |
FFABS(sl->mv_cache[0][b_idx][1] - sl->mv_cache[1][bn_idx][1]) >= mvy_limit | |
|
462 |
356838 |
sl->mv_cache[1][b_idx][0] - sl->mv_cache[0][bn_idx][0] + 3 >= 7U | |
|
463 |
356838 |
FFABS(sl->mv_cache[1][b_idx][1] - sl->mv_cache[0][bn_idx][1]) >= mvy_limit; |
|
464 |
} |
||
465 |
} |
||
466 |
|||
467 |
24277174 |
return v; |
|
468 |
} |
||
469 |
|||
470 |
19699314 |
static av_always_inline void filter_mb_dir(const H264Context *h, H264SliceContext *sl, |
|
471 |
int mb_x, int mb_y, |
||
472 |
uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, |
||
473 |
unsigned int linesize, unsigned int uvlinesize, |
||
474 |
int mb_xy, int mb_type, int mvy_limit, |
||
475 |
int first_vertical_edge_done, int a, int b, |
||
476 |
int chroma, int dir) |
||
477 |
{ |
||
478 |
int edge; |
||
479 |
int chroma_qp_avg[2]; |
||
480 |
19699314 |
int chroma444 = CHROMA444(h); |
|
481 |
19699314 |
int chroma422 = CHROMA422(h); |
|
482 |
✓✓ | 19699314 |
const int mbm_xy = dir == 0 ? mb_xy -1 : sl->top_mb_xy; |
483 |
✓✓ | 19699314 |
const int mbm_type = dir == 0 ? sl->left_type[LTOP] : sl->top_type; |
484 |
|||
485 |
// how often to recheck mv-based bS when iterating between edges |
||
486 |
static const uint8_t mask_edge_tab[2][8]={{0,3,3,3,1,1,1,1}, |
||
487 |
{0,3,1,1,3,3,3,3}}; |
||
488 |
19699314 |
const int mask_edge = mask_edge_tab[dir][(mb_type>>3)&7]; |
|
489 |
✓✓✓✓ |
19699314 |
const int edges = mask_edge== 3 && !(sl->cbp&15) ? 1 : 4; |
490 |
|||
491 |
// how often to recheck mv-based bS when iterating along each edge |
||
492 |
19699314 |
const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); |
|
493 |
|||
494 |
✓✓✓✓ |
19699314 |
if(mbm_type && !first_vertical_edge_done){ |
495 |
|||
496 |
✓✓✓✓ ✓✓ |
18550431 |
if (FRAME_MBAFF(h) && (dir == 1) && ((mb_y&1) == 0) |
497 |
✓✓ | 718622 |
&& IS_INTERLACED(mbm_type&~mb_type) |
498 |
91625 |
) { |
|
499 |
// This is a special case in the norm where the filtering must |
||
500 |
// be done twice (one each of the field) even if we are in a |
||
501 |
// frame macroblock. |
||
502 |
// |
||
503 |
91625 |
unsigned int tmp_linesize = 2 * linesize; |
|
504 |
91625 |
unsigned int tmp_uvlinesize = 2 * uvlinesize; |
|
505 |
91625 |
int mbn_xy = mb_xy - 2 * h->mb_stride; |
|
506 |
int j; |
||
507 |
|||
508 |
✓✓ | 274875 |
for(j=0; j<2; j++, mbn_xy += h->mb_stride){ |
509 |
183250 |
LOCAL_ALIGNED(8, int16_t, bS, [4]); |
|
510 |
int qp; |
||
511 |
✓✓ | 183250 |
if (IS_INTRA(mb_type | h->cur_pic.mb_type[mbn_xy])) { |
512 |
101718 |
AV_WN64A(bS, 0x0003000300030003ULL); |
|
513 |
} else { |
||
514 |
✓✓✓✓ |
81532 |
if (!CABAC(h) && IS_8x8DCT(h->cur_pic.mb_type[mbn_xy])) { |
515 |
✓✓✓✓ |
924 |
bS[0]= 1+((h->cbp_table[mbn_xy] & 0x4000) || sl->non_zero_count_cache[scan8[0]+0]); |
516 |
✓✓✓✓ |
924 |
bS[1]= 1+((h->cbp_table[mbn_xy] & 0x4000) || sl->non_zero_count_cache[scan8[0]+1]); |
517 |
✓✓✓✓ |
924 |
bS[2]= 1+((h->cbp_table[mbn_xy] & 0x8000) || sl->non_zero_count_cache[scan8[0]+2]); |
518 |
✓✓✓✓ |
924 |
bS[3]= 1+((h->cbp_table[mbn_xy] & 0x8000) || sl->non_zero_count_cache[scan8[0]+3]); |
519 |
}else{ |
||
520 |
80608 |
const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy] + 3*4; |
|
521 |
int i; |
||
522 |
✓✓ | 403040 |
for( i = 0; i < 4; i++ ) { |
523 |
✓✓ | 322432 |
bS[i] = 1 + !!(sl->non_zero_count_cache[scan8[0]+i] | mbn_nnz[i]); |
524 |
} |
||
525 |
} |
||
526 |
} |
||
527 |
// Do not use s->qscale as luma quantizer because it has not the same |
||
528 |
// value in IPCM macroblocks. |
||
529 |
183250 |
qp = (h->cur_pic.qscale_table[mb_xy] + h->cur_pic.qscale_table[mbn_xy] + 1) >> 1; |
|
530 |
ff_tlog(h->avctx, "filter mb:%d/%d dir:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, qp, tmp_linesize, tmp_uvlinesize); |
||
531 |
✓✓ | 916250 |
{ int i; for (i = 0; i < 4; i++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); } |
532 |
183250 |
filter_mb_edgeh( &img_y[j*linesize], tmp_linesize, bS, qp, a, b, h, 0 ); |
|
533 |
183250 |
chroma_qp_avg[0] = (sl->chroma_qp[0] + get_chroma_qp(h->ps.pps, 0, h->cur_pic.qscale_table[mbn_xy]) + 1) >> 1; |
|
534 |
183250 |
chroma_qp_avg[1] = (sl->chroma_qp[1] + get_chroma_qp(h->ps.pps, 1, h->cur_pic.qscale_table[mbn_xy]) + 1) >> 1; |
|
535 |
✓✗ | 183250 |
if (chroma) { |
536 |
✗✓ | 183250 |
if (chroma444) { |
537 |
filter_mb_edgeh (&img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp_avg[0], a, b, h, 0); |
||
538 |
filter_mb_edgeh (&img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp_avg[1], a, b, h, 0); |
||
539 |
} else { |
||
540 |
183250 |
filter_mb_edgech(&img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp_avg[0], a, b, h, 0); |
|
541 |
183250 |
filter_mb_edgech(&img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp_avg[1], a, b, h, 0); |
|
542 |
} |
||
543 |
} |
||
544 |
} |
||
545 |
}else{ |
||
546 |
18458806 |
LOCAL_ALIGNED(8, int16_t, bS, [4]); |
|
547 |
int qp; |
||
548 |
|||
549 |
✓✓ | 18458806 |
if( IS_INTRA(mb_type|mbm_type)) { |
550 |
5982298 |
AV_WN64A(bS, 0x0003000300030003ULL); |
|
551 |
✓✓ | 5982298 |
if ( (!IS_INTERLACED(mb_type|mbm_type)) |
552 |
✓✓✓✗ ✓✓ |
1354569 |
|| ((FRAME_MBAFF(h) || (h->picture_structure != PICT_FRAME)) && (dir == 0)) |
553 |
) |
||
554 |
5261733 |
AV_WN64A(bS, 0x0004000400040004ULL); |
|
555 |
} else { |
||
556 |
int i; |
||
557 |
int mv_done; |
||
558 |
|||
559 |
✓✓✓✓ ✓✓ |
12476508 |
if( dir && FRAME_MBAFF(h) && IS_INTERLACED(mb_type ^ mbm_type)) { |
560 |
83832 |
AV_WN64A(bS, 0x0001000100010001ULL); |
|
561 |
83832 |
mv_done = 1; |
|
562 |
} |
||
563 |
✓✓✓✓ |
12392676 |
else if( mask_par0 && ((mbm_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
564 |
8866046 |
int b_idx= 8 + 4; |
|
565 |
✓✓ | 8866046 |
int bn_idx= b_idx - (dir ? 8:1); |
566 |
|||
567 |
8866046 |
bS[0] = bS[1] = bS[2] = bS[3] = check_mv(sl, 8 + 4, bn_idx, mvy_limit); |
|
568 |
8866046 |
mv_done = 1; |
|
569 |
} |
||
570 |
else |
||
571 |
3526630 |
mv_done = 0; |
|
572 |
|||
573 |
✓✓ | 62382540 |
for( i = 0; i < 4; i++ ) { |
574 |
✓✓ | 49906032 |
int x = dir == 0 ? 0 : i; |
575 |
✓✓ | 49906032 |
int y = dir == 0 ? i : 0; |
576 |
49906032 |
int b_idx= 8 + 4 + x + 8*y; |
|
577 |
✓✓ | 49906032 |
int bn_idx= b_idx - (dir ? 8:1); |
578 |
|||
579 |
49906032 |
if (sl->non_zero_count_cache[b_idx] | |
|
580 |
✓✓ | 49906032 |
sl->non_zero_count_cache[bn_idx]) { |
581 |
14744730 |
bS[i] = 2; |
|
582 |
} |
||
583 |
✓✓ | 35161302 |
else if(!mv_done) |
584 |
{ |
||
585 |
6848854 |
bS[i] = check_mv(sl, b_idx, bn_idx, mvy_limit); |
|
586 |
} |
||
587 |
} |
||
588 |
} |
||
589 |
|||
590 |
/* Filter edge */ |
||
591 |
// Do not use s->qscale as luma quantizer because it has not the same |
||
592 |
// value in IPCM macroblocks. |
||
593 |
✓✓ | 18458806 |
if(bS[0]+bS[1]+bS[2]+bS[3]){ |
594 |
13538065 |
qp = (h->cur_pic.qscale_table[mb_xy] + h->cur_pic.qscale_table[mbm_xy] + 1) >> 1; |
|
595 |
//ff_tlog(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp[0], h->cur_pic.qscale_table[mbn_xy]); |
||
596 |
ff_tlog(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize); |
||
597 |
//{ int i; for (i = 0; i < 4; i++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); } |
||
598 |
13538065 |
chroma_qp_avg[0] = (sl->chroma_qp[0] + get_chroma_qp(h->ps.pps, 0, h->cur_pic.qscale_table[mbm_xy]) + 1) >> 1; |
|
599 |
13538065 |
chroma_qp_avg[1] = (sl->chroma_qp[1] + get_chroma_qp(h->ps.pps, 1, h->cur_pic.qscale_table[mbm_xy]) + 1) >> 1; |
|
600 |
✓✓ | 13538065 |
if( dir == 0 ) { |
601 |
6733345 |
filter_mb_edgev( &img_y[0], linesize, bS, qp, a, b, h, 1 ); |
|
602 |
✓✓ | 6733345 |
if (chroma) { |
603 |
✓✓ | 6670317 |
if (chroma444) { |
604 |
19305 |
filter_mb_edgev ( &img_cb[0], uvlinesize, bS, chroma_qp_avg[0], a, b, h, 1); |
|
605 |
19305 |
filter_mb_edgev ( &img_cr[0], uvlinesize, bS, chroma_qp_avg[1], a, b, h, 1); |
|
606 |
} else { |
||
607 |
6651012 |
filter_mb_edgecv( &img_cb[0], uvlinesize, bS, chroma_qp_avg[0], a, b, h, 1); |
|
608 |
6651012 |
filter_mb_edgecv( &img_cr[0], uvlinesize, bS, chroma_qp_avg[1], a, b, h, 1); |
|
609 |
} |
||
610 |
} |
||
611 |
} else { |
||
612 |
6804720 |
filter_mb_edgeh( &img_y[0], linesize, bS, qp, a, b, h, 1 ); |
|
613 |
✓✓ | 6804720 |
if (chroma) { |
614 |
✓✓ | 6740945 |
if (chroma444) { |
615 |
19214 |
filter_mb_edgeh ( &img_cb[0], uvlinesize, bS, chroma_qp_avg[0], a, b, h, 1); |
|
616 |
19214 |
filter_mb_edgeh ( &img_cr[0], uvlinesize, bS, chroma_qp_avg[1], a, b, h, 1); |
|
617 |
} else { |
||
618 |
6721731 |
filter_mb_edgech( &img_cb[0], uvlinesize, bS, chroma_qp_avg[0], a, b, h, 1); |
|
619 |
6721731 |
filter_mb_edgech( &img_cr[0], uvlinesize, bS, chroma_qp_avg[1], a, b, h, 1); |
|
620 |
} |
||
621 |
} |
||
622 |
} |
||
623 |
} |
||
624 |
} |
||
625 |
} |
||
626 |
|||
627 |
/* Calculate bS */ |
||
628 |
✓✓ | 60261318 |
for( edge = 1; edge < edges; edge++ ) { |
629 |
40562004 |
LOCAL_ALIGNED(8, int16_t, bS, [4]); |
|
630 |
int qp; |
||
631 |
40562004 |
const int deblock_edge = !IS_8x8DCT(mb_type & (edge<<24)); // (edge&1) && IS_8x8DCT(mb_type) |
|
632 |
|||
633 |
✓✓✓✓ ✓✓ |
40562004 |
if (!deblock_edge && (!chroma422 || dir == 0)) |
634 |
11249109 |
continue; |
|
635 |
|||
636 |
✓✓ | 34019410 |
if( IS_INTRA(mb_type)) { |
637 |
13235330 |
AV_WN64A(bS, 0x0003000300030003ULL); |
|
638 |
} else { |
||
639 |
int i; |
||
640 |
int mv_done; |
||
641 |
|||
642 |
✓✓ | 20784080 |
if( edge & mask_edge ) { |
643 |
13343915 |
AV_ZERO64(bS); |
|
644 |
13343915 |
mv_done = 1; |
|
645 |
} |
||
646 |
✓✓ | 7440165 |
else if( mask_par0 ) { |
647 |
✓✓ | 860237 |
int b_idx= 8 + 4 + edge * (dir ? 8:1); |
648 |
✓✓ | 860237 |
int bn_idx= b_idx - (dir ? 8:1); |
649 |
|||
650 |
860237 |
bS[0] = bS[1] = bS[2] = bS[3] = check_mv(sl, b_idx, bn_idx, mvy_limit); |
|
651 |
860237 |
mv_done = 1; |
|
652 |
} |
||
653 |
else |
||
654 |
6579928 |
mv_done = 0; |
|
655 |
|||
656 |
✓✓ | 103920400 |
for( i = 0; i < 4; i++ ) { |
657 |
✓✓ | 83136320 |
int x = dir == 0 ? edge : i; |
658 |
✓✓ | 83136320 |
int y = dir == 0 ? i : edge; |
659 |
83136320 |
int b_idx= 8 + 4 + x + 8*y; |
|
660 |
✓✓ | 83136320 |
int bn_idx= b_idx - (dir ? 8:1); |
661 |
|||
662 |
83136320 |
if (sl->non_zero_count_cache[b_idx] | |
|
663 |
✓✓ | 83136320 |
sl->non_zero_count_cache[bn_idx]) { |
664 |
40341613 |
bS[i] = 2; |
|
665 |
} |
||
666 |
✓✓ | 42794707 |
else if(!mv_done) |
667 |
{ |
||
668 |
12435055 |
bS[i] = check_mv(sl, b_idx, bn_idx, mvy_limit); |
|
669 |
} |
||
670 |
} |
||
671 |
|||
672 |
✓✓ | 20784080 |
if(bS[0]+bS[1]+bS[2]+bS[3] == 0) |
673 |
4706515 |
continue; |
|
674 |
} |
||
675 |
|||
676 |
/* Filter edge */ |
||
677 |
// Do not use s->qscale as luma quantizer because it has not the same |
||
678 |
// value in IPCM macroblocks. |
||
679 |
29312895 |
qp = h->cur_pic.qscale_table[mb_xy]; |
|
680 |
//ff_tlog(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp[0], h->cur_pic.qscale_table[mbn_xy]); |
||
681 |
ff_tlog(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize); |
||
682 |
//{ int i; for (i = 0; i < 4; i++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); } |
||
683 |
✓✓ | 29312895 |
if( dir == 0 ) { |
684 |
14275111 |
filter_mb_edgev( &img_y[4*edge << h->pixel_shift], linesize, bS, qp, a, b, h, 0 ); |
|
685 |
✓✓ | 14275111 |
if (chroma) { |
686 |
✓✓ | 14144117 |
if (chroma444) { |
687 |
27841 |
filter_mb_edgev ( &img_cb[4*edge << h->pixel_shift], uvlinesize, bS, sl->chroma_qp[0], a, b, h, 0); |
|
688 |
27841 |
filter_mb_edgev ( &img_cr[4*edge << h->pixel_shift], uvlinesize, bS, sl->chroma_qp[1], a, b, h, 0); |
|
689 |
✓✓ | 14116276 |
} else if( (edge&1) == 0 ) { |
690 |
6139879 |
filter_mb_edgecv( &img_cb[2*edge << h->pixel_shift], uvlinesize, bS, sl->chroma_qp[0], a, b, h, 0); |
|
691 |
6139879 |
filter_mb_edgecv( &img_cr[2*edge << h->pixel_shift], uvlinesize, bS, sl->chroma_qp[1], a, b, h, 0); |
|
692 |
} |
||
693 |
} |
||
694 |
} else { |
||
695 |
✓✓ | 15037784 |
if (chroma422) { |
696 |
✓✓ | 2064167 |
if (deblock_edge) |
697 |
1290264 |
filter_mb_edgeh(&img_y[4*edge*linesize], linesize, bS, qp, a, b, h, 0); |
|
698 |
✓✗ | 2064167 |
if (chroma) { |
699 |
2064167 |
filter_mb_edgech(&img_cb[4*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[0], a, b, h, 0); |
|
700 |
2064167 |
filter_mb_edgech(&img_cr[4*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[1], a, b, h, 0); |
|
701 |
} |
||
702 |
} else { |
||
703 |
12973617 |
filter_mb_edgeh(&img_y[4*edge*linesize], linesize, bS, qp, a, b, h, 0); |
|
704 |
✓✓ | 12973617 |
if (chroma) { |
705 |
✓✓ | 12842902 |
if (chroma444) { |
706 |
28142 |
filter_mb_edgeh (&img_cb[4*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[0], a, b, h, 0); |
|
707 |
28142 |
filter_mb_edgeh (&img_cr[4*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[1], a, b, h, 0); |
|
708 |
✓✓ | 12814760 |
} else if ((edge&1) == 0) { |
709 |
5435021 |
filter_mb_edgech(&img_cb[2*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[0], a, b, h, 0); |
|
710 |
5435021 |
filter_mb_edgech(&img_cr[2*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[1], a, b, h, 0); |
|
711 |
} |
||
712 |
} |
||
713 |
} |
||
714 |
} |
||
715 |
} |
||
716 |
19699314 |
} |
|
717 |
|||
718 |
9849657 |
void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, |
|
719 |
int mb_x, int mb_y, |
||
720 |
uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, |
||
721 |
unsigned int linesize, unsigned int uvlinesize) |
||
722 |
{ |
||
723 |
9849657 |
const int mb_xy= mb_x + mb_y*h->mb_stride; |
|
724 |
9849657 |
const int mb_type = h->cur_pic.mb_type[mb_xy]; |
|
725 |
✓✓ | 9849657 |
const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4; |
726 |
9849657 |
int first_vertical_edge_done = 0; |
|
727 |
9849657 |
int chroma = CHROMA(h) && !(CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY)); |
|
728 |
9849657 |
int qp_bd_offset = 6 * (h->ps.sps->bit_depth_luma - 8); |
|
729 |
9849657 |
int a = 52 + sl->slice_alpha_c0_offset - qp_bd_offset; |
|
730 |
9849657 |
int b = 52 + sl->slice_beta_offset - qp_bd_offset; |
|
731 |
|||
732 |
✓✓ | 9849657 |
if (FRAME_MBAFF(h) |
733 |
// and current and left pair do not have the same interlaced type |
||
734 |
✓✓ | 1608490 |
&& IS_INTERLACED(mb_type ^ sl->left_type[LTOP]) |
735 |
// and left mb is in available to us |
||
736 |
✓✓ | 352491 |
&& sl->left_type[LTOP]) { |
737 |
/* First vertical edge is different in MBAFF frames |
||
738 |
* There are 8 different bS to compute and 2 different Qp |
||
739 |
*/ |
||
740 |
343038 |
LOCAL_ALIGNED(8, int16_t, bS, [8]); |
|
741 |
int qp[2]; |
||
742 |
int bqp[2]; |
||
743 |
int rqp[2]; |
||
744 |
int mb_qp, mbn0_qp, mbn1_qp; |
||
745 |
int i; |
||
746 |
343038 |
first_vertical_edge_done = 1; |
|
747 |
|||
748 |
✓✓ | 343038 |
if( IS_INTRA(mb_type) ) { |
749 |
166747 |
AV_WN64A(&bS[0], 0x0004000400040004ULL); |
|
750 |
166747 |
AV_WN64A(&bS[4], 0x0004000400040004ULL); |
|
751 |
} else { |
||
752 |
static const uint8_t offset[2][2][8]={ |
||
753 |
{ |
||
754 |
{3+4*0, 3+4*0, 3+4*0, 3+4*0, 3+4*1, 3+4*1, 3+4*1, 3+4*1}, |
||
755 |
{3+4*2, 3+4*2, 3+4*2, 3+4*2, 3+4*3, 3+4*3, 3+4*3, 3+4*3}, |
||
756 |
},{ |
||
757 |
{3+4*0, 3+4*1, 3+4*2, 3+4*3, 3+4*0, 3+4*1, 3+4*2, 3+4*3}, |
||
758 |
{3+4*0, 3+4*1, 3+4*2, 3+4*3, 3+4*0, 3+4*1, 3+4*2, 3+4*3}, |
||
759 |
} |
||
760 |
}; |
||
761 |
176291 |
const uint8_t *off= offset[MB_FIELD(sl)][mb_y&1]; |
|
762 |
✓✓ | 1586619 |
for( i = 0; i < 8; i++ ) { |
763 |
✓✓ | 1410328 |
int j= MB_FIELD(sl) ? i>>2 : i&1; |
764 |
1410328 |
int mbn_xy = sl->left_mb_xy[LEFT(j)]; |
|
765 |
1410328 |
int mbn_type = sl->left_type[LEFT(j)]; |
|
766 |
|||
767 |
✓✓ | 1410328 |
if( IS_INTRA( mbn_type ) ) |
768 |
158044 |
bS[i] = 4; |
|
769 |
else{ |
||
770 |
✓✓ | 1252284 |
bS[i] = 1 + !!(sl->non_zero_count_cache[12+8*(i>>1)] | |
771 |
✓✓ | 243500 |
((!h->ps.pps->cabac && IS_8x8DCT(mbn_type)) ? |
772 |
✓✓✓✓ |
31036 |
(h->cbp_table[mbn_xy] & (((MB_FIELD(sl) ? (i&2) : (mb_y&1)) ? 8 : 2) << 12)) |
773 |
✓✓ | 1283320 |
: |
774 |
1221248 |
h->non_zero_count[mbn_xy][ off[i] ])); |
|
775 |
} |
||
776 |
} |
||
777 |
} |
||
778 |
|||
779 |
343038 |
mb_qp = h->cur_pic.qscale_table[mb_xy]; |
|
780 |
343038 |
mbn0_qp = h->cur_pic.qscale_table[sl->left_mb_xy[0]]; |
|
781 |
343038 |
mbn1_qp = h->cur_pic.qscale_table[sl->left_mb_xy[1]]; |
|
782 |
343038 |
qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; |
|
783 |
343038 |
bqp[0] = (get_chroma_qp(h->ps.pps, 0, mb_qp) + |
|
784 |
343038 |
get_chroma_qp(h->ps.pps, 0, mbn0_qp) + 1) >> 1; |
|
785 |
343038 |
rqp[0] = (get_chroma_qp(h->ps.pps, 1, mb_qp) + |
|
786 |
343038 |
get_chroma_qp(h->ps.pps, 1, mbn0_qp) + 1) >> 1; |
|
787 |
343038 |
qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; |
|
788 |
343038 |
bqp[1] = (get_chroma_qp(h->ps.pps, 0, mb_qp) + |
|
789 |
343038 |
get_chroma_qp(h->ps.pps, 0, mbn1_qp) + 1 ) >> 1; |
|
790 |
343038 |
rqp[1] = (get_chroma_qp(h->ps.pps, 1, mb_qp) + |
|
791 |
343038 |
get_chroma_qp(h->ps.pps, 1, mbn1_qp) + 1 ) >> 1; |
|
792 |
|||
793 |
/* Filter edge */ |
||
794 |
ff_tlog(h->avctx, "filter mb:%d/%d MBAFF, QPy:%d/%d, QPb:%d/%d QPr:%d/%d ls:%d uvls:%d", mb_x, mb_y, qp[0], qp[1], bqp[0], bqp[1], rqp[0], rqp[1], linesize, uvlinesize); |
||
795 |
✓✓ | 3087342 |
{ int i; for (i = 0; i < 8; i++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); } |
796 |
✓✓ | 343038 |
if (MB_FIELD(sl)) { |
797 |
172381 |
filter_mb_mbaff_edgev ( h, img_y , linesize, bS , 1, qp [0], a, b, 1 ); |
|
798 |
172381 |
filter_mb_mbaff_edgev ( h, img_y + 8* linesize, linesize, bS+4, 1, qp [1], a, b, 1 ); |
|
799 |
✓✗ | 172381 |
if (chroma){ |
800 |
✗✓ | 172381 |
if (CHROMA444(h)) { |
801 |
filter_mb_mbaff_edgev ( h, img_cb, uvlinesize, bS , 1, bqp[0], a, b, 1 ); |
||
802 |
filter_mb_mbaff_edgev ( h, img_cb + 8*uvlinesize, uvlinesize, bS+4, 1, bqp[1], a, b, 1 ); |
||
803 |
filter_mb_mbaff_edgev ( h, img_cr, uvlinesize, bS , 1, rqp[0], a, b, 1 ); |
||
804 |
filter_mb_mbaff_edgev ( h, img_cr + 8*uvlinesize, uvlinesize, bS+4, 1, rqp[1], a, b, 1 ); |
||
805 |
✓✓ | 172381 |
} else if (CHROMA422(h)) { |
806 |
27784 |
filter_mb_mbaff_edgecv(h, img_cb, uvlinesize, bS , 1, bqp[0], a, b, 1); |
|
807 |
27784 |
filter_mb_mbaff_edgecv(h, img_cb + 8*uvlinesize, uvlinesize, bS+4, 1, bqp[1], a, b, 1); |
|
808 |
27784 |
filter_mb_mbaff_edgecv(h, img_cr, uvlinesize, bS , 1, rqp[0], a, b, 1); |
|
809 |
27784 |
filter_mb_mbaff_edgecv(h, img_cr + 8*uvlinesize, uvlinesize, bS+4, 1, rqp[1], a, b, 1); |
|
810 |
}else{ |
||
811 |
144597 |
filter_mb_mbaff_edgecv( h, img_cb, uvlinesize, bS , 1, bqp[0], a, b, 1 ); |
|
812 |
144597 |
filter_mb_mbaff_edgecv( h, img_cb + 4*uvlinesize, uvlinesize, bS+4, 1, bqp[1], a, b, 1 ); |
|
813 |
144597 |
filter_mb_mbaff_edgecv( h, img_cr, uvlinesize, bS , 1, rqp[0], a, b, 1 ); |
|
814 |
144597 |
filter_mb_mbaff_edgecv( h, img_cr + 4*uvlinesize, uvlinesize, bS+4, 1, rqp[1], a, b, 1 ); |
|
815 |
} |
||
816 |
} |
||
817 |
}else{ |
||
818 |
170657 |
filter_mb_mbaff_edgev ( h, img_y , 2* linesize, bS , 2, qp [0], a, b, 1 ); |
|
819 |
170657 |
filter_mb_mbaff_edgev ( h, img_y + linesize, 2* linesize, bS+1, 2, qp [1], a, b, 1 ); |
|
820 |
✓✗ | 170657 |
if (chroma){ |
821 |
✗✓ | 170657 |
if (CHROMA444(h)) { |
822 |
filter_mb_mbaff_edgev ( h, img_cb, 2*uvlinesize, bS , 2, bqp[0], a, b, 1 ); |
||
823 |
filter_mb_mbaff_edgev ( h, img_cb + uvlinesize, 2*uvlinesize, bS+1, 2, bqp[1], a, b, 1 ); |
||
824 |
filter_mb_mbaff_edgev ( h, img_cr, 2*uvlinesize, bS , 2, rqp[0], a, b, 1 ); |
||
825 |
filter_mb_mbaff_edgev ( h, img_cr + uvlinesize, 2*uvlinesize, bS+1, 2, rqp[1], a, b, 1 ); |
||
826 |
}else{ |
||
827 |
170657 |
filter_mb_mbaff_edgecv( h, img_cb, 2*uvlinesize, bS , 2, bqp[0], a, b, 1 ); |
|
828 |
170657 |
filter_mb_mbaff_edgecv( h, img_cb + uvlinesize, 2*uvlinesize, bS+1, 2, bqp[1], a, b, 1 ); |
|
829 |
170657 |
filter_mb_mbaff_edgecv( h, img_cr, 2*uvlinesize, bS , 2, rqp[0], a, b, 1 ); |
|
830 |
170657 |
filter_mb_mbaff_edgecv( h, img_cr + uvlinesize, 2*uvlinesize, bS+1, 2, rqp[1], a, b, 1 ); |
|
831 |
} |
||
832 |
} |
||
833 |
} |
||
834 |
} |
||
835 |
|||
836 |
#if CONFIG_SMALL |
||
837 |
{ |
||
838 |
int dir; |
||
839 |
for (dir = 0; dir < 2; dir++) |
||
840 |
filter_mb_dir(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, |
||
841 |
uvlinesize, mb_xy, mb_type, mvy_limit, |
||
842 |
dir ? 0 : first_vertical_edge_done, a, b, |
||
843 |
chroma, dir); |
||
844 |
} |
||
845 |
#else |
||
846 |
9849657 |
filter_mb_dir(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, first_vertical_edge_done, a, b, chroma, 0); |
|
847 |
9849657 |
filter_mb_dir(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, 0, a, b, chroma, 1); |
|
848 |
#endif |
||
849 |
9849657 |
} |
| Generated by: GCOVR (Version 4.1) |