h264_loopfilter.c
Go to the documentation of this file.
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 / MPEG4 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 "mpegvideo.h"
33 #include "h264.h"
34 #include "mathops.h"
35 #include "rectangle.h"
36 
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,
48  255,255,
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,
53 };
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,
64  18, 18,
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,
69 };
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 },
98 };
99 
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,
102  const int16_t bS[4],
103  unsigned int qp, int a, int b,
104  H264Context *h, int intra)
105 {
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;
110 
111  if( bS[0] < 4 || !intra ) {
112  int8_t tc[4];
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);
118  } else {
119  h->h264dsp.h264_h_loop_filter_luma_intra(pix, stride, alpha, beta);
120  }
121 }
122 
123 static av_always_inline void filter_mb_edgecv(uint8_t *pix, int stride,
124  const int16_t bS[4],
125  unsigned int qp, int a, int b,
126  H264Context *h, int intra)
127 {
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;
132 
133  if( bS[0] < 4 || !intra ) {
134  int8_t tc[4];
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);
140  } else {
141  h->h264dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
142  }
143 }
144 
145 static av_always_inline void filter_mb_mbaff_edgev(H264Context *h, uint8_t *pix,
146  int stride,
147  const int16_t bS[7], int bsi,
148  int qp, int a, int b,
149  int intra)
150 {
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;
155 
156  if( bS[0] < 4 || !intra ) {
157  int8_t tc[4];
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);
163  } else {
164  h->h264dsp.h264_h_loop_filter_luma_mbaff_intra(pix, stride, alpha, beta);
165  }
166 }
167 
168 static av_always_inline void filter_mb_mbaff_edgecv(H264Context *h,
169  uint8_t *pix, int stride,
170  const int16_t bS[7],
171  int bsi, int qp, int a,
172  int b, int intra)
173 {
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;
178 
179  if( bS[0] < 4 || !intra ) {
180  int8_t tc[4];
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);
186  } else {
187  h->h264dsp.h264_h_loop_filter_chroma_mbaff_intra(pix, stride, alpha, beta);
188  }
189 }
190 
191 static av_always_inline void filter_mb_edgeh(uint8_t *pix, int stride,
192  const int16_t bS[4],
193  unsigned int qp, int a, int b,
194  H264Context *h, int intra)
195 {
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;
200 
201  if( bS[0] < 4 || !intra ) {
202  int8_t tc[4];
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);
208  } else {
209  h->h264dsp.h264_v_loop_filter_luma_intra(pix, stride, alpha, beta);
210  }
211 }
212 
213 static av_always_inline void filter_mb_edgech(uint8_t *pix, int stride,
214  const int16_t bS[4],
215  unsigned int qp, int a, int b,
216  H264Context *h, int intra)
217 {
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;
222 
223  if( bS[0] < 4 || !intra ) {
224  int8_t tc[4];
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);
230  } else {
231  h->h264dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);
232  }
233 }
234 
235 static av_always_inline void h264_filter_mb_fast_internal(H264Context *h,
236  int mb_x, int mb_y,
237  uint8_t *img_y,
238  uint8_t *img_cb,
239  uint8_t *img_cr,
240  unsigned int linesize,
241  unsigned int uvlinesize,
242  int pixel_shift)
243 {
244  int chroma = CHROMA(h) && !(CONFIG_GRAY && (h->flags&CODEC_FLAG_GRAY));
245  int chroma444 = CHROMA444(h);
246  int chroma422 = CHROMA422(h);
247 
248  int mb_xy = h->mb_xy;
249  int left_type= h->left_type[LTOP];
250  int top_type= h->top_type;
251 
252  int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
253  int a = h->slice_alpha_c0_offset - qp_bd_offset;
254  int b = h->slice_beta_offset - qp_bd_offset;
255 
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;
267 
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;
272  if(left_type)
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);
276  if(top_type){
277  filter_mb_edgeh( &img_y[4*0*linesize], linesize, bSH, qp1, a, b, h, 1);
278  }
279  filter_mb_edgeh( &img_y[4*2*linesize], linesize, bS3, qp, a, b, h, 0);
280  } else {
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);
284  if(top_type){
285  filter_mb_edgeh( &img_y[4*0*linesize], linesize, bSH, qp1, a, b, h, 1);
286  }
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);
290  }
291  if(chroma){
292  if(chroma444){
293  if(left_type){
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);
296  }
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);
300  if(top_type){
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 );
303  }
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);
306  } else {
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);
313  if(top_type){
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);
316  }
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);
323  }
324  }else if(chroma422){
325  if(left_type){
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);
328  }
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);
331  if(top_type){
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);
334  }
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);
341  }else{
342  if(left_type){
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);
345  }
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);
348  if(top_type){
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);
351  }
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);
354  }
355  }
356  return;
357  } else {
358  LOCAL_ALIGNED_8(int16_t, bS, [2], [4][4]);
359  int edges;
360  if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 && !chroma444 ) {
361  edges = 4;
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);
366  } else {
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));
373  }
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);
378 
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 );\
382  if(chroma){\
383  if(chroma444){\
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 );\
389  }\
390  }\
391  }
392  if(left_type)
393  FILTER(v,0,0,1);
394  if( edges == 1 ) {
395  if(top_type)
396  FILTER(h,1,0,1);
397  } else if( IS_8x8DCT(mb_type) ) {
398  FILTER(v,0,2,0);
399  if(top_type)
400  FILTER(h,1,0,1);
401  FILTER(h,1,2,0);
402  } else {
403  FILTER(v,0,1,0);
404  FILTER(v,0,2,0);
405  FILTER(v,0,3,0);
406  if(top_type)
407  FILTER(h,1,0,1);
408  FILTER(h,1,1,0);
409  FILTER(h,1,2,0);
410  FILTER(h,1,3,0);
411  }
412 #undef FILTER
413  }
414 }
415 
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);
420  return;
421  }
422 
423 #if CONFIG_SMALL
424  h264_filter_mb_fast_internal(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, h->pixel_shift);
425 #else
426  if(h->pixel_shift){
427  h264_filter_mb_fast_internal(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 1);
428  }else{
429  h264_filter_mb_fast_internal(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 0);
430  }
431 #endif
432 }
433 
434 static int check_mv(H264Context *h, long b_idx, long bn_idx, int mvy_limit){
435  int v;
436 
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;
441 
442  if(h->list_count==2){
443  if(!v)
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;
447 
448  if(v){
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])
451  return 1;
452  return
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;
457  }
458  }
459 
460  return v;
461 }
462 
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) {
464  int edge;
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;
470 
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},
473  {0,3,1,1,3,3,3,3}};
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;
476 
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));
479 
480  if(mbm_type && !first_vertical_edge_done){
481 
482  if (FRAME_MBAFF(h) && (dir == 1) && ((mb_y&1) == 0)
483  && IS_INTERLACED(mbm_type&~mb_type)
484  ) {
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
487  // frame macroblock.
488  //
489  unsigned int tmp_linesize = 2 * linesize;
490  unsigned int tmp_uvlinesize = 2 * uvlinesize;
491  int mbn_xy = mb_xy - 2 * h->mb_stride;
492  int j;
493 
494  for(j=0; j<2; j++, mbn_xy += h->mb_stride){
495  DECLARE_ALIGNED(8, int16_t, bS)[4];
496  int qp;
497  if (IS_INTRA(mb_type | h->cur_pic.mb_type[mbn_xy])) {
498  AV_WN64A(bS, 0x0003000300030003ULL);
499  } else {
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]);
505  }else{
506  const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy] + 3*4;
507  int i;
508  for( i = 0; i < 4; i++ ) {
509  bS[i] = 1 + !!(h->non_zero_count_cache[scan8[0]+i] | mbn_nnz[i]);
510  }
511  }
512  }
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;
521  if (chroma) {
522  if (chroma444) {
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);
525  } else {
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);
528  }
529  }
530  }
531  }else{
532  DECLARE_ALIGNED(8, int16_t, bS)[4];
533  int qp;
534 
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))
539  )
540  AV_WN64A(bS, 0x0004000400040004ULL);
541  } else {
542  int i;
543  int mv_done;
544 
545  if( dir && FRAME_MBAFF(h) && IS_INTERLACED(mb_type ^ mbm_type)) {
546  AV_WN64A(bS, 0x0001000100010001ULL);
547  mv_done = 1;
548  }
549  else if( mask_par0 && ((mbm_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) {
550  int b_idx= 8 + 4;
551  int bn_idx= b_idx - (dir ? 8:1);
552 
553  bS[0] = bS[1] = bS[2] = bS[3] = check_mv(h, 8 + 4, bn_idx, mvy_limit);
554  mv_done = 1;
555  }
556  else
557  mv_done = 0;
558 
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);
564 
565  if( h->non_zero_count_cache[b_idx] |
566  h->non_zero_count_cache[bn_idx] ) {
567  bS[i] = 2;
568  }
569  else if(!mv_done)
570  {
571  bS[i] = check_mv(h, b_idx, bn_idx, mvy_limit);
572  }
573  }
574  }
575 
576  /* Filter edge */
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;
586  if( dir == 0 ) {
587  filter_mb_edgev( &img_y[0], linesize, bS, qp, a, b, h, 1 );
588  if (chroma) {
589  if (chroma444) {
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);
592  } else {
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);
595  }
596  }
597  } else {
598  filter_mb_edgeh( &img_y[0], linesize, bS, qp, a, b, h, 1 );
599  if (chroma) {
600  if (chroma444) {
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);
603  } else {
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);
606  }
607  }
608  }
609  }
610  }
611  }
612 
613  /* Calculate bS */
614  for( edge = 1; edge < edges; edge++ ) {
615  DECLARE_ALIGNED(8, int16_t, bS)[4];
616  int qp;
617  const int deblock_edge = !IS_8x8DCT(mb_type & (edge<<24)); // (edge&1) && IS_8x8DCT(mb_type)
618 
619  if (!deblock_edge && (!chroma422 || dir == 0))
620  continue;
621 
622  if( IS_INTRA(mb_type)) {
623  AV_WN64A(bS, 0x0003000300030003ULL);
624  } else {
625  int i;
626  int mv_done;
627 
628  if( edge & mask_edge ) {
629  AV_ZERO64(bS);
630  mv_done = 1;
631  }
632  else if( mask_par0 ) {
633  int b_idx= 8 + 4 + edge * (dir ? 8:1);
634  int bn_idx= b_idx - (dir ? 8:1);
635 
636  bS[0] = bS[1] = bS[2] = bS[3] = check_mv(h, b_idx, bn_idx, mvy_limit);
637  mv_done = 1;
638  }
639  else
640  mv_done = 0;
641 
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);
647 
648  if( h->non_zero_count_cache[b_idx] |
649  h->non_zero_count_cache[bn_idx] ) {
650  bS[i] = 2;
651  }
652  else if(!mv_done)
653  {
654  bS[i] = check_mv(h, b_idx, bn_idx, mvy_limit);
655  }
656  }
657 
658  if(bS[0]+bS[1]+bS[2]+bS[3] == 0)
659  continue;
660  }
661 
662  /* Filter edge */
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"); }
669  if( dir == 0 ) {
670  filter_mb_edgev( &img_y[4*edge << h->pixel_shift], linesize, bS, qp, a, b, h, 0 );
671  if (chroma) {
672  if (chroma444) {
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);
678  }
679  }
680  } else {
681  if (chroma422) {
682  if (deblock_edge)
683  filter_mb_edgeh(&img_y[4*edge*linesize], linesize, bS, qp, a, b, h, 0);
684  if (chroma) {
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);
687  }
688  } else {
689  filter_mb_edgeh(&img_y[4*edge*linesize], linesize, bS, qp, a, b, h, 0);
690  if (chroma) {
691  if (chroma444) {
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);
697  }
698  }
699  }
700  }
701  }
702 }
703 
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  av_unused int dir;
710  int chroma = CHROMA(h) && !(CONFIG_GRAY && (h->flags&CODEC_FLAG_GRAY));
711  int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
712  int a = h->slice_alpha_c0_offset - qp_bd_offset;
713  int b = h->slice_beta_offset - qp_bd_offset;
714 
715  if (FRAME_MBAFF(h)
716  // and current and left pair do not have the same interlaced type
717  && IS_INTERLACED(mb_type^h->left_type[LTOP])
718  // and left mb is in available to us
719  && h->left_type[LTOP]) {
720  /* First vertical edge is different in MBAFF frames
721  * There are 8 different bS to compute and 2 different Qp
722  */
723  DECLARE_ALIGNED(8, int16_t, bS)[8];
724  int qp[2];
725  int bqp[2];
726  int rqp[2];
727  int mb_qp, mbn0_qp, mbn1_qp;
728  int i;
729  first_vertical_edge_done = 1;
730 
731  if( IS_INTRA(mb_type) ) {
732  AV_WN64A(&bS[0], 0x0004000400040004ULL);
733  AV_WN64A(&bS[4], 0x0004000400040004ULL);
734  } else {
735  static const uint8_t offset[2][2][8]={
736  {
737  {3+4*0, 3+4*0, 3+4*0, 3+4*0, 3+4*1, 3+4*1, 3+4*1, 3+4*1},
738  {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  },{
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},
741  {3+4*0, 3+4*1, 3+4*2, 3+4*3, 3+4*0, 3+4*1, 3+4*2, 3+4*3},
742  }
743  };
744  const uint8_t *off= offset[MB_FIELD(h)][mb_y&1];
745  for( i = 0; i < 8; i++ ) {
746  int j= MB_FIELD(h) ? i>>2 : i&1;
747  int mbn_xy = h->left_mb_xy[LEFT(j)];
748  int mbn_type= h->left_type[LEFT(j)];
749 
750  if( IS_INTRA( mbn_type ) )
751  bS[i] = 4;
752  else{
753  bS[i] = 1 + !!(h->non_zero_count_cache[12+8*(i>>1)] |
754  ((!h->pps.cabac && IS_8x8DCT(mbn_type)) ?
755  (h->cbp_table[mbn_xy] & (((MB_FIELD(h) ? (i&2) : (mb_y&1)) ? 8 : 2) << 12))
756  :
757  h->non_zero_count[mbn_xy][ off[i] ]));
758  }
759  }
760  }
761 
762  mb_qp = h->cur_pic.qscale_table[mb_xy];
763  mbn0_qp = h->cur_pic.qscale_table[h->left_mb_xy[0]];
764  mbn1_qp = h->cur_pic.qscale_table[h->left_mb_xy[1]];
765  qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1;
766  bqp[0] = ( get_chroma_qp( h, 0, mb_qp ) +
767  get_chroma_qp( h, 0, mbn0_qp ) + 1 ) >> 1;
768  rqp[0] = ( get_chroma_qp( h, 1, mb_qp ) +
769  get_chroma_qp( h, 1, mbn0_qp ) + 1 ) >> 1;
770  qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1;
771  bqp[1] = ( get_chroma_qp( h, 0, mb_qp ) +
772  get_chroma_qp( h, 0, mbn1_qp ) + 1 ) >> 1;
773  rqp[1] = ( get_chroma_qp( h, 1, mb_qp ) +
774  get_chroma_qp( h, 1, mbn1_qp ) + 1 ) >> 1;
775 
776  /* Filter edge */
777  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);
778  { int i; for (i = 0; i < 8; i++) tprintf(h->avctx, " bS[%d]:%d", i, bS[i]); tprintf(h->avctx, "\n"); }
779  if (MB_FIELD(h)) {
780  filter_mb_mbaff_edgev ( h, img_y , linesize, bS , 1, qp [0], a, b, 1 );
781  filter_mb_mbaff_edgev ( h, img_y + 8* linesize, linesize, bS+4, 1, qp [1], a, b, 1 );
782  if (chroma){
783  if (CHROMA444(h)) {
784  filter_mb_mbaff_edgev ( h, img_cb, uvlinesize, bS , 1, bqp[0], a, b, 1 );
785  filter_mb_mbaff_edgev ( h, img_cb + 8*uvlinesize, uvlinesize, bS+4, 1, bqp[1], a, b, 1 );
786  filter_mb_mbaff_edgev ( h, img_cr, uvlinesize, bS , 1, rqp[0], a, b, 1 );
787  filter_mb_mbaff_edgev ( h, img_cr + 8*uvlinesize, uvlinesize, bS+4, 1, rqp[1], a, b, 1 );
788  } else if (CHROMA422(h)) {
789  filter_mb_mbaff_edgecv(h, img_cb, uvlinesize, bS , 1, bqp[0], a, b, 1);
790  filter_mb_mbaff_edgecv(h, img_cb + 8*uvlinesize, uvlinesize, bS+4, 1, bqp[1], a, b, 1);
791  filter_mb_mbaff_edgecv(h, img_cr, uvlinesize, bS , 1, rqp[0], a, b, 1);
792  filter_mb_mbaff_edgecv(h, img_cr + 8*uvlinesize, uvlinesize, bS+4, 1, rqp[1], a, b, 1);
793  }else{
794  filter_mb_mbaff_edgecv( h, img_cb, uvlinesize, bS , 1, bqp[0], a, b, 1 );
795  filter_mb_mbaff_edgecv( h, img_cb + 4*uvlinesize, uvlinesize, bS+4, 1, bqp[1], a, b, 1 );
796  filter_mb_mbaff_edgecv( h, img_cr, uvlinesize, bS , 1, rqp[0], a, b, 1 );
797  filter_mb_mbaff_edgecv( h, img_cr + 4*uvlinesize, uvlinesize, bS+4, 1, rqp[1], a, b, 1 );
798  }
799  }
800  }else{
801  filter_mb_mbaff_edgev ( h, img_y , 2* linesize, bS , 2, qp [0], a, b, 1 );
802  filter_mb_mbaff_edgev ( h, img_y + linesize, 2* linesize, bS+1, 2, qp [1], a, b, 1 );
803  if (chroma){
804  if (CHROMA444(h)) {
805  filter_mb_mbaff_edgev ( h, img_cb, 2*uvlinesize, bS , 2, bqp[0], a, b, 1 );
806  filter_mb_mbaff_edgev ( h, img_cb + uvlinesize, 2*uvlinesize, bS+1, 2, bqp[1], a, b, 1 );
807  filter_mb_mbaff_edgev ( h, img_cr, 2*uvlinesize, bS , 2, rqp[0], a, b, 1 );
808  filter_mb_mbaff_edgev ( h, img_cr + uvlinesize, 2*uvlinesize, bS+1, 2, rqp[1], a, b, 1 );
809  }else{
810  filter_mb_mbaff_edgecv( h, img_cb, 2*uvlinesize, bS , 2, bqp[0], a, b, 1 );
811  filter_mb_mbaff_edgecv( h, img_cb + uvlinesize, 2*uvlinesize, bS+1, 2, bqp[1], a, b, 1 );
812  filter_mb_mbaff_edgecv( h, img_cr, 2*uvlinesize, bS , 2, rqp[0], a, b, 1 );
813  filter_mb_mbaff_edgecv( h, img_cr + uvlinesize, 2*uvlinesize, bS+1, 2, rqp[1], a, b, 1 );
814  }
815  }
816  }
817  }
818 
819 #if CONFIG_SMALL
820  for( dir = 0; dir < 2; dir++ )
821  filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, dir ? 0 : first_vertical_edge_done, a, b, chroma, dir);
822 #else
823  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);
824  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);
825 #endif
826 }
v
float v
Definition: avf_showspectrum.c:88
CHROMA444
#define CHROMA444(h)
Definition: h264.h:92
H264Context::cbp
int cbp
Definition: h264.h:435
H264DSPContext::h264_h_loop_filter_chroma_mbaff_intra
void(* h264_h_loop_filter_chroma_mbaff_intra)(uint8_t *pix, int stride, int alpha, int beta)
Definition: h264dsp.h:71
H264Context::left_type
int left_type[LEFT_MBS]
Definition: h264.h:311
H264Context::cbp_table
uint16_t * cbp_table
Definition: h264.h:434
H264Context::mb_y
int mb_y
Definition: h264.h:461
alpha_table
static const uint8_t alpha_table[52 *3]
Definition: h264_loopfilter.c:38
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:59
H264Context::flags
int flags
Definition: h264.h:293
tc
#define tc
Definition: regdef.h:69
mpegvideo.h
mpegvideo header.
H264Context
H264Context.
Definition: h264.h:260
PPS::chroma_qp_diff
int chroma_qp_diff
Definition: h264.h:232
stride
int stride
Definition: mace.c:144
H264Context::picture_structure
int picture_structure
Definition: h264.h:382
IS_8x8DCT
#define IS_8x8DCT(a)
Definition: h264.h:99
uint8_t
uint8_t
Definition: audio_convert.c:194
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
PICT_FRAME
#define PICT_FRAME
Definition: mpegvideo.h:664
CHROMA
#define CHROMA(h)
Definition: h264.h:90
H264DSPContext::h264_v_loop_filter_luma_intra
void(* h264_v_loop_filter_luma_intra)(uint8_t *pix, int stride, int alpha, int beta)
Definition: h264dsp.h:54
b
#define b
Definition: input.c:42
PPS::cabac
int cabac
entropy_coding_mode_flag
Definition: h264.h:215
H264Context::mb_xy
int mb_xy
Definition: h264.h:468
H264Context::uvlinesize
int uvlinesize
Definition: h264.h:283
H264Context::mb_x
int mb_x
Definition: h264.h:461
filter_mb_edgech
static av_always_inline void filter_mb_edgech(uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, int a, int b, H264Context *h, int intra)
Definition: h264_loopfilter.c:213
H264Context::left_mb_xy
int left_mb_xy[LEFT_MBS]
Definition: h264.h:306
ff_h264_filter_mb
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)
Definition: h264_loopfilter.c:704
H264Context::top_mb_xy
int top_mb_xy
Definition: h264.h:304
H264DSPContext::h264_h_loop_filter_luma_mbaff_intra
void(* h264_h_loop_filter_luma_mbaff_intra)(uint8_t *pix, int stride, int alpha, int beta)
Definition: h264dsp.h:58
IS_INTERLACED
#define IS_INTERLACED(a)
Definition: mpegvideo.h:142
LOCAL_ALIGNED_8
#define LOCAL_ALIGNED_8(t, v,...)
Definition: libavutil/internal.h:86
h264.h
H.264 / AVC / MPEG4 part10 codec.
x
Discrete Time axis x
Definition: FFT of a Simple Sinusoid.m:10
U
#define U(x)
Definition: arm/vp56_arith.h:37
filter_mb_mbaff_edgecv
static av_always_inline void filter_mb_mbaff_edgecv(H264Context *h, uint8_t *pix, int stride, const int16_t bS[7], int bsi, int qp, int a, int b, int intra)
Definition: h264_loopfilter.c:168
alpha
static double alpha(void *priv, double x, double y)
Definition: vf_geq.c:86
get_chroma_qp
static av_always_inline int get_chroma_qp(H264Context *h, int t, int qscale)
Get the chroma qp.
Definition: h264.h:849
MB_FIELD
#define MB_FIELD(h)
Definition: h264.h:65
H264Context::pps
PPS pps
current pps
Definition: h264.h:365
CABAC
#define CABAC(h)
Definition: h264.h:87
IS_INTRA
#define IS_INTRA(a)
Definition: mpegvideo.h:138
H264DSPContext::h264_h_loop_filter_chroma_mbaff
void(* h264_h_loop_filter_chroma_mbaff)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
Definition: h264dsp.h:64
offset
static const uint8_t offset[127][2]
Definition: vf_spp.c:70
avcodec.h
external API header
scan8
static const uint8_t scan8[16 *3+3]
Definition: h264.h:812
internal.h
common internal API header
rectangle.h
useful rectangle filling function
H264DSPContext::h264_v_loop_filter_chroma
void(* h264_v_loop_filter_chroma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
Definition: h264dsp.h:60
H264DSPContext::h264_h_loop_filter_chroma
void(* h264_h_loop_filter_chroma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
Definition: h264dsp.h:62
FIELD_PICTURE
#define FIELD_PICTURE(h)
Definition: h264.h:67
H264Context::sps
SPS sps
current sps
Definition: h264.h:360
H264DSPContext::h264_h_loop_filter_chroma_intra
void(* h264_h_loop_filter_chroma_intra)(uint8_t *pix, int stride, int alpha, int beta)
Definition: h264dsp.h:69
H264DSPContext::h264_h_loop_filter_luma_mbaff
void(* h264_h_loop_filter_luma_mbaff)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
Definition: h264dsp.h:51
FFABS
#define FFABS(a)
Definition: common.h:53
H264DSPContext::h264_v_loop_filter_luma
void(* h264_v_loop_filter_luma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
Definition: h264dsp.h:47
CONFIG_GRAY
#define CONFIG_GRAY
Definition: config.h:376
AV_WN64A
#define AV_WN64A(p, v)
Definition: intreadwrite.h:534
H264Context::top_type
int top_type
Definition: h264.h:309
H264Context::list_count
unsigned int list_count
Definition: h264.h:409
h264_filter_mb_fast_internal
static av_always_inline void h264_filter_mb_fast_internal(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 pixel_shift)
Definition: h264_loopfilter.c:235
H264Context::cur_pic
Picture cur_pic
Definition: h264.h:274
H264Context::mb_stride
int mb_stride
Definition: h264.h:466
H264Context::avctx
AVCodecContext * avctx
Definition: h264.h:261
MB_TYPE_8x16
#define MB_TYPE_8x16
Definition: libavcodec/avcodec.h:842
H264Context::slice_alpha_c0_offset
int slice_alpha_c0_offset
Definition: h264.h:474
LTOP
#define LTOP
Definition: h264.h:69
check_mv
static int check_mv(H264Context *h, long b_idx, long bn_idx, int mvy_limit)
Definition: h264_loopfilter.c:434
filter_mb_dir
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)
Definition: h264_loopfilter.c:463
H264DSPContext::h264_loop_filter_strength
void(* h264_loop_filter_strength)(int16_t bS[2][4][4], uint8_t nnz[40], int8_t ref[2][40], int16_t mv[2][40][2], int bidir, int edges, int step, int mask_mv0, int mask_mv1, int field)
Definition: h264dsp.h:74
tc0_table
static const uint8_t tc0_table[52 *3][4]
Definition: h264_loopfilter.c:70
H264Context::slice_beta_offset
int slice_beta_offset
Definition: h264.h:475
CHROMA422
#define CHROMA422(h)
Definition: h264.h:91
i
synthesis window for stochastic i
Definition: code Kat/hpsmodel.m:34
filter_mb_mbaff_edgev
static av_always_inline void filter_mb_mbaff_edgev(H264Context *h, uint8_t *pix, int stride, const int16_t bS[7], int bsi, int qp, int a, int b, int intra)
Definition: h264_loopfilter.c:145
H264Context::pixel_shift
int pixel_shift
0 for 8-bit H264, 1 for high-bit-depth H264
Definition: h264.h:276
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: libavcodec/avcodec.h:840
filter_mb_edgeh
static av_always_inline void filter_mb_edgeh(uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, int a, int b, H264Context *h, int intra)
Definition: h264_loopfilter.c:191
H264DSPContext::h264_h_loop_filter_luma
void(* h264_h_loop_filter_luma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
Definition: h264dsp.h:49
Picture::qscale_table
int8_t * qscale_table
Definition: mpegvideo.h:102
filter_mb_edgev
static av_always_inline void filter_mb_edgev(uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, int a, int b, H264Context *h, int intra)
Definition: h264_loopfilter.c:101
AV_ZERO64
#define AV_ZERO64(d)
Definition: intreadwrite.h:610
tprintf
#define tprintf(p,...)
Definition: get_bits.h:628
internal.h
common internal api header.
CODEC_FLAG_GRAY
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: libavcodec/avcodec.h:706
FILTER
#define FILTER(hv, dir, edge, intra)
y
function y
Definition: D.m:1
H264Context::chroma_qp
int chroma_qp[2]
Definition: h264.h:277
SPS::bit_depth_luma
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264.h:203
H264Context::linesize
int linesize
Definition: h264.h:283
H264DSPContext::h264_h_loop_filter_luma_intra
void(* h264_h_loop_filter_luma_intra)(uint8_t *pix, int stride, int alpha, int beta)
Definition: h264dsp.h:56
FRAME_MBAFF
#define FRAME_MBAFF(h)
Definition: h264.h:66
H264Context::h264dsp
H264DSPContext h264dsp
Definition: h264.h:263
Picture::mb_type
uint32_t * mb_type
Definition: mpegvideo.h:108
av_always_inline
#define av_always_inline
Definition: attributes.h:41
filter_mb_edgecv
static av_always_inline void filter_mb_edgecv(uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, int a, int b, H264Context *h, int intra)
Definition: h264_loopfilter.c:123
H264DSPContext::h264_v_loop_filter_chroma_intra
void(* h264_v_loop_filter_chroma_intra)(uint8_t *pix, int stride, int alpha, int beta)
Definition: h264dsp.h:67
LEFT
#define LEFT
Definition: cdgraphics.c:163
H264Context::non_zero_count
uint8_t(* non_zero_count)[48]
Definition: h264.h:331
beta_table
static const uint8_t beta_table[52 *3]
Definition: h264_loopfilter.c:54
av_unused
#define av_unused
Definition: attributes.h:114
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:12
ff_h264_filter_mb_fast
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)
Definition: h264_loopfilter.c:416
a
a
Definition: h264pred_template.c:466
Generated on Wed May 8 2024 06:52:06 for FFmpeg by   doxygen 1.8.11