2 * H.26L/H.264/AVC/JVT/14496-10/... loop filter
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
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.
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.
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
24 * H.264 / AVC / MPEG4 part10 loop filter.
25 * @author Michael Niedermayer <michaelni@gmx.at>
28 #include "libavutil/internal.h"
29 #include "libavutil/intreadwrite.h"
34 #include "mpegutils.h"
35 #include "rectangle.h"
37 /* Deblocking filter (p153) */
38 static const uint8_t alpha_table
[52*3] = {
39 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
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,
44 0, 0, 0, 0, 0, 0, 4, 4, 5, 6,
45 7, 8, 9, 10, 12, 13, 15, 17, 20, 22,
46 25, 28, 32, 36, 40, 45, 50, 56, 63, 71,
47 80, 90,101,113,127,144,162,182,203,226,
49 255,255,255,255,255,255,255,255,255,255,255,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,
54 static const uint8_t beta_table
[52*3] = {
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
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,
60 0, 0, 0, 0, 0, 0, 2, 2, 2, 3,
61 3, 3, 3, 4, 4, 4, 6, 6, 7, 7,
62 8, 8, 9, 9, 10, 10, 11, 11, 12, 12,
63 13, 13, 14, 14, 15, 15, 16, 16, 17, 17,
65 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 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,
70 static const uint8_t tc0_table
[52*3][4] = {
71 {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
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 },
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 }, {-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, 1 },
83 {-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 1, 1 }, {-1, 0, 1, 1 }, {-1, 1, 1, 1 },
84 {-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 },
85 {-1, 1, 1, 2 }, {-1, 1, 2, 3 }, {-1, 1, 2, 3 }, {-1, 2, 2, 3 }, {-1, 2, 2, 4 }, {-1, 2, 3, 4 },
86 {-1, 2, 3, 4 }, {-1, 3, 3, 5 }, {-1, 3, 4, 6 }, {-1, 3, 4, 6 }, {-1, 4, 5, 7 }, {-1, 4, 5, 8 },
87 {-1, 4, 6, 9 }, {-1, 5, 7,10 }, {-1, 6, 8,11 }, {-1, 6, 8,13 }, {-1, 7,10,14 }, {-1, 8,11,16 },
88 {-1, 9,12,18 }, {-1,10,13,20 }, {-1,11,15,23 }, {-1,13,17,25 },
89 {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-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 },
100 /* intra: 0 if this loopfilter call is guaranteed to be inter (bS < 4), 1 if it might be intra (bS == 4) */
101 static av_always_inline
void filter_mb_edgev(uint8_t *pix
, int stride
,
103 unsigned int qp
, int a
, int b
,
104 H264Context
*h
, int intra
)
106 const unsigned int index_a
= qp
+ a
;
107 const int alpha
= alpha_table
[index_a
];
108 const int beta
= beta_table
[qp
+ b
];
109 if (alpha
==0 || beta
== 0) return;
111 if( bS
[0] < 4 || !intra
) {
113 tc
[0] = tc0_table
[index_a
][bS
[0]];
114 tc
[1] = tc0_table
[index_a
][bS
[1]];
115 tc
[2] = tc0_table
[index_a
][bS
[2]];
116 tc
[3] = tc0_table
[index_a
][bS
[3]];
117 h
->h264dsp
.h264_h_loop_filter_luma(pix
, stride
, alpha
, beta
, tc
);
119 h
->h264dsp
.h264_h_loop_filter_luma_intra(pix
, stride
, alpha
, beta
);
123 static av_always_inline
void filter_mb_edgecv(uint8_t *pix
, int stride
,
125 unsigned int qp
, int a
, int b
,
126 H264Context
*h
, int intra
)
128 const unsigned int index_a
= qp
+ a
;
129 const int alpha
= alpha_table
[index_a
];
130 const int beta
= beta_table
[qp
+ b
];
131 if (alpha
==0 || beta
== 0) return;
133 if( bS
[0] < 4 || !intra
) {
135 tc
[0] = tc0_table
[index_a
][bS
[0]]+1;
136 tc
[1] = tc0_table
[index_a
][bS
[1]]+1;
137 tc
[2] = tc0_table
[index_a
][bS
[2]]+1;
138 tc
[3] = tc0_table
[index_a
][bS
[3]]+1;
139 h
->h264dsp
.h264_h_loop_filter_chroma(pix
, stride
, alpha
, beta
, tc
);
141 h
->h264dsp
.h264_h_loop_filter_chroma_intra(pix
, stride
, alpha
, beta
);
145 static av_always_inline
void filter_mb_mbaff_edgev(H264Context
*h
, uint8_t *pix
,
147 const int16_t bS
[7], int bsi
,
148 int qp
, int a
, int b
,
151 const unsigned int index_a
= qp
+ a
;
152 const int alpha
= alpha_table
[index_a
];
153 const int beta
= beta_table
[qp
+ b
];
154 if (alpha
==0 || beta
== 0) return;
156 if( bS
[0] < 4 || !intra
) {
158 tc
[0] = tc0_table
[index_a
][bS
[0*bsi
]];
159 tc
[1] = tc0_table
[index_a
][bS
[1*bsi
]];
160 tc
[2] = tc0_table
[index_a
][bS
[2*bsi
]];
161 tc
[3] = tc0_table
[index_a
][bS
[3*bsi
]];
162 h
->h264dsp
.h264_h_loop_filter_luma_mbaff(pix
, stride
, alpha
, beta
, tc
);
164 h
->h264dsp
.h264_h_loop_filter_luma_mbaff_intra(pix
, stride
, alpha
, beta
);
168 static av_always_inline
void filter_mb_mbaff_edgecv(H264Context
*h
,
169 uint8_t *pix
, int stride
,
171 int bsi
, int qp
, int a
,
174 const unsigned int index_a
= qp
+ a
;
175 const int alpha
= alpha_table
[index_a
];
176 const int beta
= beta_table
[qp
+ b
];
177 if (alpha
==0 || beta
== 0) return;
179 if( bS
[0] < 4 || !intra
) {
181 tc
[0] = tc0_table
[index_a
][bS
[0*bsi
]] + 1;
182 tc
[1] = tc0_table
[index_a
][bS
[1*bsi
]] + 1;
183 tc
[2] = tc0_table
[index_a
][bS
[2*bsi
]] + 1;
184 tc
[3] = tc0_table
[index_a
][bS
[3*bsi
]] + 1;
185 h
->h264dsp
.h264_h_loop_filter_chroma_mbaff(pix
, stride
, alpha
, beta
, tc
);
187 h
->h264dsp
.h264_h_loop_filter_chroma_mbaff_intra(pix
, stride
, alpha
, beta
);
191 static av_always_inline
void filter_mb_edgeh(uint8_t *pix
, int stride
,
193 unsigned int qp
, int a
, int b
,
194 H264Context
*h
, int intra
)
196 const unsigned int index_a
= qp
+ a
;
197 const int alpha
= alpha_table
[index_a
];
198 const int beta
= beta_table
[qp
+ b
];
199 if (alpha
==0 || beta
== 0) return;
201 if( bS
[0] < 4 || !intra
) {
203 tc
[0] = tc0_table
[index_a
][bS
[0]];
204 tc
[1] = tc0_table
[index_a
][bS
[1]];
205 tc
[2] = tc0_table
[index_a
][bS
[2]];
206 tc
[3] = tc0_table
[index_a
][bS
[3]];
207 h
->h264dsp
.h264_v_loop_filter_luma(pix
, stride
, alpha
, beta
, tc
);
209 h
->h264dsp
.h264_v_loop_filter_luma_intra(pix
, stride
, alpha
, beta
);
213 static av_always_inline
void filter_mb_edgech(uint8_t *pix
, int stride
,
215 unsigned int qp
, int a
, int b
,
216 H264Context
*h
, int intra
)
218 const unsigned int index_a
= qp
+ a
;
219 const int alpha
= alpha_table
[index_a
];
220 const int beta
= beta_table
[qp
+ b
];
221 if (alpha
==0 || beta
== 0) return;
223 if( bS
[0] < 4 || !intra
) {
225 tc
[0] = tc0_table
[index_a
][bS
[0]]+1;
226 tc
[1] = tc0_table
[index_a
][bS
[1]]+1;
227 tc
[2] = tc0_table
[index_a
][bS
[2]]+1;
228 tc
[3] = tc0_table
[index_a
][bS
[3]]+1;
229 h
->h264dsp
.h264_v_loop_filter_chroma(pix
, stride
, alpha
, beta
, tc
);
231 h
->h264dsp
.h264_v_loop_filter_chroma_intra(pix
, stride
, alpha
, beta
);
235 static av_always_inline
void h264_filter_mb_fast_internal(H264Context
*h
,
240 unsigned int linesize
,
241 unsigned int uvlinesize
,
244 int chroma
= CHROMA(h
) && !(CONFIG_GRAY
&& (h
->flags
&CODEC_FLAG_GRAY
));
245 int chroma444
= CHROMA444(h
);
246 int chroma422
= CHROMA422(h
);
248 int mb_xy
= h
->mb_xy
;
249 int left_type
= h
->left_type
[LTOP
];
250 int top_type
= h
->top_type
;
252 int qp_bd_offset
= 6 * (h
->sps
.bit_depth_luma
- 8);
253 int a
= 52 + h
->slice_alpha_c0_offset
- qp_bd_offset
;
254 int b
= 52 + h
->slice_beta_offset
- qp_bd_offset
;
256 int mb_type
= h
->cur_pic
.mb_type
[mb_xy
];
257 int qp
= h
->cur_pic
.qscale_table
[mb_xy
];
258 int qp0
= h
->cur_pic
.qscale_table
[mb_xy
- 1];
259 int qp1
= h
->cur_pic
.qscale_table
[h
->top_mb_xy
];
260 int qpc
= get_chroma_qp( h
, 0, qp
);
261 int qpc0
= get_chroma_qp( h
, 0, qp0
);
262 int qpc1
= get_chroma_qp( h
, 0, qp1
);
263 qp0
= (qp
+ qp0
+ 1) >> 1;
264 qp1
= (qp
+ qp1
+ 1) >> 1;
265 qpc0
= (qpc
+ qpc0
+ 1) >> 1;
266 qpc1
= (qpc
+ qpc1
+ 1) >> 1;
268 if( IS_INTRA(mb_type
) ) {
269 static const int16_t bS4
[4] = {4,4,4,4};
270 static const int16_t bS3
[4] = {3,3,3,3};
271 const int16_t *bSH
= FIELD_PICTURE(h
) ? bS3
: bS4
;
273 filter_mb_edgev( &img_y
[4*0<<pixel_shift
], linesize
, bS4
, qp0
, a
, b
, h
, 1);
274 if( IS_8x8DCT(mb_type
) ) {
275 filter_mb_edgev( &img_y
[4*2<<pixel_shift
], linesize
, bS3
, qp
, a
, b
, h
, 0);
277 filter_mb_edgeh( &img_y
[4*0*linesize
], linesize
, bSH
, qp1
, a
, b
, h
, 1);
279 filter_mb_edgeh( &img_y
[4*2*linesize
], linesize
, bS3
, qp
, a
, b
, h
, 0);
281 filter_mb_edgev( &img_y
[4*1<<pixel_shift
], linesize
, bS3
, qp
, a
, b
, h
, 0);
282 filter_mb_edgev( &img_y
[4*2<<pixel_shift
], linesize
, bS3
, qp
, a
, b
, h
, 0);
283 filter_mb_edgev( &img_y
[4*3<<pixel_shift
], linesize
, bS3
, qp
, a
, b
, h
, 0);
285 filter_mb_edgeh( &img_y
[4*0*linesize
], linesize
, bSH
, qp1
, a
, b
, h
, 1);
287 filter_mb_edgeh( &img_y
[4*1*linesize
], linesize
, bS3
, qp
, a
, b
, h
, 0);
288 filter_mb_edgeh( &img_y
[4*2*linesize
], linesize
, bS3
, qp
, a
, b
, h
, 0);
289 filter_mb_edgeh( &img_y
[4*3*linesize
], linesize
, bS3
, qp
, a
, b
, h
, 0);
294 filter_mb_edgev( &img_cb
[4*0<<pixel_shift
], linesize
, bS4
, qpc0
, a
, b
, h
, 1);
295 filter_mb_edgev( &img_cr
[4*0<<pixel_shift
], linesize
, bS4
, qpc0
, a
, b
, h
, 1);
297 if( IS_8x8DCT(mb_type
) ) {
298 filter_mb_edgev( &img_cb
[4*2<<pixel_shift
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
299 filter_mb_edgev( &img_cr
[4*2<<pixel_shift
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
301 filter_mb_edgeh( &img_cb
[4*0*linesize
], linesize
, bSH
, qpc1
, a
, b
, h
, 1 );
302 filter_mb_edgeh( &img_cr
[4*0*linesize
], linesize
, bSH
, qpc1
, a
, b
, h
, 1 );
304 filter_mb_edgeh( &img_cb
[4*2*linesize
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
305 filter_mb_edgeh( &img_cr
[4*2*linesize
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
307 filter_mb_edgev( &img_cb
[4*1<<pixel_shift
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
308 filter_mb_edgev( &img_cr
[4*1<<pixel_shift
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
309 filter_mb_edgev( &img_cb
[4*2<<pixel_shift
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
310 filter_mb_edgev( &img_cr
[4*2<<pixel_shift
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
311 filter_mb_edgev( &img_cb
[4*3<<pixel_shift
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
312 filter_mb_edgev( &img_cr
[4*3<<pixel_shift
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
314 filter_mb_edgeh( &img_cb
[4*0*linesize
], linesize
, bSH
, qpc1
, a
, b
, h
, 1);
315 filter_mb_edgeh( &img_cr
[4*0*linesize
], linesize
, bSH
, qpc1
, a
, b
, h
, 1);
317 filter_mb_edgeh( &img_cb
[4*1*linesize
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
318 filter_mb_edgeh( &img_cr
[4*1*linesize
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
319 filter_mb_edgeh( &img_cb
[4*2*linesize
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
320 filter_mb_edgeh( &img_cr
[4*2*linesize
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
321 filter_mb_edgeh( &img_cb
[4*3*linesize
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
322 filter_mb_edgeh( &img_cr
[4*3*linesize
], linesize
, bS3
, qpc
, a
, b
, h
, 0);
326 filter_mb_edgecv(&img_cb
[2*0<<pixel_shift
], uvlinesize
, bS4
, qpc0
, a
, b
, h
, 1);
327 filter_mb_edgecv(&img_cr
[2*0<<pixel_shift
], uvlinesize
, bS4
, qpc0
, a
, b
, h
, 1);
329 filter_mb_edgecv(&img_cb
[2*2<<pixel_shift
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
330 filter_mb_edgecv(&img_cr
[2*2<<pixel_shift
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
332 filter_mb_edgech(&img_cb
[4*0*uvlinesize
], uvlinesize
, bSH
, qpc1
, a
, b
, h
, 1);
333 filter_mb_edgech(&img_cr
[4*0*uvlinesize
], uvlinesize
, bSH
, qpc1
, a
, b
, h
, 1);
335 filter_mb_edgech(&img_cb
[4*1*uvlinesize
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
336 filter_mb_edgech(&img_cr
[4*1*uvlinesize
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
337 filter_mb_edgech(&img_cb
[4*2*uvlinesize
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
338 filter_mb_edgech(&img_cr
[4*2*uvlinesize
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
339 filter_mb_edgech(&img_cb
[4*3*uvlinesize
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
340 filter_mb_edgech(&img_cr
[4*3*uvlinesize
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
343 filter_mb_edgecv( &img_cb
[2*0<<pixel_shift
], uvlinesize
, bS4
, qpc0
, a
, b
, h
, 1);
344 filter_mb_edgecv( &img_cr
[2*0<<pixel_shift
], uvlinesize
, bS4
, qpc0
, a
, b
, h
, 1);
346 filter_mb_edgecv( &img_cb
[2*2<<pixel_shift
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
347 filter_mb_edgecv( &img_cr
[2*2<<pixel_shift
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
349 filter_mb_edgech( &img_cb
[2*0*uvlinesize
], uvlinesize
, bSH
, qpc1
, a
, b
, h
, 1);
350 filter_mb_edgech( &img_cr
[2*0*uvlinesize
], uvlinesize
, bSH
, qpc1
, a
, b
, h
, 1);
352 filter_mb_edgech( &img_cb
[2*2*uvlinesize
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
353 filter_mb_edgech( &img_cr
[2*2*uvlinesize
], uvlinesize
, bS3
, qpc
, a
, b
, h
, 0);
358 LOCAL_ALIGNED_8(int16_t, bS
, [2], [4][4]);
360 if( IS_8x8DCT(mb_type
) && (h
->cbp
&7) == 7 && !chroma444
) {
362 AV_WN64A(bS
[0][0], 0x0002000200020002ULL
);
363 AV_WN64A(bS
[0][2], 0x0002000200020002ULL
);
364 AV_WN64A(bS
[1][0], 0x0002000200020002ULL
);
365 AV_WN64A(bS
[1][2], 0x0002000200020002ULL
);
367 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;
368 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;
369 int step
= 1+(mb_type
>>24); //IS_8x8DCT(mb_type) ? 2 : 1;
370 edges
= 4 - 3*((mb_type
>>3) & !(h
->cbp
& 15)); //(mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4;
371 h
->h264dsp
.h264_loop_filter_strength( bS
, h
->non_zero_count_cache
, h
->ref_cache
, h
->mv_cache
,
372 h
->list_count
==2, edges
, step
, mask_edge0
, mask_edge1
, FIELD_PICTURE(h
));
374 if( IS_INTRA(left_type
) )
375 AV_WN64A(bS
[0][0], 0x0004000400040004ULL
);
376 if( IS_INTRA(top_type
) )
377 AV_WN64A(bS
[1][0], FIELD_PICTURE(h
) ? 0x0003000300030003ULL
: 0x0004000400040004ULL
);
379 #define FILTER(hv,dir,edge,intra)\
380 if(AV_RN64A(bS[dir][edge])) { \
381 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 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 );\
385 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 );\
386 } else if(!(edge&1)) {\
387 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 );\
388 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 );\
397 } else if( IS_8x8DCT(mb_type
) ) {
416 void ff_h264_filter_mb_fast( H264Context
*h
, int mb_x
, int mb_y
, uint8_t *img_y
, uint8_t *img_cb
, uint8_t *img_cr
, unsigned int linesize
, unsigned int uvlinesize
) {
417 av_assert2(!FRAME_MBAFF(h
));
418 if(!h
->h264dsp
.h264_loop_filter_strength
|| h
->pps
.chroma_qp_diff
) {
419 ff_h264_filter_mb(h
, mb_x
, mb_y
, img_y
, img_cb
, img_cr
, linesize
, uvlinesize
);
424 h264_filter_mb_fast_internal(h
, mb_x
, mb_y
, img_y
, img_cb
, img_cr
, linesize
, uvlinesize
, h
->pixel_shift
);
427 h264_filter_mb_fast_internal(h
, mb_x
, mb_y
, img_y
, img_cb
, img_cr
, linesize
, uvlinesize
, 1);
429 h264_filter_mb_fast_internal(h
, mb_x
, mb_y
, img_y
, img_cb
, img_cr
, linesize
, uvlinesize
, 0);
434 static int check_mv(H264Context
*h
, long b_idx
, long bn_idx
, int mvy_limit
){
437 v
= h
->ref_cache
[0][b_idx
] != h
->ref_cache
[0][bn_idx
];
438 if(!v
&& h
->ref_cache
[0][b_idx
]!=-1)
439 v
= h
->mv_cache
[0][b_idx
][0] - h
->mv_cache
[0][bn_idx
][0] + 3 >= 7U |
440 FFABS( h
->mv_cache
[0][b_idx
][1] - h
->mv_cache
[0][bn_idx
][1] ) >= mvy_limit
;
442 if(h
->list_count
==2){
444 v
= h
->ref_cache
[1][b_idx
] != h
->ref_cache
[1][bn_idx
] |
445 h
->mv_cache
[1][b_idx
][0] - h
->mv_cache
[1][bn_idx
][0] + 3 >= 7U |
446 FFABS( h
->mv_cache
[1][b_idx
][1] - h
->mv_cache
[1][bn_idx
][1] ) >= mvy_limit
;
449 if(h
->ref_cache
[0][b_idx
] != h
->ref_cache
[1][bn_idx
] |
450 h
->ref_cache
[1][b_idx
] != h
->ref_cache
[0][bn_idx
])
453 h
->mv_cache
[0][b_idx
][0] - h
->mv_cache
[1][bn_idx
][0] + 3 >= 7U |
454 FFABS( h
->mv_cache
[0][b_idx
][1] - h
->mv_cache
[1][bn_idx
][1] ) >= mvy_limit
|
455 h
->mv_cache
[1][b_idx
][0] - h
->mv_cache
[0][bn_idx
][0] + 3 >= 7U |
456 FFABS( h
->mv_cache
[1][b_idx
][1] - h
->mv_cache
[0][bn_idx
][1] ) >= mvy_limit
;
463 static av_always_inline
void filter_mb_dir(H264Context
*h
, int mb_x
, int mb_y
, uint8_t *img_y
, uint8_t *img_cb
, uint8_t *img_cr
, unsigned int linesize
, unsigned int uvlinesize
, int mb_xy
, int mb_type
, int mvy_limit
, int first_vertical_edge_done
, int a
, int b
, int chroma
, int dir
) {
465 int chroma_qp_avg
[2];
466 int chroma444
= CHROMA444(h
);
467 int chroma422
= CHROMA422(h
);
468 const int mbm_xy
= dir
== 0 ? mb_xy
-1 : h
->top_mb_xy
;
469 const int mbm_type
= dir
== 0 ? h
->left_type
[LTOP
] : h
->top_type
;
471 // how often to recheck mv-based bS when iterating between edges
472 static const uint8_t mask_edge_tab
[2][8]={{0,3,3,3,1,1,1,1},
474 const int mask_edge
= mask_edge_tab
[dir
][(mb_type
>>3)&7];
475 const int edges
= mask_edge
== 3 && !(h
->cbp
&15) ? 1 : 4;
477 // how often to recheck mv-based bS when iterating along each edge
478 const int mask_par0
= mb_type
& (MB_TYPE_16x16
| (MB_TYPE_8x16
>> dir
));
480 if(mbm_type
&& !first_vertical_edge_done
){
482 if (FRAME_MBAFF(h
) && (dir
== 1) && ((mb_y
&1) == 0)
483 && IS_INTERLACED(mbm_type
&~mb_type
)
485 // This is a special case in the norm where the filtering must
486 // be done twice (one each of the field) even if we are in a
489 unsigned int tmp_linesize
= 2 * linesize
;
490 unsigned int tmp_uvlinesize
= 2 * uvlinesize
;
491 int mbn_xy
= mb_xy
- 2 * h
->mb_stride
;
494 for(j
=0; j
<2; j
++, mbn_xy
+= h
->mb_stride
){
495 DECLARE_ALIGNED(8, int16_t, bS
)[4];
497 if (IS_INTRA(mb_type
| h
->cur_pic
.mb_type
[mbn_xy
])) {
498 AV_WN64A(bS
, 0x0003000300030003ULL
);
500 if (!CABAC(h
) && IS_8x8DCT(h
->cur_pic
.mb_type
[mbn_xy
])) {
501 bS
[0]= 1+((h
->cbp_table
[mbn_xy
] & 0x4000)||h
->non_zero_count_cache
[scan8
[0]+0]);
502 bS
[1]= 1+((h
->cbp_table
[mbn_xy
] & 0x4000)||h
->non_zero_count_cache
[scan8
[0]+1]);
503 bS
[2]= 1+((h
->cbp_table
[mbn_xy
] & 0x8000)||h
->non_zero_count_cache
[scan8
[0]+2]);
504 bS
[3]= 1+((h
->cbp_table
[mbn_xy
] & 0x8000)||h
->non_zero_count_cache
[scan8
[0]+3]);
506 const uint8_t *mbn_nnz
= h
->non_zero_count
[mbn_xy
] + 3*4;
508 for( i
= 0; i
< 4; i
++ ) {
509 bS
[i
] = 1 + !!(h
->non_zero_count_cache
[scan8
[0]+i
] | mbn_nnz
[i
]);
513 // Do not use s->qscale as luma quantizer because it has not the same
514 // value in IPCM macroblocks.
515 qp
= (h
->cur_pic
.qscale_table
[mb_xy
] + h
->cur_pic
.qscale_table
[mbn_xy
] + 1) >> 1;
516 tprintf(h
->avctx
, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x
, mb_y
, dir
, edge
, qp
, tmp_linesize
, tmp_uvlinesize
);
517 { int i
; for (i
= 0; i
< 4; i
++) tprintf(h
->avctx
, " bS[%d]:%d", i
, bS
[i
]); tprintf(h
->avctx
, "\n"); }
518 filter_mb_edgeh( &img_y
[j
*linesize
], tmp_linesize
, bS
, qp
, a
, b
, h
, 0 );
519 chroma_qp_avg
[0] = (h
->chroma_qp
[0] + get_chroma_qp(h
, 0, h
->cur_pic
.qscale_table
[mbn_xy
]) + 1) >> 1;
520 chroma_qp_avg
[1] = (h
->chroma_qp
[1] + get_chroma_qp(h
, 1, h
->cur_pic
.qscale_table
[mbn_xy
]) + 1) >> 1;
523 filter_mb_edgeh (&img_cb
[j
*uvlinesize
], tmp_uvlinesize
, bS
, chroma_qp_avg
[0], a
, b
, h
, 0);
524 filter_mb_edgeh (&img_cr
[j
*uvlinesize
], tmp_uvlinesize
, bS
, chroma_qp_avg
[1], a
, b
, h
, 0);
526 filter_mb_edgech(&img_cb
[j
*uvlinesize
], tmp_uvlinesize
, bS
, chroma_qp_avg
[0], a
, b
, h
, 0);
527 filter_mb_edgech(&img_cr
[j
*uvlinesize
], tmp_uvlinesize
, bS
, chroma_qp_avg
[1], a
, b
, h
, 0);
532 DECLARE_ALIGNED(8, int16_t, bS
)[4];
535 if( IS_INTRA(mb_type
|mbm_type
)) {
536 AV_WN64A(bS
, 0x0003000300030003ULL
);
537 if ( (!IS_INTERLACED(mb_type
|mbm_type
))
538 || ((FRAME_MBAFF(h
) || (h
->picture_structure
!= PICT_FRAME
)) && (dir
== 0))
540 AV_WN64A(bS
, 0x0004000400040004ULL
);
545 if( dir
&& FRAME_MBAFF(h
) && IS_INTERLACED(mb_type
^ mbm_type
)) {
546 AV_WN64A(bS
, 0x0001000100010001ULL
);
549 else if( mask_par0
&& ((mbm_type
& (MB_TYPE_16x16
| (MB_TYPE_8x16
>> dir
)))) ) {
551 int bn_idx
= b_idx
- (dir
? 8:1);
553 bS
[0] = bS
[1] = bS
[2] = bS
[3] = check_mv(h
, 8 + 4, bn_idx
, mvy_limit
);
559 for( i
= 0; i
< 4; i
++ ) {
560 int x
= dir
== 0 ? 0 : i
;
561 int y
= dir
== 0 ? i
: 0;
562 int b_idx
= 8 + 4 + x
+ 8*y
;
563 int bn_idx
= b_idx
- (dir
? 8:1);
565 if( h
->non_zero_count_cache
[b_idx
] |
566 h
->non_zero_count_cache
[bn_idx
] ) {
571 bS
[i
] = check_mv(h
, b_idx
, bn_idx
, mvy_limit
);
577 // Do not use s->qscale as luma quantizer because it has not the same
578 // value in IPCM macroblocks.
579 if(bS
[0]+bS
[1]+bS
[2]+bS
[3]){
580 qp
= (h
->cur_pic
.qscale_table
[mb_xy
] + h
->cur_pic
.qscale_table
[mbm_xy
] + 1) >> 1;
581 //tprintf(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]);
582 tprintf(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
);
583 //{ int i; for (i = 0; i < 4; i++) tprintf(h->avctx, " bS[%d]:%d", i, bS[i]); tprintf(h->avctx, "\n"); }
584 chroma_qp_avg
[0] = (h
->chroma_qp
[0] + get_chroma_qp(h
, 0, h
->cur_pic
.qscale_table
[mbm_xy
]) + 1) >> 1;
585 chroma_qp_avg
[1] = (h
->chroma_qp
[1] + get_chroma_qp(h
, 1, h
->cur_pic
.qscale_table
[mbm_xy
]) + 1) >> 1;
587 filter_mb_edgev( &img_y
[0], linesize
, bS
, qp
, a
, b
, h
, 1 );
590 filter_mb_edgev ( &img_cb
[0], uvlinesize
, bS
, chroma_qp_avg
[0], a
, b
, h
, 1);
591 filter_mb_edgev ( &img_cr
[0], uvlinesize
, bS
, chroma_qp_avg
[1], a
, b
, h
, 1);
593 filter_mb_edgecv( &img_cb
[0], uvlinesize
, bS
, chroma_qp_avg
[0], a
, b
, h
, 1);
594 filter_mb_edgecv( &img_cr
[0], uvlinesize
, bS
, chroma_qp_avg
[1], a
, b
, h
, 1);
598 filter_mb_edgeh( &img_y
[0], linesize
, bS
, qp
, a
, b
, h
, 1 );
601 filter_mb_edgeh ( &img_cb
[0], uvlinesize
, bS
, chroma_qp_avg
[0], a
, b
, h
, 1);
602 filter_mb_edgeh ( &img_cr
[0], uvlinesize
, bS
, chroma_qp_avg
[1], a
, b
, h
, 1);
604 filter_mb_edgech( &img_cb
[0], uvlinesize
, bS
, chroma_qp_avg
[0], a
, b
, h
, 1);
605 filter_mb_edgech( &img_cr
[0], uvlinesize
, bS
, chroma_qp_avg
[1], a
, b
, h
, 1);
614 for( edge
= 1; edge
< edges
; edge
++ ) {
615 DECLARE_ALIGNED(8, int16_t, bS
)[4];
617 const int deblock_edge
= !IS_8x8DCT(mb_type
& (edge
<<24)); // (edge&1) && IS_8x8DCT(mb_type)
619 if (!deblock_edge
&& (!chroma422
|| dir
== 0))
622 if( IS_INTRA(mb_type
)) {
623 AV_WN64A(bS
, 0x0003000300030003ULL
);
628 if( edge
& mask_edge
) {
632 else if( mask_par0
) {
633 int b_idx
= 8 + 4 + edge
* (dir
? 8:1);
634 int bn_idx
= b_idx
- (dir
? 8:1);
636 bS
[0] = bS
[1] = bS
[2] = bS
[3] = check_mv(h
, b_idx
, bn_idx
, mvy_limit
);
642 for( i
= 0; i
< 4; i
++ ) {
643 int x
= dir
== 0 ? edge
: i
;
644 int y
= dir
== 0 ? i
: edge
;
645 int b_idx
= 8 + 4 + x
+ 8*y
;
646 int bn_idx
= b_idx
- (dir
? 8:1);
648 if( h
->non_zero_count_cache
[b_idx
] |
649 h
->non_zero_count_cache
[bn_idx
] ) {
654 bS
[i
] = check_mv(h
, b_idx
, bn_idx
, mvy_limit
);
658 if(bS
[0]+bS
[1]+bS
[2]+bS
[3] == 0)
663 // Do not use s->qscale as luma quantizer because it has not the same
664 // value in IPCM macroblocks.
665 qp
= h
->cur_pic
.qscale_table
[mb_xy
];
666 //tprintf(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]);
667 tprintf(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
);
668 //{ int i; for (i = 0; i < 4; i++) tprintf(h->avctx, " bS[%d]:%d", i, bS[i]); tprintf(h->avctx, "\n"); }
670 filter_mb_edgev( &img_y
[4*edge
<< h
->pixel_shift
], linesize
, bS
, qp
, a
, b
, h
, 0 );
673 filter_mb_edgev ( &img_cb
[4*edge
<< h
->pixel_shift
], uvlinesize
, bS
, h
->chroma_qp
[0], a
, b
, h
, 0);
674 filter_mb_edgev ( &img_cr
[4*edge
<< h
->pixel_shift
], uvlinesize
, bS
, h
->chroma_qp
[1], a
, b
, h
, 0);
675 } else if( (edge
&1) == 0 ) {
676 filter_mb_edgecv( &img_cb
[2*edge
<< h
->pixel_shift
], uvlinesize
, bS
, h
->chroma_qp
[0], a
, b
, h
, 0);
677 filter_mb_edgecv( &img_cr
[2*edge
<< h
->pixel_shift
], uvlinesize
, bS
, h
->chroma_qp
[1], a
, b
, h
, 0);
683 filter_mb_edgeh(&img_y
[4*edge
*linesize
], linesize
, bS
, qp
, a
, b
, h
, 0);
685 filter_mb_edgech(&img_cb
[4*edge
*uvlinesize
], uvlinesize
, bS
, h
->chroma_qp
[0], a
, b
, h
, 0);
686 filter_mb_edgech(&img_cr
[4*edge
*uvlinesize
], uvlinesize
, bS
, h
->chroma_qp
[1], a
, b
, h
, 0);
689 filter_mb_edgeh(&img_y
[4*edge
*linesize
], linesize
, bS
, qp
, a
, b
, h
, 0);
692 filter_mb_edgeh (&img_cb
[4*edge
*uvlinesize
], uvlinesize
, bS
, h
->chroma_qp
[0], a
, b
, h
, 0);
693 filter_mb_edgeh (&img_cr
[4*edge
*uvlinesize
], uvlinesize
, bS
, h
->chroma_qp
[1], a
, b
, h
, 0);
694 } else if ((edge
&1) == 0) {
695 filter_mb_edgech(&img_cb
[2*edge
*uvlinesize
], uvlinesize
, bS
, h
->chroma_qp
[0], a
, b
, h
, 0);
696 filter_mb_edgech(&img_cr
[2*edge
*uvlinesize
], uvlinesize
, bS
, h
->chroma_qp
[1], a
, b
, h
, 0);
704 void ff_h264_filter_mb( H264Context
*h
, int mb_x
, int mb_y
, uint8_t *img_y
, uint8_t *img_cb
, uint8_t *img_cr
, unsigned int linesize
, unsigned int uvlinesize
) {
705 const int mb_xy
= mb_x
+ mb_y
*h
->mb_stride
;
706 const int mb_type
= h
->cur_pic
.mb_type
[mb_xy
];
707 const int mvy_limit
= IS_INTERLACED(mb_type
) ? 2 : 4;
708 int first_vertical_edge_done
= 0;
709 int chroma
= CHROMA(h
) && !(CONFIG_GRAY
&& (h
->flags
&CODEC_FLAG_GRAY
));
710 int qp_bd_offset
= 6 * (h
->sps
.bit_depth_luma
- 8);
711 int a
= 52 + h
->slice_alpha_c0_offset
- qp_bd_offset
;
712 int b
= 52 + h
->slice_beta_offset
- qp_bd_offset
;
715 // and current and left pair do not have the same interlaced type
716 && IS_INTERLACED(mb_type
^h
->left_type
[LTOP
])
717 // and left mb is in available to us
718 && h
->left_type
[LTOP
]) {
719 /* First vertical edge is different in MBAFF frames
720 * There are 8 different bS to compute and 2 different Qp
722 DECLARE_ALIGNED(8, int16_t, bS
)[8];
726 int mb_qp
, mbn0_qp
, mbn1_qp
;
728 first_vertical_edge_done
= 1;
730 if( IS_INTRA(mb_type
) ) {
731 AV_WN64A(&bS
[0], 0x0004000400040004ULL
);
732 AV_WN64A(&bS
[4], 0x0004000400040004ULL
);
734 static const uint8_t offset
[2][2][8]={
736 {3+4*0, 3+4*0, 3+4*0, 3+4*0, 3+4*1, 3+4*1, 3+4*1, 3+4*1},
737 {3+4*2, 3+4*2, 3+4*2, 3+4*2, 3+4*3, 3+4*3, 3+4*3, 3+4*3},
739 {3+4*0, 3+4*1, 3+4*2, 3+4*3, 3+4*0, 3+4*1, 3+4*2, 3+4*3},
740 {3+4*0, 3+4*1, 3+4*2, 3+4*3, 3+4*0, 3+4*1, 3+4*2, 3+4*3},
743 const uint8_t *off
= offset
[MB_FIELD(h
)][mb_y
&1];
744 for( i
= 0; i
< 8; i
++ ) {
745 int j
= MB_FIELD(h
) ? i
>>2 : i
&1;
746 int mbn_xy
= h
->left_mb_xy
[LEFT(j
)];
747 int mbn_type
= h
->left_type
[LEFT(j
)];
749 if( IS_INTRA( mbn_type
) )
752 bS
[i
] = 1 + !!(h
->non_zero_count_cache
[12+8*(i
>>1)] |
753 ((!h
->pps
.cabac
&& IS_8x8DCT(mbn_type
)) ?
754 (h
->cbp_table
[mbn_xy
] & (((MB_FIELD(h
) ? (i
&2) : (mb_y
&1)) ? 8 : 2) << 12))
756 h
->non_zero_count
[mbn_xy
][ off
[i
] ]));
761 mb_qp
= h
->cur_pic
.qscale_table
[mb_xy
];
762 mbn0_qp
= h
->cur_pic
.qscale_table
[h
->left_mb_xy
[0]];
763 mbn1_qp
= h
->cur_pic
.qscale_table
[h
->left_mb_xy
[1]];
764 qp
[0] = ( mb_qp
+ mbn0_qp
+ 1 ) >> 1;
765 bqp
[0] = ( get_chroma_qp( h
, 0, mb_qp
) +
766 get_chroma_qp( h
, 0, mbn0_qp
) + 1 ) >> 1;
767 rqp
[0] = ( get_chroma_qp( h
, 1, mb_qp
) +
768 get_chroma_qp( h
, 1, mbn0_qp
) + 1 ) >> 1;
769 qp
[1] = ( mb_qp
+ mbn1_qp
+ 1 ) >> 1;
770 bqp
[1] = ( get_chroma_qp( h
, 0, mb_qp
) +
771 get_chroma_qp( h
, 0, mbn1_qp
) + 1 ) >> 1;
772 rqp
[1] = ( get_chroma_qp( h
, 1, mb_qp
) +
773 get_chroma_qp( h
, 1, mbn1_qp
) + 1 ) >> 1;
776 tprintf(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
);
777 { int i
; for (i
= 0; i
< 8; i
++) tprintf(h
->avctx
, " bS[%d]:%d", i
, bS
[i
]); tprintf(h
->avctx
, "\n"); }
779 filter_mb_mbaff_edgev ( h
, img_y
, linesize
, bS
, 1, qp
[0], a
, b
, 1 );
780 filter_mb_mbaff_edgev ( h
, img_y
+ 8* linesize
, linesize
, bS
+4, 1, qp
[1], a
, b
, 1 );
783 filter_mb_mbaff_edgev ( h
, img_cb
, uvlinesize
, bS
, 1, bqp
[0], a
, b
, 1 );
784 filter_mb_mbaff_edgev ( h
, img_cb
+ 8*uvlinesize
, uvlinesize
, bS
+4, 1, bqp
[1], a
, b
, 1 );
785 filter_mb_mbaff_edgev ( h
, img_cr
, uvlinesize
, bS
, 1, rqp
[0], a
, b
, 1 );
786 filter_mb_mbaff_edgev ( h
, img_cr
+ 8*uvlinesize
, uvlinesize
, bS
+4, 1, rqp
[1], a
, b
, 1 );
787 } else if (CHROMA422(h
)) {
788 filter_mb_mbaff_edgecv(h
, img_cb
, uvlinesize
, bS
, 1, bqp
[0], a
, b
, 1);
789 filter_mb_mbaff_edgecv(h
, img_cb
+ 8*uvlinesize
, uvlinesize
, bS
+4, 1, bqp
[1], a
, b
, 1);
790 filter_mb_mbaff_edgecv(h
, img_cr
, uvlinesize
, bS
, 1, rqp
[0], a
, b
, 1);
791 filter_mb_mbaff_edgecv(h
, img_cr
+ 8*uvlinesize
, uvlinesize
, bS
+4, 1, rqp
[1], a
, b
, 1);
793 filter_mb_mbaff_edgecv( h
, img_cb
, uvlinesize
, bS
, 1, bqp
[0], a
, b
, 1 );
794 filter_mb_mbaff_edgecv( h
, img_cb
+ 4*uvlinesize
, uvlinesize
, bS
+4, 1, bqp
[1], a
, b
, 1 );
795 filter_mb_mbaff_edgecv( h
, img_cr
, uvlinesize
, bS
, 1, rqp
[0], a
, b
, 1 );
796 filter_mb_mbaff_edgecv( h
, img_cr
+ 4*uvlinesize
, uvlinesize
, bS
+4, 1, rqp
[1], a
, b
, 1 );
800 filter_mb_mbaff_edgev ( h
, img_y
, 2* linesize
, bS
, 2, qp
[0], a
, b
, 1 );
801 filter_mb_mbaff_edgev ( h
, img_y
+ linesize
, 2* linesize
, bS
+1, 2, qp
[1], a
, b
, 1 );
804 filter_mb_mbaff_edgev ( h
, img_cb
, 2*uvlinesize
, bS
, 2, bqp
[0], a
, b
, 1 );
805 filter_mb_mbaff_edgev ( h
, img_cb
+ uvlinesize
, 2*uvlinesize
, bS
+1, 2, bqp
[1], a
, b
, 1 );
806 filter_mb_mbaff_edgev ( h
, img_cr
, 2*uvlinesize
, bS
, 2, rqp
[0], a
, b
, 1 );
807 filter_mb_mbaff_edgev ( h
, img_cr
+ uvlinesize
, 2*uvlinesize
, bS
+1, 2, rqp
[1], a
, b
, 1 );
809 filter_mb_mbaff_edgecv( h
, img_cb
, 2*uvlinesize
, bS
, 2, bqp
[0], a
, b
, 1 );
810 filter_mb_mbaff_edgecv( h
, img_cb
+ uvlinesize
, 2*uvlinesize
, bS
+1, 2, bqp
[1], a
, b
, 1 );
811 filter_mb_mbaff_edgecv( h
, img_cr
, 2*uvlinesize
, bS
, 2, rqp
[0], a
, b
, 1 );
812 filter_mb_mbaff_edgecv( h
, img_cr
+ uvlinesize
, 2*uvlinesize
, bS
+1, 2, rqp
[1], a
, b
, 1 );
821 for (dir
= 0; dir
< 2; dir
++)
822 filter_mb_dir(h
, mb_x
, mb_y
, img_y
, img_cb
, img_cr
, linesize
,
823 uvlinesize
, mb_xy
, mb_type
, mvy_limit
,
824 dir
? 0 : first_vertical_edge_done
, a
, b
,
828 filter_mb_dir(h
, 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);
829 filter_mb_dir(h
, mb_x
, mb_y
, img_y
, img_cb
, img_cr
, linesize
, uvlinesize
, mb_xy
, mb_type
, mvy_limit
, 0, a
, b
, chroma
, 1);