| 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 "libavutil/mem_internal.h" |
||
31 |
#include "internal.h" |
||
32 |
#include "avcodec.h" |
||
33 |
#include "h264dec.h" |
||
34 |
#include "h264_ps.h" |
||
35 |
#include "mathops.h" |
||
36 |
#include "mpegutils.h" |
||
37 |
#include "rectangle.h" |
||
38 |
|||
39 |
/* Deblocking filter (p153) */ |
||
40 |
static const uint8_t alpha_table[52*3] = { |
||
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, 0, 0, 0, |
||
45 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
46 |
0, 0, 0, 0, 0, 0, 4, 4, 5, 6, |
||
47 |
7, 8, 9, 10, 12, 13, 15, 17, 20, 22, |
||
48 |
25, 28, 32, 36, 40, 45, 50, 56, 63, 71, |
||
49 |
80, 90,101,113,127,144,162,182,203,226, |
||
50 |
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 |
255,255,255,255,255,255,255,255,255,255,255,255,255, |
||
55 |
}; |
||
56 |
static const uint8_t beta_table[52*3] = { |
||
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, 0, 0, 0, |
||
61 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||
62 |
0, 0, 0, 0, 0, 0, 2, 2, 2, 3, |
||
63 |
3, 3, 3, 4, 4, 4, 6, 6, 7, 7, |
||
64 |
8, 8, 9, 9, 10, 10, 11, 11, 12, 12, |
||
65 |
13, 13, 14, 14, 15, 15, 16, 16, 17, 17, |
||
66 |
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 |
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, |
||
71 |
}; |
||
72 |
static const uint8_t tc0_table[52*3][4] = { |
||
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 }, {-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 }, |
||
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, 0 }, |
||
84 |
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 1 }, |
||
85 |
{-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 1, 1 }, {-1, 0, 1, 1 }, {-1, 1, 1, 1 }, |
||
86 |
{-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 }, |
||
87 |
{-1, 1, 1, 2 }, {-1, 1, 2, 3 }, {-1, 1, 2, 3 }, {-1, 2, 2, 3 }, {-1, 2, 2, 4 }, {-1, 2, 3, 4 }, |
||
88 |
{-1, 2, 3, 4 }, {-1, 3, 3, 5 }, {-1, 3, 4, 6 }, {-1, 3, 4, 6 }, {-1, 4, 5, 7 }, {-1, 4, 5, 8 }, |
||
89 |
{-1, 4, 6, 9 }, {-1, 5, 7,10 }, {-1, 6, 8,11 }, {-1, 6, 8,13 }, {-1, 7,10,14 }, {-1, 8,11,16 }, |
||
90 |
{-1, 9,12,18 }, {-1,10,13,20 }, {-1,11,15,23 }, {-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 }, {-1,13,17,25 }, {-1,13,17,25 }, |
||
99 |
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, |
||
100 |
}; |
||
101 |
|||
102 |
/* intra: 0 if this loopfilter call is guaranteed to be inter (bS < 4), 1 if it might be intra (bS == 4) */ |
||
103 |
21417275 |
static av_always_inline void filter_mb_edgev(uint8_t *pix, int stride, |
|
104 |
const int16_t bS[4], |
||
105 |
unsigned int qp, int a, int b, |
||
106 |
const H264Context *h, int intra) |
||
107 |
{ |
||
108 |
21417275 |
const unsigned int index_a = qp + a; |
|
109 |
21417275 |
const int alpha = alpha_table[index_a]; |
|
110 |
21417275 |
const int beta = beta_table[qp + b]; |
|
111 |
✓✓✗✓ |
21417275 |
if (alpha ==0 || beta == 0) return; |
112 |
|||
113 |
✓✓✗✓ |
39227964 |
if( bS[0] < 4 || !intra ) { |
114 |
int8_t tc[4]; |
||
115 |
18135837 |
tc[0] = tc0_table[index_a][bS[0]]; |
|
116 |
18135837 |
tc[1] = tc0_table[index_a][bS[1]]; |
|
117 |
18135837 |
tc[2] = tc0_table[index_a][bS[2]]; |
|
118 |
18135837 |
tc[3] = tc0_table[index_a][bS[3]]; |
|
119 |
18135837 |
h->h264dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
|
120 |
} else { |
||
121 |
2956290 |
h->h264dsp.h264_h_loop_filter_luma_intra(pix, stride, alpha, beta); |
|
122 |
} |
||
123 |
} |
||
124 |
|||
125 |
25896616 |
static av_always_inline void filter_mb_edgecv(uint8_t *pix, int stride, |
|
126 |
const int16_t bS[4], |
||
127 |
unsigned int qp, int a, int b, |
||
128 |
const H264Context *h, int intra) |
||
129 |
{ |
||
130 |
25896616 |
const unsigned int index_a = qp + a; |
|
131 |
25896616 |
const int alpha = alpha_table[index_a]; |
|
132 |
25896616 |
const int beta = beta_table[qp + b]; |
|
133 |
✓✓✗✓ |
25896616 |
if (alpha ==0 || beta == 0) return; |
134 |
|||
135 |
✓✓✗✓ |
44958403 |
if( bS[0] < 4 || !intra ) { |
136 |
int8_t tc[4]; |
||
137 |
19632151 |
tc[0] = tc0_table[index_a][bS[0]]+1; |
|
138 |
19632151 |
tc[1] = tc0_table[index_a][bS[1]]+1; |
|
139 |
19632151 |
tc[2] = tc0_table[index_a][bS[2]]+1; |
|
140 |
19632151 |
tc[3] = tc0_table[index_a][bS[3]]+1; |
|
141 |
19632151 |
h->h264dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
|
142 |
} else { |
||
143 |
5694101 |
h->h264dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta); |
|
144 |
} |
||
145 |
} |
||
146 |
|||
147 |
686076 |
static av_always_inline void filter_mb_mbaff_edgev(const H264Context *h, uint8_t *pix, |
|
148 |
int stride, |
||
149 |
const int16_t bS[7], int bsi, |
||
150 |
int qp, int a, int b, |
||
151 |
int intra) |
||
152 |
{ |
||
153 |
686076 |
const unsigned int index_a = qp + a; |
|
154 |
686076 |
const int alpha = alpha_table[index_a]; |
|
155 |
686076 |
const int beta = beta_table[qp + b]; |
|
156 |
✓✓✗✓ |
686076 |
if (alpha ==0 || beta == 0) return; |
157 |
|||
158 |
✓✓✗✓ |
967749 |
if( bS[0] < 4 || !intra ) { |
159 |
int8_t tc[4]; |
||
160 |
299912 |
tc[0] = tc0_table[index_a][bS[0*bsi]]; |
|
161 |
299912 |
tc[1] = tc0_table[index_a][bS[1*bsi]]; |
|
162 |
299912 |
tc[2] = tc0_table[index_a][bS[2*bsi]]; |
|
163 |
299912 |
tc[3] = tc0_table[index_a][bS[3*bsi]]; |
|
164 |
299912 |
h->h264dsp.h264_h_loop_filter_luma_mbaff(pix, stride, alpha, beta, tc); |
|
165 |
} else { |
||
166 |
367925 |
h->h264dsp.h264_h_loop_filter_luma_mbaff_intra(pix, stride, alpha, beta); |
|
167 |
} |
||
168 |
} |
||
169 |
|||
170 |
1372152 |
static av_always_inline void filter_mb_mbaff_edgecv(const H264Context *h, |
|
171 |
uint8_t *pix, int stride, |
||
172 |
const int16_t bS[7], |
||
173 |
int bsi, int qp, int a, |
||
174 |
int b, int intra) |
||
175 |
{ |
||
176 |
1372152 |
const unsigned int index_a = qp + a; |
|
177 |
1372152 |
const int alpha = alpha_table[index_a]; |
|
178 |
1372152 |
const int beta = beta_table[qp + b]; |
|
179 |
✓✓✗✓ |
1372152 |
if (alpha ==0 || beta == 0) return; |
180 |
|||
181 |
✓✓✗✓ |
1934448 |
if( bS[0] < 4 || !intra ) { |
182 |
int8_t tc[4]; |
||
183 |
599366 |
tc[0] = tc0_table[index_a][bS[0*bsi]] + 1; |
|
184 |
599366 |
tc[1] = tc0_table[index_a][bS[1*bsi]] + 1; |
|
185 |
599366 |
tc[2] = tc0_table[index_a][bS[2*bsi]] + 1; |
|
186 |
599366 |
tc[3] = tc0_table[index_a][bS[3*bsi]] + 1; |
|
187 |
599366 |
h->h264dsp.h264_h_loop_filter_chroma_mbaff(pix, stride, alpha, beta, tc); |
|
188 |
} else { |
||
189 |
735716 |
h->h264dsp.h264_h_loop_filter_chroma_mbaff_intra(pix, stride, alpha, beta); |
|
190 |
} |
||
191 |
} |
||
192 |
|||
193 |
21663301 |
static av_always_inline void filter_mb_edgeh(uint8_t *pix, int stride, |
|
194 |
const int16_t bS[4], |
||
195 |
unsigned int qp, int a, int b, |
||
196 |
const H264Context *h, int intra) |
||
197 |
{ |
||
198 |
21663301 |
const unsigned int index_a = qp + a; |
|
199 |
21663301 |
const int alpha = alpha_table[index_a]; |
|
200 |
21663301 |
const int beta = beta_table[qp + b]; |
|
201 |
✓✓✗✓ |
21663301 |
if (alpha ==0 || beta == 0) return; |
202 |
|||
203 |
✓✓✗✓ |
40306730 |
if( bS[0] < 4 || !intra ) { |
204 |
int8_t tc[4]; |
||
205 |
18975910 |
tc[0] = tc0_table[index_a][bS[0]]; |
|
206 |
18975910 |
tc[1] = tc0_table[index_a][bS[1]]; |
|
207 |
18975910 |
tc[2] = tc0_table[index_a][bS[2]]; |
|
208 |
18975910 |
tc[3] = tc0_table[index_a][bS[3]]; |
|
209 |
18975910 |
h->h264dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
|
210 |
} else { |
||
211 |
2354910 |
h->h264dsp.h264_v_loop_filter_luma_intra(pix, stride, alpha, beta); |
|
212 |
} |
||
213 |
} |
||
214 |
|||
215 |
29129872 |
static av_always_inline void filter_mb_edgech(uint8_t *pix, int stride, |
|
216 |
const int16_t bS[4], |
||
217 |
unsigned int qp, int a, int b, |
||
218 |
const H264Context *h, int intra) |
||
219 |
{ |
||
220 |
29129872 |
const unsigned int index_a = qp + a; |
|
221 |
29129872 |
const int alpha = alpha_table[index_a]; |
|
222 |
29129872 |
const int beta = beta_table[qp + b]; |
|
223 |
✓✓✗✓ |
29129872 |
if (alpha ==0 || beta == 0) return; |
224 |
|||
225 |
✓✓✗✓ |
52620246 |
if( bS[0] < 4 || !intra ) { |
226 |
int8_t tc[4]; |
||
227 |
24065486 |
tc[0] = tc0_table[index_a][bS[0]]+1; |
|
228 |
24065486 |
tc[1] = tc0_table[index_a][bS[1]]+1; |
|
229 |
24065486 |
tc[2] = tc0_table[index_a][bS[2]]+1; |
|
230 |
24065486 |
tc[3] = tc0_table[index_a][bS[3]]+1; |
|
231 |
24065486 |
h->h264dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
|
232 |
} else { |
||
233 |
4489274 |
h->h264dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta); |
|
234 |
} |
||
235 |
} |
||
236 |
|||
237 |
179006 |
static av_always_inline void h264_filter_mb_fast_internal(const H264Context *h, |
|
238 |
H264SliceContext *sl, |
||
239 |
int mb_x, int mb_y, |
||
240 |
uint8_t *img_y, |
||
241 |
uint8_t *img_cb, |
||
242 |
uint8_t *img_cr, |
||
243 |
unsigned int linesize, |
||
244 |
unsigned int uvlinesize, |
||
245 |
int pixel_shift) |
||
246 |
{ |
||
247 |
179006 |
int chroma = CHROMA(h) && !(CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY)); |
|
248 |
179006 |
int chroma444 = CHROMA444(h); |
|
249 |
179006 |
int chroma422 = CHROMA422(h); |
|
250 |
|||
251 |
179006 |
int mb_xy = sl->mb_xy; |
|
252 |
179006 |
int left_type = sl->left_type[LTOP]; |
|
253 |
179006 |
int top_type = sl->top_type; |
|
254 |
|||
255 |
179006 |
int qp_bd_offset = 6 * (h->ps.sps->bit_depth_luma - 8); |
|
256 |
179006 |
int a = 52 + sl->slice_alpha_c0_offset - qp_bd_offset; |
|
257 |
179006 |
int b = 52 + sl->slice_beta_offset - qp_bd_offset; |
|
258 |
|||
259 |
179006 |
int mb_type = h->cur_pic.mb_type[mb_xy]; |
|
260 |
179006 |
int qp = h->cur_pic.qscale_table[mb_xy]; |
|
261 |
179006 |
int qp0 = h->cur_pic.qscale_table[mb_xy - 1]; |
|
262 |
179006 |
int qp1 = h->cur_pic.qscale_table[sl->top_mb_xy]; |
|
263 |
179006 |
int qpc = get_chroma_qp(h->ps.pps, 0, qp); |
|
264 |
179006 |
int qpc0 = get_chroma_qp(h->ps.pps, 0, qp0); |
|
265 |
179006 |
int qpc1 = get_chroma_qp(h->ps.pps, 0, qp1); |
|
266 |
179006 |
qp0 = (qp + qp0 + 1) >> 1; |
|
267 |
179006 |
qp1 = (qp + qp1 + 1) >> 1; |
|
268 |
179006 |
qpc0 = (qpc + qpc0 + 1) >> 1; |
|
269 |
179006 |
qpc1 = (qpc + qpc1 + 1) >> 1; |
|
270 |
|||
271 |
✓✓ | 179006 |
if( IS_INTRA(mb_type) ) { |
272 |
static const int16_t bS4[4] = {4,4,4,4}; |
||
273 |
static const int16_t bS3[4] = {3,3,3,3}; |
||
274 |
✓✓ | 13515 |
const int16_t *bSH = FIELD_PICTURE(h) ? bS3 : bS4; |
275 |
✓✓ | 13515 |
if(left_type) |
276 |
13133 |
filter_mb_edgev( &img_y[4*0<<pixel_shift], linesize, bS4, qp0, a, b, h, 1); |
|
277 |
✓✓ | 13515 |
if( IS_8x8DCT(mb_type) ) { |
278 |
4971 |
filter_mb_edgev( &img_y[4*2<<pixel_shift], linesize, bS3, qp, a, b, h, 0); |
|
279 |
✓✓ | 4971 |
if(top_type){ |
280 |
4933 |
filter_mb_edgeh( &img_y[4*0*linesize], linesize, bSH, qp1, a, b, h, 1); |
|
281 |
} |
||
282 |
4971 |
filter_mb_edgeh( &img_y[4*2*linesize], linesize, bS3, qp, a, b, h, 0); |
|
283 |
} else { |
||
284 |
8544 |
filter_mb_edgev( &img_y[4*1<<pixel_shift], linesize, bS3, qp, a, b, h, 0); |
|
285 |
8544 |
filter_mb_edgev( &img_y[4*2<<pixel_shift], linesize, bS3, qp, a, b, h, 0); |
|
286 |
8544 |
filter_mb_edgev( &img_y[4*3<<pixel_shift], linesize, bS3, qp, a, b, h, 0); |
|
287 |
✓✓ | 8544 |
if(top_type){ |
288 |
8293 |
filter_mb_edgeh( &img_y[4*0*linesize], linesize, bSH, qp1, a, b, h, 1); |
|
289 |
} |
||
290 |
8544 |
filter_mb_edgeh( &img_y[4*1*linesize], linesize, bS3, qp, a, b, h, 0); |
|
291 |
8544 |
filter_mb_edgeh( &img_y[4*2*linesize], linesize, bS3, qp, a, b, h, 0); |
|
292 |
8544 |
filter_mb_edgeh( &img_y[4*3*linesize], linesize, bS3, qp, a, b, h, 0); |
|
293 |
} |
||
294 |
✓✗ | 13515 |
if(chroma){ |
295 |
✗✓ | 13515 |
if(chroma444){ |
296 |
if(left_type){ |
||
297 |
filter_mb_edgev( &img_cb[4*0<<pixel_shift], linesize, bS4, qpc0, a, b, h, 1); |
||
298 |
filter_mb_edgev( &img_cr[4*0<<pixel_shift], linesize, bS4, qpc0, a, b, h, 1); |
||
299 |
} |
||
300 |
if( IS_8x8DCT(mb_type) ) { |
||
301 |
filter_mb_edgev( &img_cb[4*2<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
302 |
filter_mb_edgev( &img_cr[4*2<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
303 |
if(top_type){ |
||
304 |
filter_mb_edgeh( &img_cb[4*0*linesize], linesize, bSH, qpc1, a, b, h, 1 ); |
||
305 |
filter_mb_edgeh( &img_cr[4*0*linesize], linesize, bSH, qpc1, a, b, h, 1 ); |
||
306 |
} |
||
307 |
filter_mb_edgeh( &img_cb[4*2*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
308 |
filter_mb_edgeh( &img_cr[4*2*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
309 |
} else { |
||
310 |
filter_mb_edgev( &img_cb[4*1<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
311 |
filter_mb_edgev( &img_cr[4*1<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
312 |
filter_mb_edgev( &img_cb[4*2<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
313 |
filter_mb_edgev( &img_cr[4*2<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
314 |
filter_mb_edgev( &img_cb[4*3<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
315 |
filter_mb_edgev( &img_cr[4*3<<pixel_shift], linesize, bS3, qpc, a, b, h, 0); |
||
316 |
if(top_type){ |
||
317 |
filter_mb_edgeh( &img_cb[4*0*linesize], linesize, bSH, qpc1, a, b, h, 1); |
||
318 |
filter_mb_edgeh( &img_cr[4*0*linesize], linesize, bSH, qpc1, a, b, h, 1); |
||
319 |
} |
||
320 |
filter_mb_edgeh( &img_cb[4*1*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
321 |
filter_mb_edgeh( &img_cr[4*1*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
322 |
filter_mb_edgeh( &img_cb[4*2*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
323 |
filter_mb_edgeh( &img_cr[4*2*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
324 |
filter_mb_edgeh( &img_cb[4*3*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
325 |
filter_mb_edgeh( &img_cr[4*3*linesize], linesize, bS3, qpc, a, b, h, 0); |
||
326 |
} |
||
327 |
✗✓ | 13515 |
}else if(chroma422){ |
328 |
if(left_type){ |
||
329 |
filter_mb_edgecv(&img_cb[2*0<<pixel_shift], uvlinesize, bS4, qpc0, a, b, h, 1); |
||
330 |
filter_mb_edgecv(&img_cr[2*0<<pixel_shift], uvlinesize, bS4, qpc0, a, b, h, 1); |
||
331 |
} |
||
332 |
filter_mb_edgecv(&img_cb[2*2<<pixel_shift], uvlinesize, bS3, qpc, a, b, h, 0); |
||
333 |
filter_mb_edgecv(&img_cr[2*2<<pixel_shift], uvlinesize, bS3, qpc, a, b, h, 0); |
||
334 |
if(top_type){ |
||
335 |
filter_mb_edgech(&img_cb[4*0*uvlinesize], uvlinesize, bSH, qpc1, a, b, h, 1); |
||
336 |
filter_mb_edgech(&img_cr[4*0*uvlinesize], uvlinesize, bSH, qpc1, a, b, h, 1); |
||
337 |
} |
||
338 |
filter_mb_edgech(&img_cb[4*1*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
339 |
filter_mb_edgech(&img_cr[4*1*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
340 |
filter_mb_edgech(&img_cb[4*2*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
341 |
filter_mb_edgech(&img_cr[4*2*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
342 |
filter_mb_edgech(&img_cb[4*3*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
343 |
filter_mb_edgech(&img_cr[4*3*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
||
344 |
}else{ |
||
345 |
✓✓ | 13515 |
if(left_type){ |
346 |
13133 |
filter_mb_edgecv( &img_cb[2*0<<pixel_shift], uvlinesize, bS4, qpc0, a, b, h, 1); |
|
347 |
13133 |
filter_mb_edgecv( &img_cr[2*0<<pixel_shift], uvlinesize, bS4, qpc0, a, b, h, 1); |
|
348 |
} |
||
349 |
13515 |
filter_mb_edgecv( &img_cb[2*2<<pixel_shift], uvlinesize, bS3, qpc, a, b, h, 0); |
|
350 |
13515 |
filter_mb_edgecv( &img_cr[2*2<<pixel_shift], uvlinesize, bS3, qpc, a, b, h, 0); |
|
351 |
✓✓ | 13515 |
if(top_type){ |
352 |
13226 |
filter_mb_edgech( &img_cb[2*0*uvlinesize], uvlinesize, bSH, qpc1, a, b, h, 1); |
|
353 |
13226 |
filter_mb_edgech( &img_cr[2*0*uvlinesize], uvlinesize, bSH, qpc1, a, b, h, 1); |
|
354 |
} |
||
355 |
13515 |
filter_mb_edgech( &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
|
356 |
13515 |
filter_mb_edgech( &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc, a, b, h, 0); |
|
357 |
} |
||
358 |
} |
||
359 |
13515 |
return; |
|
360 |
} else { |
||
361 |
165491 |
LOCAL_ALIGNED(8, int16_t, bS, [2], [4][4]); |
|
362 |
int edges; |
||
363 |
✓✓✓✓ ✓✗ |
165491 |
if( IS_8x8DCT(mb_type) && (sl->cbp&7) == 7 && !chroma444 ) { |
364 |
3569 |
edges = 4; |
|
365 |
3569 |
AV_WN64A(bS[0][0], 0x0002000200020002ULL); |
|
366 |
3569 |
AV_WN64A(bS[0][2], 0x0002000200020002ULL); |
|
367 |
3569 |
AV_WN64A(bS[1][0], 0x0002000200020002ULL); |
|
368 |
3569 |
AV_WN64A(bS[1][2], 0x0002000200020002ULL); |
|
369 |
} else { |
||
370 |
161922 |
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; |
|
371 |
161922 |
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; |
|
372 |
161922 |
int step = 1+(mb_type>>24); //IS_8x8DCT(mb_type) ? 2 : 1; |
|
373 |
161922 |
edges = 4 - 3*((mb_type>>3) & !(sl->cbp & 15)); //(mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; |
|
374 |
161922 |
h->h264dsp.h264_loop_filter_strength(bS, sl->non_zero_count_cache, sl->ref_cache, sl->mv_cache, |
|
375 |
161922 |
sl->list_count==2, edges, step, mask_edge0, mask_edge1, FIELD_PICTURE(h)); |
|
376 |
} |
||
377 |
✓✓ | 165491 |
if( IS_INTRA(left_type) ) |
378 |
2256 |
AV_WN64A(bS[0][0], 0x0004000400040004ULL); |
|
379 |
✓✓ | 165491 |
if( IS_INTRA(top_type) ) |
380 |
✓✓ | 2444 |
AV_WN64A(bS[1][0], FIELD_PICTURE(h) ? 0x0003000300030003ULL : 0x0004000400040004ULL); |
381 |
|||
382 |
#define FILTER(hv,dir,edge,intra)\ |
||
383 |
if(AV_RN64A(bS[dir][edge])) { \ |
||
384 |
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 );\ |
||
385 |
if(chroma){\ |
||
386 |
if(chroma444){\ |
||
387 |
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 );\ |
||
388 |
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 );\ |
||
389 |
} else if(!(edge&1)) {\ |
||
390 |
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 );\ |
||
391 |
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 );\ |
||
392 |
}\ |
||
393 |
}\ |
||
394 |
} |
||
395 |
✓✓ | 165491 |
if(left_type) |
396 |
✓✓✓✗ ✗✓ |
162171 |
FILTER(v,0,0,1); |
397 |
✓✓ | 165491 |
if( edges == 1 ) { |
398 |
✓✓ | 137905 |
if(top_type) |
399 |
✓✓✓✗ ✗✓ |
135411 |
FILTER(h,1,0,1); |
400 |
✓✓ | 27586 |
} else if( IS_8x8DCT(mb_type) ) { |
401 |
✓✗✓✗ ✗✓ |
11813 |
FILTER(v,0,2,0); |
402 |
✓✓ | 11813 |
if(top_type) |
403 |
✓✓✓✗ ✗✓ |
11755 |
FILTER(h,1,0,1); |
404 |
✓✗✓✗ ✗✓ |
11813 |
FILTER(h,1,2,0); |
405 |
} else { |
||
406 |
✓✓✓✗ ✗✓ |
15773 |
FILTER(v,0,1,0); |
407 |
✓✓✓✗ ✗✓ |
15773 |
FILTER(v,0,2,0); |
408 |
✓✓✓✗ ✗✓ |
15773 |
FILTER(v,0,3,0); |
409 |
✓✓ | 15773 |
if(top_type) |
410 |
✓✓✓✗ ✗✓ |
15292 |
FILTER(h,1,0,1); |
411 |
✓✓✓✗ ✗✓ |
15773 |
FILTER(h,1,1,0); |
412 |
✓✓✓✗ ✗✓ |
15773 |
FILTER(h,1,2,0); |
413 |
✓✓✓✗ ✗✓ |
15773 |
FILTER(h,1,3,0); |
414 |
} |
||
415 |
#undef FILTER |
||
416 |
} |
||
417 |
} |
||
418 |
|||
419 |
8804217 |
void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, |
|
420 |
int mb_x, int mb_y, uint8_t *img_y, |
||
421 |
uint8_t *img_cb, uint8_t *img_cr, |
||
422 |
unsigned int linesize, unsigned int uvlinesize) |
||
423 |
{ |
||
424 |
av_assert2(!FRAME_MBAFF(h)); |
||
425 |
✓✓✓✓ |
8804217 |
if(!h->h264dsp.h264_loop_filter_strength || h->ps.pps->chroma_qp_diff) { |
426 |
8625211 |
ff_h264_filter_mb(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize); |
|
427 |
8625211 |
return; |
|
428 |
} |
||
429 |
|||
430 |
#if CONFIG_SMALL |
||
431 |
h264_filter_mb_fast_internal(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, h->pixel_shift); |
||
432 |
#else |
||
433 |
✗✓ | 179006 |
if(h->pixel_shift){ |
434 |
h264_filter_mb_fast_internal(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 1); |
||
435 |
}else{ |
||
436 |
179006 |
h264_filter_mb_fast_internal(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 0); |
|
437 |
} |
||
438 |
#endif |
||
439 |
} |
||
440 |
|||
441 |
29760508 |
static int check_mv(H264SliceContext *sl, long b_idx, long bn_idx, int mvy_limit) |
|
442 |
{ |
||
443 |
int v; |
||
444 |
|||
445 |
29760508 |
v = sl->ref_cache[0][b_idx] != sl->ref_cache[0][bn_idx]; |
|
446 |
✓✓✓✓ |
29760508 |
if (!v && sl->ref_cache[0][b_idx] != -1) |
447 |
23863978 |
v = sl->mv_cache[0][b_idx][0] - sl->mv_cache[0][bn_idx][0] + 3 >= 7U | |
|
448 |
23863978 |
FFABS(sl->mv_cache[0][b_idx][1] - sl->mv_cache[0][bn_idx][1]) >= mvy_limit; |
|
449 |
|||
450 |
✓✓ | 29760508 |
if (sl->list_count == 2) { |
451 |
✓✓ | 15280676 |
if(!v) |
452 |
11956660 |
v = sl->ref_cache[1][b_idx] != sl->ref_cache[1][bn_idx] | |
|
453 |
11956660 |
sl->mv_cache[1][b_idx][0] - sl->mv_cache[1][bn_idx][0] + 3 >= 7U | |
|
454 |
11956660 |
FFABS(sl->mv_cache[1][b_idx][1] - sl->mv_cache[1][bn_idx][1]) >= mvy_limit; |
|
455 |
|||
456 |
✓✓ | 15280676 |
if(v){ |
457 |
4765805 |
if (sl->ref_cache[0][b_idx] != sl->ref_cache[1][bn_idx] | |
|
458 |
✓✓ | 4765805 |
sl->ref_cache[1][b_idx] != sl->ref_cache[0][bn_idx]) |
459 |
4408887 |
return 1; |
|
460 |
return |
||
461 |
356918 |
sl->mv_cache[0][b_idx][0] - sl->mv_cache[1][bn_idx][0] + 3 >= 7U | |
|
462 |
356918 |
FFABS(sl->mv_cache[0][b_idx][1] - sl->mv_cache[1][bn_idx][1]) >= mvy_limit | |
|
463 |
356918 |
sl->mv_cache[1][b_idx][0] - sl->mv_cache[0][bn_idx][0] + 3 >= 7U | |
|
464 |
356918 |
FFABS(sl->mv_cache[1][b_idx][1] - sl->mv_cache[0][bn_idx][1]) >= mvy_limit; |
|
465 |
} |
||
466 |
} |
||
467 |
|||
468 |
24994703 |
return v; |
|
469 |
} |
||
470 |
|||
471 |
20467402 |
static av_always_inline void filter_mb_dir(const H264Context *h, H264SliceContext *sl, |
|
472 |
int mb_x, int mb_y, |
||
473 |
uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, |
||
474 |
unsigned int linesize, unsigned int uvlinesize, |
||
475 |
int mb_xy, int mb_type, int mvy_limit, |
||
476 |
int first_vertical_edge_done, int a, int b, |
||
477 |
int chroma, int dir) |
||
478 |
{ |
||
479 |
int edge; |
||
480 |
int chroma_qp_avg[2]; |
||
481 |
20467402 |
int chroma444 = CHROMA444(h); |
|
482 |
20467402 |
int chroma422 = CHROMA422(h); |
|
483 |
✓✓ | 20467402 |
const int mbm_xy = dir == 0 ? mb_xy -1 : sl->top_mb_xy; |
484 |
✓✓ | 20467402 |
const int mbm_type = dir == 0 ? sl->left_type[LTOP] : sl->top_type; |
485 |
|||
486 |
// how often to recheck mv-based bS when iterating between edges |
||
487 |
static const uint8_t mask_edge_tab[2][8]={{0,3,3,3,1,1,1,1}, |
||
488 |
{0,3,1,1,3,3,3,3}}; |
||
489 |
20467402 |
const int mask_edge = mask_edge_tab[dir][(mb_type>>3)&7]; |
|
490 |
✓✓✓✓ |
20467402 |
const int edges = mask_edge== 3 && !(sl->cbp&15) ? 1 : 4; |
491 |
|||
492 |
// how often to recheck mv-based bS when iterating along each edge |
||
493 |
20467402 |
const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); |
|
494 |
|||
495 |
✓✓✓✓ |
20467402 |
if(mbm_type && !first_vertical_edge_done){ |
496 |
|||
497 |
✓✓✓✓ ✓✓ |
19310228 |
if (FRAME_MBAFF(h) && (dir == 1) && ((mb_y&1) == 0) |
498 |
✓✓ | 718622 |
&& IS_INTERLACED(mbm_type&~mb_type) |
499 |
91625 |
) { |
|
500 |
// This is a special case in the norm where the filtering must |
||
501 |
// be done twice (one each of the field) even if we are in a |
||
502 |
// frame macroblock. |
||
503 |
// |
||
504 |
91625 |
unsigned int tmp_linesize = 2 * linesize; |
|
505 |
91625 |
unsigned int tmp_uvlinesize = 2 * uvlinesize; |
|
506 |
91625 |
int mbn_xy = mb_xy - 2 * h->mb_stride; |
|
507 |
int j; |
||
508 |
|||
509 |
✓✓ | 274875 |
for(j=0; j<2; j++, mbn_xy += h->mb_stride){ |
510 |
183250 |
LOCAL_ALIGNED(8, int16_t, bS, [4]); |
|
511 |
int qp; |
||
512 |
✓✓ | 183250 |
if (IS_INTRA(mb_type | h->cur_pic.mb_type[mbn_xy])) { |
513 |
101718 |
AV_WN64A(bS, 0x0003000300030003ULL); |
|
514 |
} else { |
||
515 |
✓✓✓✓ |
81532 |
if (!CABAC(h) && IS_8x8DCT(h->cur_pic.mb_type[mbn_xy])) { |
516 |
✓✓✓✓ |
924 |
bS[0]= 1+((h->cbp_table[mbn_xy] & 0x4000) || sl->non_zero_count_cache[scan8[0]+0]); |
517 |
✓✓✓✓ |
924 |
bS[1]= 1+((h->cbp_table[mbn_xy] & 0x4000) || sl->non_zero_count_cache[scan8[0]+1]); |
518 |
✓✓✓✓ |
924 |
bS[2]= 1+((h->cbp_table[mbn_xy] & 0x8000) || sl->non_zero_count_cache[scan8[0]+2]); |
519 |
✓✓✓✓ |
924 |
bS[3]= 1+((h->cbp_table[mbn_xy] & 0x8000) || sl->non_zero_count_cache[scan8[0]+3]); |
520 |
}else{ |
||
521 |
80608 |
const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy] + 3*4; |
|
522 |
int i; |
||
523 |
✓✓ | 403040 |
for( i = 0; i < 4; i++ ) { |
524 |
✓✓ | 322432 |
bS[i] = 1 + !!(sl->non_zero_count_cache[scan8[0]+i] | mbn_nnz[i]); |
525 |
} |
||
526 |
} |
||
527 |
} |
||
528 |
// Do not use s->qscale as luma quantizer because it has not the same |
||
529 |
// value in IPCM macroblocks. |
||
530 |
183250 |
qp = (h->cur_pic.qscale_table[mb_xy] + h->cur_pic.qscale_table[mbn_xy] + 1) >> 1; |
|
531 |
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); |
||
532 |
✓✓ | 916250 |
{ int i; for (i = 0; i < 4; i++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); } |
533 |
183250 |
filter_mb_edgeh( &img_y[j*linesize], tmp_linesize, bS, qp, a, b, h, 0 ); |
|
534 |
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; |
|
535 |
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; |
|
536 |
✓✗ | 183250 |
if (chroma) { |
537 |
✗✓ | 183250 |
if (chroma444) { |
538 |
filter_mb_edgeh (&img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp_avg[0], a, b, h, 0); |
||
539 |
filter_mb_edgeh (&img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp_avg[1], a, b, h, 0); |
||
540 |
} else { |
||
541 |
183250 |
filter_mb_edgech(&img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp_avg[0], a, b, h, 0); |
|
542 |
183250 |
filter_mb_edgech(&img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp_avg[1], a, b, h, 0); |
|
543 |
} |
||
544 |
} |
||
545 |
} |
||
546 |
}else{ |
||
547 |
19218603 |
LOCAL_ALIGNED(8, int16_t, bS, [4]); |
|
548 |
int qp; |
||
549 |
|||
550 |
✓✓ | 19218603 |
if( IS_INTRA(mb_type|mbm_type)) { |
551 |
6036003 |
AV_WN64A(bS, 0x0003000300030003ULL); |
|
552 |
✓✓ | 6036003 |
if ( (!IS_INTERLACED(mb_type|mbm_type)) |
553 |
✓✓✓✗ ✓✓ |
1383664 |
|| ((FRAME_MBAFF(h) || (h->picture_structure != PICT_FRAME)) && (dir == 0)) |
554 |
) |
||
555 |
5300798 |
AV_WN64A(bS, 0x0004000400040004ULL); |
|
556 |
} else { |
||
557 |
int i; |
||
558 |
int mv_done; |
||
559 |
|||
560 |
✓✓✓✓ ✓✓ |
13182600 |
if( dir && FRAME_MBAFF(h) && IS_INTERLACED(mb_type ^ mbm_type)) { |
561 |
83832 |
AV_WN64A(bS, 0x0001000100010001ULL); |
|
562 |
83832 |
mv_done = 1; |
|
563 |
} |
||
564 |
✓✓✓✓ |
13098768 |
else if( mask_par0 && ((mbm_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
565 |
9563416 |
int b_idx= 8 + 4; |
|
566 |
✓✓ | 9563416 |
int bn_idx= b_idx - (dir ? 8:1); |
567 |
|||
568 |
9563416 |
bS[0] = bS[1] = bS[2] = bS[3] = check_mv(sl, 8 + 4, bn_idx, mvy_limit); |
|
569 |
9563416 |
mv_done = 1; |
|
570 |
} |
||
571 |
else |
||
572 |
3535352 |
mv_done = 0; |
|
573 |
|||
574 |
✓✓ | 65913000 |
for( i = 0; i < 4; i++ ) { |
575 |
✓✓ | 52730400 |
int x = dir == 0 ? 0 : i; |
576 |
✓✓ | 52730400 |
int y = dir == 0 ? i : 0; |
577 |
52730400 |
int b_idx= 8 + 4 + x + 8*y; |
|
578 |
✓✓ | 52730400 |
int bn_idx= b_idx - (dir ? 8:1); |
579 |
|||
580 |
52730400 |
if (sl->non_zero_count_cache[b_idx] | |
|
581 |
✓✓ | 52730400 |
sl->non_zero_count_cache[bn_idx]) { |
582 |
14795661 |
bS[i] = 2; |
|
583 |
} |
||
584 |
✓✓ | 37934739 |
else if(!mv_done) |
585 |
{ |
||
586 |
6869605 |
bS[i] = check_mv(sl, b_idx, bn_idx, mvy_limit); |
|
587 |
} |
||
588 |
} |
||
589 |
} |
||
590 |
|||
591 |
/* Filter edge */ |
||
592 |
// Do not use s->qscale as luma quantizer because it has not the same |
||
593 |
// value in IPCM macroblocks. |
||
594 |
✓✓ | 19218603 |
if(bS[0]+bS[1]+bS[2]+bS[3]){ |
595 |
13649709 |
qp = (h->cur_pic.qscale_table[mb_xy] + h->cur_pic.qscale_table[mbm_xy] + 1) >> 1; |
|
596 |
//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]); |
||
597 |
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); |
||
598 |
//{ int i; for (i = 0; i < 4; i++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); } |
||
599 |
13649709 |
chroma_qp_avg[0] = (sl->chroma_qp[0] + get_chroma_qp(h->ps.pps, 0, h->cur_pic.qscale_table[mbm_xy]) + 1) >> 1; |
|
600 |
13649709 |
chroma_qp_avg[1] = (sl->chroma_qp[1] + get_chroma_qp(h->ps.pps, 1, h->cur_pic.qscale_table[mbm_xy]) + 1) >> 1; |
|
601 |
✓✓ | 13649709 |
if( dir == 0 ) { |
602 |
6787967 |
filter_mb_edgev( &img_y[0], linesize, bS, qp, a, b, h, 1 ); |
|
603 |
✓✓ | 6787967 |
if (chroma) { |
604 |
✓✓ | 6724939 |
if (chroma444) { |
605 |
31200 |
filter_mb_edgev ( &img_cb[0], uvlinesize, bS, chroma_qp_avg[0], a, b, h, 1); |
|
606 |
31200 |
filter_mb_edgev ( &img_cr[0], uvlinesize, bS, chroma_qp_avg[1], a, b, h, 1); |
|
607 |
} else { |
||
608 |
6693739 |
filter_mb_edgecv( &img_cb[0], uvlinesize, bS, chroma_qp_avg[0], a, b, h, 1); |
|
609 |
6693739 |
filter_mb_edgecv( &img_cr[0], uvlinesize, bS, chroma_qp_avg[1], a, b, h, 1); |
|
610 |
} |
||
611 |
} |
||
612 |
} else { |
||
613 |
6861742 |
filter_mb_edgeh( &img_y[0], linesize, bS, qp, a, b, h, 1 ); |
|
614 |
✓✓ | 6861742 |
if (chroma) { |
615 |
✓✓ | 6797967 |
if (chroma444) { |
616 |
31199 |
filter_mb_edgeh ( &img_cb[0], uvlinesize, bS, chroma_qp_avg[0], a, b, h, 1); |
|
617 |
31199 |
filter_mb_edgeh ( &img_cr[0], uvlinesize, bS, chroma_qp_avg[1], a, b, h, 1); |
|
618 |
} else { |
||
619 |
6766768 |
filter_mb_edgech( &img_cb[0], uvlinesize, bS, chroma_qp_avg[0], a, b, h, 1); |
|
620 |
6766768 |
filter_mb_edgech( &img_cr[0], uvlinesize, bS, chroma_qp_avg[1], a, b, h, 1); |
|
621 |
} |
||
622 |
} |
||
623 |
} |
||
624 |
} |
||
625 |
} |
||
626 |
} |
||
627 |
|||
628 |
/* Calculate bS */ |
||
629 |
✓✓ | 61258474 |
for( edge = 1; edge < edges; edge++ ) { |
630 |
40791072 |
LOCAL_ALIGNED(8, int16_t, bS, [4]); |
|
631 |
int qp; |
||
632 |
40791072 |
const int deblock_edge = !IS_8x8DCT(mb_type & (edge<<24)); // (edge&1) && IS_8x8DCT(mb_type) |
|
633 |
|||
634 |
✓✓✓✓ ✓✓ |
40791072 |
if (!deblock_edge && (!chroma422 || dir == 0)) |
635 |
11340329 |
continue; |
|
636 |
|||
637 |
✓✓ | 34167086 |
if( IS_INTRA(mb_type)) { |
638 |
13331270 |
AV_WN64A(bS, 0x0003000300030003ULL); |
|
639 |
} else { |
||
640 |
int i; |
||
641 |
int mv_done; |
||
642 |
|||
643 |
✓✓ | 20835816 |
if( edge & mask_edge ) { |
644 |
13380241 |
AV_ZERO64(bS); |
|
645 |
13380241 |
mv_done = 1; |
|
646 |
} |
||
647 |
✓✓ | 7455575 |
else if( mask_par0 ) { |
648 |
✓✓ | 860617 |
int b_idx= 8 + 4 + edge * (dir ? 8:1); |
649 |
✓✓ | 860617 |
int bn_idx= b_idx - (dir ? 8:1); |
650 |
|||
651 |
860617 |
bS[0] = bS[1] = bS[2] = bS[3] = check_mv(sl, b_idx, bn_idx, mvy_limit); |
|
652 |
860617 |
mv_done = 1; |
|
653 |
} |
||
654 |
else |
||
655 |
6594958 |
mv_done = 0; |
|
656 |
|||
657 |
✓✓ | 104179080 |
for( i = 0; i < 4; i++ ) { |
658 |
✓✓ | 83343264 |
int x = dir == 0 ? edge : i; |
659 |
✓✓ | 83343264 |
int y = dir == 0 ? i : edge; |
660 |
83343264 |
int b_idx= 8 + 4 + x + 8*y; |
|
661 |
✓✓ | 83343264 |
int bn_idx= b_idx - (dir ? 8:1); |
662 |
|||
663 |
83343264 |
if (sl->non_zero_count_cache[b_idx] | |
|
664 |
✓✓ | 83343264 |
sl->non_zero_count_cache[bn_idx]) { |
665 |
40440237 |
bS[i] = 2; |
|
666 |
} |
||
667 |
✓✓ | 42903027 |
else if(!mv_done) |
668 |
{ |
||
669 |
12466870 |
bS[i] = check_mv(sl, b_idx, bn_idx, mvy_limit); |
|
670 |
} |
||
671 |
} |
||
672 |
|||
673 |
✓✓ | 20835816 |
if(bS[0]+bS[1]+bS[2]+bS[3] == 0) |
674 |
4716343 |
continue; |
|
675 |
} |
||
676 |
|||
677 |
/* Filter edge */ |
||
678 |
// Do not use s->qscale as luma quantizer because it has not the same |
||
679 |
// value in IPCM macroblocks. |
||
680 |
29450743 |
qp = h->cur_pic.qscale_table[mb_xy]; |
|
681 |
//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]); |
||
682 |
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); |
||
683 |
//{ int i; for (i = 0; i < 4; i++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); } |
||
684 |
✓✓ | 29450743 |
if( dir == 0 ) { |
685 |
14344726 |
filter_mb_edgev( &img_y[4*edge << h->pixel_shift], linesize, bS, qp, a, b, h, 0 ); |
|
686 |
✓✓ | 14344726 |
if (chroma) { |
687 |
✓✓ | 14213732 |
if (chroma444) { |
688 |
47636 |
filter_mb_edgev ( &img_cb[4*edge << h->pixel_shift], uvlinesize, bS, sl->chroma_qp[0], a, b, h, 0); |
|
689 |
47636 |
filter_mb_edgev ( &img_cr[4*edge << h->pixel_shift], uvlinesize, bS, sl->chroma_qp[1], a, b, h, 0); |
|
690 |
✓✓ | 14166096 |
} else if( (edge&1) == 0 ) { |
691 |
6165032 |
filter_mb_edgecv( &img_cb[2*edge << h->pixel_shift], uvlinesize, bS, sl->chroma_qp[0], a, b, h, 0); |
|
692 |
6165032 |
filter_mb_edgecv( &img_cr[2*edge << h->pixel_shift], uvlinesize, bS, sl->chroma_qp[1], a, b, h, 0); |
|
693 |
} |
||
694 |
} |
||
695 |
} else { |
||
696 |
✓✓ | 15106017 |
if (chroma422) { |
697 |
✓✓ | 2064167 |
if (deblock_edge) |
698 |
1290264 |
filter_mb_edgeh(&img_y[4*edge*linesize], linesize, bS, qp, a, b, h, 0); |
|
699 |
✓✗ | 2064167 |
if (chroma) { |
700 |
2064167 |
filter_mb_edgech(&img_cb[4*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[0], a, b, h, 0); |
|
701 |
2064167 |
filter_mb_edgech(&img_cr[4*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[1], a, b, h, 0); |
|
702 |
} |
||
703 |
} else { |
||
704 |
13041850 |
filter_mb_edgeh(&img_y[4*edge*linesize], linesize, bS, qp, a, b, h, 0); |
|
705 |
✓✓ | 13041850 |
if (chroma) { |
706 |
✓✓ | 12911135 |
if (chroma444) { |
707 |
47937 |
filter_mb_edgeh (&img_cb[4*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[0], a, b, h, 0); |
|
708 |
47937 |
filter_mb_edgeh (&img_cr[4*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[1], a, b, h, 0); |
|
709 |
✓✓ | 12863198 |
} else if ((edge&1) == 0) { |
710 |
5460044 |
filter_mb_edgech(&img_cb[2*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[0], a, b, h, 0); |
|
711 |
5460044 |
filter_mb_edgech(&img_cr[2*edge*uvlinesize], uvlinesize, bS, sl->chroma_qp[1], a, b, h, 0); |
|
712 |
} |
||
713 |
} |
||
714 |
} |
||
715 |
} |
||
716 |
} |
||
717 |
20467402 |
} |
|
718 |
|||
719 |
10233701 |
void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, |
|
720 |
int mb_x, int mb_y, |
||
721 |
uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, |
||
722 |
unsigned int linesize, unsigned int uvlinesize) |
||
723 |
{ |
||
724 |
10233701 |
const int mb_xy= mb_x + mb_y*h->mb_stride; |
|
725 |
10233701 |
const int mb_type = h->cur_pic.mb_type[mb_xy]; |
|
726 |
✓✓ | 10233701 |
const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4; |
727 |
10233701 |
int first_vertical_edge_done = 0; |
|
728 |
10233701 |
int chroma = CHROMA(h) && !(CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY)); |
|
729 |
10233701 |
int qp_bd_offset = 6 * (h->ps.sps->bit_depth_luma - 8); |
|
730 |
10233701 |
int a = 52 + sl->slice_alpha_c0_offset - qp_bd_offset; |
|
731 |
10233701 |
int b = 52 + sl->slice_beta_offset - qp_bd_offset; |
|
732 |
|||
733 |
✓✓ | 10233701 |
if (FRAME_MBAFF(h) |
734 |
// and current and left pair do not have the same interlaced type |
||
735 |
✓✓ | 1608490 |
&& IS_INTERLACED(mb_type ^ sl->left_type[LTOP]) |
736 |
// and left mb is in available to us |
||
737 |
✓✓ | 352491 |
&& sl->left_type[LTOP]) { |
738 |
/* First vertical edge is different in MBAFF frames |
||
739 |
* There are 8 different bS to compute and 2 different Qp |
||
740 |
*/ |
||
741 |
343038 |
LOCAL_ALIGNED(8, int16_t, bS, [8]); |
|
742 |
int qp[2]; |
||
743 |
int bqp[2]; |
||
744 |
int rqp[2]; |
||
745 |
int mb_qp, mbn0_qp, mbn1_qp; |
||
746 |
int i; |
||
747 |
343038 |
first_vertical_edge_done = 1; |
|
748 |
|||
749 |
✓✓ | 343038 |
if( IS_INTRA(mb_type) ) { |
750 |
166747 |
AV_WN64A(&bS[0], 0x0004000400040004ULL); |
|
751 |
166747 |
AV_WN64A(&bS[4], 0x0004000400040004ULL); |
|
752 |
} else { |
||
753 |
static const uint8_t offset[2][2][8]={ |
||
754 |
{ |
||
755 |
{3+4*0, 3+4*0, 3+4*0, 3+4*0, 3+4*1, 3+4*1, 3+4*1, 3+4*1}, |
||
756 |
{3+4*2, 3+4*2, 3+4*2, 3+4*2, 3+4*3, 3+4*3, 3+4*3, 3+4*3}, |
||
757 |
},{ |
||
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 |
{3+4*0, 3+4*1, 3+4*2, 3+4*3, 3+4*0, 3+4*1, 3+4*2, 3+4*3}, |
||
760 |
} |
||
761 |
}; |
||
762 |
176291 |
const uint8_t *off= offset[MB_FIELD(sl)][mb_y&1]; |
|
763 |
✓✓ | 1586619 |
for( i = 0; i < 8; i++ ) { |
764 |
✓✓ | 1410328 |
int j= MB_FIELD(sl) ? i>>2 : i&1; |
765 |
1410328 |
int mbn_xy = sl->left_mb_xy[LEFT(j)]; |
|
766 |
1410328 |
int mbn_type = sl->left_type[LEFT(j)]; |
|
767 |
|||
768 |
✓✓ | 1410328 |
if( IS_INTRA( mbn_type ) ) |
769 |
158044 |
bS[i] = 4; |
|
770 |
else{ |
||
771 |
✓✓ | 1252284 |
bS[i] = 1 + !!(sl->non_zero_count_cache[12+8*(i>>1)] | |
772 |
✓✓ | 243500 |
((!h->ps.pps->cabac && IS_8x8DCT(mbn_type)) ? |
773 |
✓✓✓✓ |
31036 |
(h->cbp_table[mbn_xy] & (((MB_FIELD(sl) ? (i&2) : (mb_y&1)) ? 8 : 2) << 12)) |
774 |
✓✓ | 1283320 |
: |
775 |
1221248 |
h->non_zero_count[mbn_xy][ off[i] ])); |
|
776 |
} |
||
777 |
} |
||
778 |
} |
||
779 |
|||
780 |
343038 |
mb_qp = h->cur_pic.qscale_table[mb_xy]; |
|
781 |
343038 |
mbn0_qp = h->cur_pic.qscale_table[sl->left_mb_xy[0]]; |
|
782 |
343038 |
mbn1_qp = h->cur_pic.qscale_table[sl->left_mb_xy[1]]; |
|
783 |
343038 |
qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; |
|
784 |
343038 |
bqp[0] = (get_chroma_qp(h->ps.pps, 0, mb_qp) + |
|
785 |
343038 |
get_chroma_qp(h->ps.pps, 0, mbn0_qp) + 1) >> 1; |
|
786 |
343038 |
rqp[0] = (get_chroma_qp(h->ps.pps, 1, mb_qp) + |
|
787 |
343038 |
get_chroma_qp(h->ps.pps, 1, mbn0_qp) + 1) >> 1; |
|
788 |
343038 |
qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; |
|
789 |
343038 |
bqp[1] = (get_chroma_qp(h->ps.pps, 0, mb_qp) + |
|
790 |
343038 |
get_chroma_qp(h->ps.pps, 0, mbn1_qp) + 1 ) >> 1; |
|
791 |
343038 |
rqp[1] = (get_chroma_qp(h->ps.pps, 1, mb_qp) + |
|
792 |
343038 |
get_chroma_qp(h->ps.pps, 1, mbn1_qp) + 1 ) >> 1; |
|
793 |
|||
794 |
/* Filter edge */ |
||
795 |
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); |
||
796 |
✓✓ | 3087342 |
{ int i; for (i = 0; i < 8; i++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); } |
797 |
✓✓ | 343038 |
if (MB_FIELD(sl)) { |
798 |
172381 |
filter_mb_mbaff_edgev ( h, img_y , linesize, bS , 1, qp [0], a, b, 1 ); |
|
799 |
172381 |
filter_mb_mbaff_edgev ( h, img_y + 8* linesize, linesize, bS+4, 1, qp [1], a, b, 1 ); |
|
800 |
✓✗ | 172381 |
if (chroma){ |
801 |
✗✓ | 172381 |
if (CHROMA444(h)) { |
802 |
filter_mb_mbaff_edgev ( h, img_cb, uvlinesize, bS , 1, bqp[0], a, b, 1 ); |
||
803 |
filter_mb_mbaff_edgev ( h, img_cb + 8*uvlinesize, uvlinesize, bS+4, 1, bqp[1], a, b, 1 ); |
||
804 |
filter_mb_mbaff_edgev ( h, img_cr, uvlinesize, bS , 1, rqp[0], a, b, 1 ); |
||
805 |
filter_mb_mbaff_edgev ( h, img_cr + 8*uvlinesize, uvlinesize, bS+4, 1, rqp[1], a, b, 1 ); |
||
806 |
✓✓ | 172381 |
} else if (CHROMA422(h)) { |
807 |
27784 |
filter_mb_mbaff_edgecv(h, img_cb, uvlinesize, bS , 1, bqp[0], a, b, 1); |
|
808 |
27784 |
filter_mb_mbaff_edgecv(h, img_cb + 8*uvlinesize, uvlinesize, bS+4, 1, bqp[1], a, b, 1); |
|
809 |
27784 |
filter_mb_mbaff_edgecv(h, img_cr, uvlinesize, bS , 1, rqp[0], a, b, 1); |
|
810 |
27784 |
filter_mb_mbaff_edgecv(h, img_cr + 8*uvlinesize, uvlinesize, bS+4, 1, rqp[1], a, b, 1); |
|
811 |
}else{ |
||
812 |
144597 |
filter_mb_mbaff_edgecv( h, img_cb, uvlinesize, bS , 1, bqp[0], a, b, 1 ); |
|
813 |
144597 |
filter_mb_mbaff_edgecv( h, img_cb + 4*uvlinesize, uvlinesize, bS+4, 1, bqp[1], a, b, 1 ); |
|
814 |
144597 |
filter_mb_mbaff_edgecv( h, img_cr, uvlinesize, bS , 1, rqp[0], a, b, 1 ); |
|
815 |
144597 |
filter_mb_mbaff_edgecv( h, img_cr + 4*uvlinesize, uvlinesize, bS+4, 1, rqp[1], a, b, 1 ); |
|
816 |
} |
||
817 |
} |
||
818 |
}else{ |
||
819 |
170657 |
filter_mb_mbaff_edgev ( h, img_y , 2* linesize, bS , 2, qp [0], a, b, 1 ); |
|
820 |
170657 |
filter_mb_mbaff_edgev ( h, img_y + linesize, 2* linesize, bS+1, 2, qp [1], a, b, 1 ); |
|
821 |
✓✗ | 170657 |
if (chroma){ |
822 |
✗✓ | 170657 |
if (CHROMA444(h)) { |
823 |
filter_mb_mbaff_edgev ( h, img_cb, 2*uvlinesize, bS , 2, bqp[0], a, b, 1 ); |
||
824 |
filter_mb_mbaff_edgev ( h, img_cb + uvlinesize, 2*uvlinesize, bS+1, 2, bqp[1], a, b, 1 ); |
||
825 |
filter_mb_mbaff_edgev ( h, img_cr, 2*uvlinesize, bS , 2, rqp[0], a, b, 1 ); |
||
826 |
filter_mb_mbaff_edgev ( h, img_cr + uvlinesize, 2*uvlinesize, bS+1, 2, rqp[1], a, b, 1 ); |
||
827 |
}else{ |
||
828 |
170657 |
filter_mb_mbaff_edgecv( h, img_cb, 2*uvlinesize, bS , 2, bqp[0], a, b, 1 ); |
|
829 |
170657 |
filter_mb_mbaff_edgecv( h, img_cb + uvlinesize, 2*uvlinesize, bS+1, 2, bqp[1], a, b, 1 ); |
|
830 |
170657 |
filter_mb_mbaff_edgecv( h, img_cr, 2*uvlinesize, bS , 2, rqp[0], a, b, 1 ); |
|
831 |
170657 |
filter_mb_mbaff_edgecv( h, img_cr + uvlinesize, 2*uvlinesize, bS+1, 2, rqp[1], a, b, 1 ); |
|
832 |
} |
||
833 |
} |
||
834 |
} |
||
835 |
} |
||
836 |
|||
837 |
#if CONFIG_SMALL |
||
838 |
{ |
||
839 |
int dir; |
||
840 |
for (dir = 0; dir < 2; dir++) |
||
841 |
filter_mb_dir(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, |
||
842 |
uvlinesize, mb_xy, mb_type, mvy_limit, |
||
843 |
dir ? 0 : first_vertical_edge_done, a, b, |
||
844 |
chroma, dir); |
||
845 |
} |
||
846 |
#else |
||
847 |
10233701 |
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); |
|
848 |
10233701 |
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); |
|
849 |
#endif |
||
850 |
10233701 |
} |
| Generated by: GCOVR (Version 4.2) |