Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libavc / refs/tags/rel/13/fp3/6.A.023.1 / . / common / ih264_deblk_edge_filters.c
blob: d2ffefdc33e630bb7a22e7d09377f62d3fb2d48b [file] [log] [blame]
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]1/******************************************************************************
2 *
3 * Copyright (C) 2015 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19*/
20/**************************************************************************** */
21/* */
22/* File Name : ih264_deblk_edge_filters.c */
23/* */
24/* Description : Contains function definitions for deblocking */
25/* */
26/* List of Functions : ih264_deblk_luma_vert_bs4() */
27/* ih264_deblk_luma_horz_bs4() */
28/* ih264_deblk_luma_vert_bslt4() */
29/* ih264_deblk_luma_horz_bslt4() */
30/* ih264_deblk_luma_vert_bs4_mbaff() */
31/* ih264_deblk_luma_vert_bslt4_mbaff() */
32/* ih264_deblk_chroma_vert_bs4_bp() */
33/* ih264_deblk_chroma_horz_bs4_bp() */
34/* ih264_deblk_chroma_vert_bslt4_bp() */
35/* ih264_deblk_chroma_horz_bslt4_bp() */
36/* ih264_deblk_chroma_vert_bs4_mbaff_bp() */
37/* ih264_deblk_chroma_vert_bslt4_mbaff_bp() */
38/* ih264_deblk_chroma_vert_bs4() */
39/* ih264_deblk_chroma_horz_bs4() */
40/* ih264_deblk_chroma_vert_bslt4() */
41/* ih264_deblk_chroma_horz_bslt4() */
42/* ih264_deblk_chroma_vert_bs4_mbaff() */
43/* ih264_deblk_chroma_vert_bslt4_mbaff() */
44/* */
45/* Issues / Problems : None */
46/* */
47/* Revision History : */
48/* */
49/* DD MM YYYY Author(s) Changes (Describe the changes made) */
50/* 28 11 2013 Ittiam Draft */
51/* 29 12 2014 Kaushik Added double-call vertical */
52/* Senthoor deblocking and high profile */
53/* deblocking functions */
54/* */
55/******************************************************************************/
56
57/*****************************************************************************/
58/* File Includes */
59/*****************************************************************************/
60
61/* System include files */
62#include <stdio.h>
63
64/* User include files */
65#include "ih264_typedefs.h"
66#include "ih264_platform_macros.h"
67#include "ih264_deblk_edge_filters.h"
68#include "ih264_macros.h"
69
70/*****************************************************************************/
71/* Function Definitions */
72/*****************************************************************************/
73
74/*****************************************************************************/
75/* */
76/* Function Name : ih264_deblk_luma_vert_bs4() */
77/* */
78/* Description : This function performs filtering of a luma block */
79/* vertical edge when the boundary strength is set to 4. */
80/* */
81/* Inputs : pu1_src - pointer to the src sample q0 */
82/* src_strd - source stride */
83/* alpha - alpha value for the boundary */
84/* beta - beta value for the boundary */
85/* */
86/* Globals : None */
87/* */
88/* Processing : This operation is described in Sec. 8.7.2.4 under the */
89/* title "Filtering process for edges for bS equal to 4" in */
90/* ITU T Rec H.264. */
91/* */
92/* Outputs : None */
93/* */
94/* Returns : None */
95/* */
96/* Issues : None */
97/* */
98/* Revision History: */
99/* */
100/* DD MM YYYY Author(s) Changes (Describe the changes made) */
101/* 28 11 2013 Ittiam Draft */
102/* */
103/*****************************************************************************/
104void ih264_deblk_luma_vert_bs4(UWORD8 *pu1_src,
105 WORD32 src_strd,
106 WORD32 alpha,
107 WORD32 beta)
108{
109 UWORD8 p3, p2, p1, p0, q0, q1, q2, q3;
110 WORD32 pos_p3, pos_p2, pos_p1, pos_p0;
111 WORD32 pos_q0, pos_q1, pos_q2,pos_q3;
112 UWORD8 a_p, a_q; /* threshold variables */
113 WORD32 blk_strd = src_strd << 2; /* block_increment = src_strd * 4 */
114 UWORD8 *pu1_src_temp;
115 WORD8 i = 0, edge;
116
117 pos_q0 = 0;
118 pos_q1 = 1;
119 pos_q2 = 2;
120 pos_q3 = 3;
121 pos_p0 = -1;
122 pos_p1 = -2;
123 pos_p2 = -3;
124 pos_p3 = -4;
125
126 for(edge = 0; edge < 4; edge++, pu1_src += blk_strd)
127 {
128 pu1_src_temp = pu1_src;
129 for(i = 0; i < 4; ++i, pu1_src_temp += src_strd)
130 {
131 q0 = pu1_src_temp[pos_q0];
132 q1 = pu1_src_temp[pos_q1];
133 p0 = pu1_src_temp[pos_p0];
134 p1 = pu1_src_temp[pos_p1];
135
136 /* Filter Decision */
137 if((ABS(p0 - q0) >= alpha) ||
138 (ABS(q1 - q0) >= beta) ||
139 (ABS(p1 - p0) >= beta))
140 continue;
141
142 p2 = pu1_src_temp[pos_p2];
143 p3 = pu1_src_temp[pos_p3];
144 q2 = pu1_src_temp[pos_q2];
145 q3 = pu1_src_temp[pos_q3];
146
147 if(ABS(p0 - q0) < ((alpha >> 2) + 2))
148 {
149 /* Threshold Variables */
150 a_p = (UWORD8)ABS(p2 - p0);
151 a_q = (UWORD8)ABS(q2 - q0);
152
153 if(a_p < beta)
154 {
155 /* p0', p1', p2' */
156 pu1_src_temp[pos_p0] = ((p2 + X2(p1) + X2(p0) + X2(q0) + q1
157 + 4) >> 3);
158 pu1_src_temp[pos_p1] = ((p2 + p1 + p0 + q0 + 2) >> 2);
159 pu1_src_temp[pos_p2] =
160 ((X2(p3) + X3(p2) + p1 + p0 + q0
161 + 4) >> 3);
162 }
163 else
164 {
165 /* p0'*/
166 pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2);
167 }
168
169 if(a_q < beta)
170 {
171 /* q0', q1', q2' */
172 pu1_src_temp[pos_q0] = (p1 + X2(p0) + X2(q0) + X2(q1) + q2
173 + 4) >> 3;
174 pu1_src_temp[pos_q1] = (p0 + q0 + q1 + q2 + 2) >> 2;
175 pu1_src_temp[pos_q2] = (X2(q3) + X3(q2) + q1 + q0 + p0 + 4)
176 >> 3;
177 }
178 else
179 {
180 /* q0'*/
181 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2;
182 }
183 }
184 else
185 {
186 /* p0', q0'*/
187 pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2);
188 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2;
189 }
190 }
191 }
192}
193
194/*****************************************************************************/
195/* */
196/* Function Name : ih264_deblk_luma_horz_bs4() */
197/* */
198/* Description : This function performs filtering of a luma block */
199/* horizontal edge when the boundary strength is set to 4. */
200/* */
201/* Inputs : pu1_src - pointer to the src sample q0 */
202/* src_strd - source stride */
203/* alpha - alpha value for the boundary */
204/* beta - beta value for the boundary */
205/* */
206/* Globals : None */
207/* */
208/* Processing : This operation is described in Sec. 8.7.2.4 under the */
209/* title "Filtering process for edges for bS equal to 4" in */
210/* ITU T Rec H.264. */
211/* */
212/* Outputs : None */
213/* */
214/* Returns : None */
215/* */
216/* Issues : None */
217/* */
218/* Revision History: */
219/* */
220/* DD MM YYYY Author(s) Changes (Describe the changes made) */
221/* 28 11 2013 Ittiam Draft */
222/* */
223/*****************************************************************************/
224void ih264_deblk_luma_horz_bs4(UWORD8 *pu1_src,
225 WORD32 src_strd,
226 WORD32 alpha,
227 WORD32 beta)
228{
229 UWORD8 p3, p2, p1, p0, q0, q1, q2, q3;
230 WORD32 pos_p3, pos_p2, pos_p1, pos_p0, pos_q0, pos_q1,
231 pos_q2, pos_q3;
232 UWORD8 a_p, a_q; /* threshold variables */
233 UWORD8 *pu1_p3; /* pointer to the src sample p3 */
234 UWORD8 *pu1_p3_temp;
235 UWORD8 *pu1_src_temp;
236 WORD8 i = 0, edge;
237
238 pu1_p3 = pu1_src - (src_strd << 2);
239 pos_q0 = 0;
240 pos_q1 = src_strd;
241 pos_q2 = X2(src_strd);
242 pos_q3 = X3(src_strd);
243 pos_p0 = X3(src_strd);
244 pos_p1 = X2(src_strd);
245 pos_p2 = src_strd;
246 pos_p3 = 0;
247
248 for(edge = 0; edge < 4; edge++, pu1_src += 4, pu1_p3 += 4)
249 {
250 pu1_src_temp = pu1_src;
251 pu1_p3_temp = pu1_p3;
252 for(i = 0; i < 4; ++i, pu1_src_temp++, pu1_p3_temp++)
253 {
254 q0 = pu1_src_temp[pos_q0];
255 q1 = pu1_src_temp[pos_q1];
256 p0 = pu1_p3_temp[pos_p0];
257 p1 = pu1_p3_temp[pos_p1];
258
259 /* Filter Decision */
260 if((ABS(p0 - q0) >= alpha) ||
261 (ABS(q1 - q0) >= beta) ||
262 (ABS(p1 - p0) >= beta))
263 continue;
264
265 p2 = pu1_p3_temp[pos_p2];
266 p3 = pu1_p3_temp[pos_p3];
267 q2 = pu1_src_temp[pos_q2];
268 q3 = pu1_src_temp[pos_q3];
269
270 if(ABS(p0 - q0) < ((alpha >> 2) + 2))
271 {
272 /* Threshold Variables */
273 a_p = ABS(p2 - p0);
274 a_q = ABS(q2 - q0);
275
276 if((a_p < beta))
277 {
278 /* p0', p1', p2' */
279 pu1_p3_temp[pos_p0] = (p2 + X2(p1) + X2(p0) + X2(q0) + q1
280 + 4) >> 3;
281 pu1_p3_temp[pos_p1] = (p2 + p1 + p0 + q0 + 2) >> 2;
282 pu1_p3_temp[pos_p2] =
283 (X2(p3) + X3(p2) + p1 + p0 + q0
284 + 4) >> 3;
285 }
286 else
287 {
288 /* p0'*/
289 pu1_p3_temp[pos_p0] = (X2(p1) + p0 + q1 + 2) >> 2;
290 }
291
292 if(a_q < beta)
293 {
294 /* q0', q1', q2' */
295 pu1_src_temp[pos_q0] = (p1 + X2(p0) + X2(q0) + X2(q1)
296 + q2 + 4) >> 3;
297 pu1_src_temp[pos_q1] = (p0 + q0 + q1 + q2 + 2) >> 2;
298 pu1_src_temp[pos_q2] = (X2(q3) + X3(q2) + q1 + q0 + p0
299 + 4) >> 3;
300 }
301 else
302 {
303 /* q0'*/
304 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2;
305 }
306 }
307 else
308 {
309 /* p0', q0'*/
310 pu1_p3_temp[pos_p0] = (X2(p1) + p0 + q1 + 2) >> 2;
311 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2;
312 }
313 }
314 }
315}
316
317/*****************************************************************************/
318/* */
319/* Function Name : ih264_deblk_chroma_vert_bs4_bp() */
320/* */
321/* Description : This function performs filtering of a chroma block */
322/* vertical edge when the boundary strength is set to 4. */
323/* */
324/* Inputs : pu1_src - pointer to the src sample q0 of U */
325/* src_strd - source stride */
326/* alpha - alpha value for the boundary */
327/* beta - beta value for the boundary */
328/* */
329/* Globals : None */
330/* */
331/* Processing : This operation is described in Sec. 8.7.2.4 under the */
332/* title "Filtering process for edges for bS equal to 4" in */
333/* ITU T Rec H.264. */
334/* */
335/* Outputs : None */
336/* */
337/* Returns : None */
338/* */
339/* Issues : None */
340/* */
341/* Revision History: */
342/* */
343/* DD MM YYYY Author(s) Changes (Describe the changes made) */
344/* 28 11 2013 Ittiam Draft */
345/* */
346/*****************************************************************************/
347void ih264_deblk_chroma_vert_bs4_bp(UWORD8 *pu1_src,
348 WORD32 src_strd,
349 WORD32 alpha,
350 WORD32 beta)
351{
352 UWORD8 *pu1_src_u = pu1_src; /* pointer to the src sample q0 of U */
353 UWORD8 *pu1_src_v = pu1_src + 1; /* pointer to the src sample q0 of V */
354 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
355 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */
356 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
357 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
358 WORD8 i = 0, edge;
359
360 pos_q0 = 0;
361 pos_q1 = 2;
362 pos_p0 = -2;
363 pos_p1 = -4;
364
365 for(edge = 0; edge < 4;
366 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd)
367 {
368 pu1_src_temp_u = pu1_src_u;
369 pu1_src_temp_v = pu1_src_v;
370 for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v +=
371 src_strd)
372 {
373 q0_u = pu1_src_temp_u[pos_q0];
374 q1_u = pu1_src_temp_u[pos_q1];
375 p0_u = pu1_src_temp_u[pos_p0];
376 p1_u = pu1_src_temp_u[pos_p1];
377 q0_v = pu1_src_temp_v[pos_q0];
378 q1_v = pu1_src_temp_v[pos_q1];
379 p0_v = pu1_src_temp_v[pos_p0];
380 p1_v = pu1_src_temp_v[pos_p1];
381
382 /* Filter Decision */
383 if((ABS(p0_u - q0_u) < alpha) &&
384 (ABS(q1_u - q0_u) < beta) &&
385 (ABS(p1_u - p0_u) < beta))
386 {
387 /* p0' */
388 pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2);
389 /* q0' */
390 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2;
391 }
392
393 /* Filter Decision */
394 if((ABS(p0_v - q0_v) < alpha) &&
395 (ABS(q1_v - q0_v) < beta) &&
396 (ABS(p1_v - p0_v) < beta))
397 {
398 /* p0' */
399 pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2);
400 /* q0' */
401 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2;
402 }
403 }
404 }
405}
406
407/*****************************************************************************/
408/* */
409/* Function Name : ih264_deblk_chroma_horz_bs4_bp() */
410/* */
411/* Description : This function performs filtering of a chroma block */
412/* horizontal edge when the boundary strength is set to 4. */
413/* */
414/* Inputs : pu1_src - pointer to the src sample q0 of U */
415/* src_strd - source stride */
416/* alpha - alpha value for the boundary */
417/* beta - beta value for the boundary */
418/* */
419/* Globals : None */
420/* */
421/* Processing : This operation is described in Sec. 8.7.2.4 under the */
422/* title "Filtering process for edges for bS equal to 4" in */
423/* ITU T Rec H.264. */
424/* */
425/* Outputs : None */
426/* */
427/* Returns : None */
428/* */
429/* Issues : None */
430/* */
431/* Revision History: */
432/* */
433/* DD MM YYYY Author(s) Changes (Describe the changes made) */
434/* 28 11 2013 Ittiam Draft */
435/* */
436/*****************************************************************************/
437void ih264_deblk_chroma_horz_bs4_bp(UWORD8 *pu1_src,
438 WORD32 src_strd,
439 WORD32 alpha,
440 WORD32 beta)
441{
442 UWORD8 *pu1_src_u = pu1_src; /* pointer to the src sample q0 of U */
443 UWORD8 *pu1_src_v = pu1_src + 1; /* pointer to the src sample q0 of V */
444 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
445 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
446 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
447 UWORD8 *pu1_p1_u; /* pointer to the src sample p1 of U */
448 UWORD8 *pu1_p1_v; /* pointer to the src sample p1 of U */
449 UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v;
450 WORD8 i = 0, edge;
451
452 pu1_p1_u = pu1_src_u - (src_strd << 1);
453 pu1_p1_v = pu1_src_v - (src_strd << 1);
454 pos_q0 = 0;
455 pos_q1 = src_strd;
456 pos_p0 = src_strd;
457 pos_p1 = 0;
458
459 for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4,
460 pu1_src_v += 4, pu1_p1_v += 4)
461 {
462 pu1_src_temp_u = pu1_src_u;
463 pu1_p1_temp_u = pu1_p1_u;
464 pu1_src_temp_v = pu1_src_v;
465 pu1_p1_temp_v = pu1_p1_v;
466 for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2,
467 pu1_src_temp_v += 2, pu1_p1_temp_v += 2)
468 {
469 q0_u = pu1_src_temp_u[pos_q0];
470 q1_u = pu1_src_temp_u[pos_q1];
471 p0_u = pu1_p1_temp_u[pos_p0];
472 p1_u = pu1_p1_temp_u[pos_p1];
473
474 q0_v = pu1_src_temp_v[pos_q0];
475 q1_v = pu1_src_temp_v[pos_q1];
476 p0_v = pu1_p1_temp_v[pos_p0];
477 p1_v = pu1_p1_temp_v[pos_p1];
478
479 /* Filter Decision */
480 if((ABS(p0_u - q0_u) < alpha) &&
481 (ABS(q1_u - q0_u) < beta) &&
482 (ABS(p1_u - p0_u) < beta))
483 {
484 /* p0' */
485 pu1_p1_temp_u[pos_p0] = (X2(p1_u) + p0_u + q1_u + 2) >> 2;
486 /* q0' */
487 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2;
488 }
489
490 /* Filter Decision */
491 if((ABS(p0_v - q0_v) < alpha) &&
492 (ABS(q1_v - q0_v) < beta) &&
493 (ABS(p1_v - p0_v) < beta))
494 {
495 /* p0' */
496 pu1_p1_temp_v[pos_p0] = (X2(p1_v) + p0_v + q1_v + 2) >> 2;
497 /* q0' */
498 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2;
499 }
500 }
501 }
502}
503
504/*****************************************************************************/
505/* */
506/* Function Name : ih264_deblk_luma_vert_bslt4() */
507/* */
508/* Description : This function performs filtering of a luma block */
509/* vertical edge when the boundary strength is less than 4. */
510/* */
511/* Inputs : pu1_src - pointer to the src sample q0 */
512/* src_strd - source stride */
513/* alpha - alpha value for the boundary */
514/* beta - beta value for the boundary */
515/* u4_bs - packed Boundary strength array */
516/* pu1_cliptab - tc0_table */
517/* */
518/* Globals : None */
519/* */
520/* Processing : This operation is described in Sec. 8.7.2.3 under the */
521/* title "Filtering process for edges for bS less than 4" */
522/* in ITU T Rec H.264. */
523/* */
524/* Outputs : None */
525/* */
526/* Returns : None */
527/* */
528/* Issues : None */
529/* */
530/* Revision History: */
531/* */
532/* DD MM YYYY Author(s) Changes (Describe the changes made) */
533/* 28 11 2013 Ittiam Draft */
534/* */
535/*****************************************************************************/
536void ih264_deblk_luma_vert_bslt4(UWORD8 *pu1_src,
537 WORD32 src_strd,
538 WORD32 alpha,
539 WORD32 beta,
540 UWORD32 u4_bs,
541 const UWORD8 *pu1_cliptab)
542{
543 WORD8 i = 0, edge;
544 UWORD8 p2, p1, p0, q0, q1, q2;
545 WORD32 pos_p2, pos_p1, pos_p0, pos_q0, pos_q1, pos_q2;
546 UWORD8 a_p, a_q; /* threshold variables */
547 WORD32 blk_strd = src_strd << 2; /* block_increment = src_strd * 4 */
548 UWORD8 *pu1_src_temp;
549 WORD8 delta;
550 WORD8 tc;
551 WORD16 val;
552 UWORD8 tc0, u1_bs;
553
554 pos_q0 = 0;
555 pos_q1 = 1;
556 pos_q2 = 2;
557 pos_p0 = -1;
558 pos_p1 = -2;
559 pos_p2 = -3;
560
561 for(edge = 0; edge < 4; edge++, pu1_src += blk_strd)
562 {
563 pu1_src_temp = pu1_src;
564 /* Filter Decision */
565 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff);
566 if(!u1_bs)
567 continue;
568 /* tc0 */
569 tc0 = pu1_cliptab[u1_bs];
570 for(i = 0; i < 4; ++i, pu1_src_temp += src_strd)
571 {
572 q0 = pu1_src_temp[pos_q0];
573 q1 = pu1_src_temp[pos_q1];
574 p0 = pu1_src_temp[pos_p0];
575 p1 = pu1_src_temp[pos_p1];
576
577 /* Filter Decision */
578 if((ABS(p0 - q0) >= alpha) ||
579 (ABS(q1 - q0) >= beta) ||
580 (ABS(p1 - p0) >= beta))
581 continue;
582
583 q2 = pu1_src_temp[pos_q2];
584 p2 = pu1_src_temp[pos_p2];
585
586 a_p = ABS(p2 - p0);
587 a_q = ABS(q2 - q0);
588
589 /* tc */
590 tc = tc0 + (a_p < beta) + (a_q < beta);
591
592 val = ((((q0 - p0) << 2) + (p1 - q1) + 4) >> 3);
593 delta = CLIP3(-tc, tc, val);
594
595 /* p0' */
596 val = p0 + delta;
597 pu1_src_temp[pos_p0] = CLIP_U8(val);
598 /* q0' */
599 val = q0 - delta;
600 pu1_src_temp[pos_q0] = CLIP_U8(val);
601
602 /* Luma only */
603 if(a_p < beta)
604 {
605 /* p1' */
606 val = ((p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1);
607 pu1_src_temp[pos_p1] += CLIP3(-tc0, tc0, val);
608 }
609
610 if(a_q < beta)
611 {
612 /* q1' */
613 val = ((q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1);
614 pu1_src_temp[pos_q1] += CLIP3(-tc0, tc0, val);
615 }
616 }
617 }
618}
619
620/*****************************************************************************/
621/* */
622/* Function Name : ih264_deblk_chroma_vert_bslt4_bp() */
623/* */
624/* Description : This function performs filtering of a chroma block */
625/* vertical edge when the boundary strength is less than 4. */
626/* */
627/* Inputs : pu1_src - pointer to the src sample q0 of U */
628/* src_strd - source stride */
629/* alpha - alpha value for the boundary */
630/* beta - beta value for the boundary */
631/* u4_bs - packed Boundary strength array */
632/* pu1_cliptab - tc0_table */
633/* */
634/* Globals : None */
635/* */
636/* Processing : This operation is described in Sec. 8.7.2.3 under the */
637/* title "Filtering process for edges for bS less than 4" */
638/* in ITU T Rec H.264. */
639/* */
640/* Outputs : None */
641/* */
642/* Returns : None */
643/* */
644/* Issues : None */
645/* */
646/* Revision History: */
647/* */
648/* DD MM YYYY Author(s) Changes (Describe the changes made) */
649/* 28 11 2013 Ittiam Draft */
650/* */
651/*****************************************************************************/
652void ih264_deblk_chroma_vert_bslt4_bp(UWORD8 *pu1_src,
653 WORD32 src_strd,
654 WORD32 alpha,
655 WORD32 beta,
656 UWORD32 u4_bs,
657 const UWORD8 *pu1_cliptab)
658{
659 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/
660 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/
661 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
662 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * (4 >> 1)*/
663 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
664 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
665 WORD8 i = 0, edge;
666 WORD8 delta;
667 WORD8 tc;
668 WORD16 val;
669 UWORD8 tc0, u1_bs;
670
671 pos_q0 = 0;
672 pos_q1 = 2;
673 pos_p0 = -2;
674 pos_p1 = -4;
675
676 for(edge = 0; edge < 4;
677 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd)
678 {
679 pu1_src_temp_u = pu1_src_u;
680 pu1_src_temp_v = pu1_src_v;
681 /* Filter Decision */
682 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff);
683 if(!u1_bs)
684 continue;
685 /* tc0 */
686 tc0 = pu1_cliptab[u1_bs];
687 tc = tc0 + 1;
688 for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v +=
689 src_strd)
690 {
691 q0_u = pu1_src_temp_u[pos_q0];
692 q1_u = pu1_src_temp_u[pos_q1];
693 p0_u = pu1_src_temp_u[pos_p0];
694 p1_u = pu1_src_temp_u[pos_p1];
695
696 q0_v = pu1_src_temp_v[pos_q0];
697 q1_v = pu1_src_temp_v[pos_q1];
698 p0_v = pu1_src_temp_v[pos_p0];
699 p1_v = pu1_src_temp_v[pos_p1];
700
701 /* Filter Decision */
702 if((ABS(p0_u - q0_u) < alpha) &&
703 (ABS(q1_u - q0_u) < beta) &&
704 (ABS(p1_u - p0_u) < beta))
705 {
706 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3);
707 delta = CLIP3(-tc, tc, val);
708 /* p0' */
709 val = p0_u + delta;
710 pu1_src_temp_u[pos_p0] = CLIP_U8(val);
711 /* q0' */
712 val = q0_u - delta;
713 pu1_src_temp_u[pos_q0] = CLIP_U8(val);
714 }
715
716 /* Filter Decision */
717 if((ABS(p0_v - q0_v) < alpha) &&
718 (ABS(q1_v - q0_v) < beta) &&
719 (ABS(p1_v - p0_v) < beta))
720 {
721 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3);
722 delta = CLIP3(-tc, tc, val);
723 /* p0' */
724 val = p0_v + delta;
725 pu1_src_temp_v[pos_p0] = CLIP_U8(val);
726 /* q0' */
727 val = q0_v - delta;
728 pu1_src_temp_v[pos_q0] = CLIP_U8(val);
729 }
730 }
731 }
732}
733
734/*****************************************************************************/
735/* */
736/* Function Name : ih264_deblk_luma_horz_bslt4() */
737/* */
738/* Description : This function performs filtering of a luma block */
739/* horizontal edge when boundary strength is less than 4. */
740/* */
741/* Inputs : pu1_src - pointer to the src sample q0 */
742/* src_strd - source stride */
743/* alpha - alpha value for the boundary */
744/* beta - beta value for the boundary */
745/* u4_bs - packed Boundary strength array */
746/* pu1_cliptab - tc0_table */
747/* */
748/* Globals : None */
749/* */
750/* Processing : This operation is described in Sec. 8.7.2.3 under the */
751/* title "Filtering process for edges for bS less than 4" */
752/* in ITU T Rec H.264. */
753/* */
754/* Outputs : None */
755/* */
756/* Returns : None */
757/* */
758/* Issues : None */
759/* */
760/* Revision History: */
761/* */
762/* DD MM YYYY Author(s) Changes (Describe the changes made) */
763/* 28 11 2013 Ittiam Draft */
764/* */
765/*****************************************************************************/
766void ih264_deblk_luma_horz_bslt4(UWORD8 *pu1_src,
767 WORD32 src_strd,
768 WORD32 alpha,
769 WORD32 beta,
770 UWORD32 u4_bs,
771 const UWORD8 *pu1_cliptab)
772{
773 UWORD8 p2, p1, p0, q0, q1, q2;
774 WORD32 pos_p2, pos_p1, pos_p0, pos_q0, pos_q1, pos_q2;
775 UWORD8 a_p, a_q; /* Threshold variables */
776 UWORD8 *pu1_p2; /* Pointer to the src sample p2 */
777 UWORD8 *pu1_p2_temp;
778 UWORD8 *pu1_src_temp;
779 WORD8 i = 0, edge;
780 WORD8 delta;
781 WORD8 tc;
782 WORD16 val;
783 UWORD8 tc0, u1_bs;
784
785 pu1_p2 = pu1_src - (src_strd << 2);
786 pos_q0 = 0;
787 pos_q1 = src_strd;
788 pos_q2 = X2(src_strd);
789 pos_p0 = X3(src_strd);
790 pos_p1 = X2(src_strd);
791 pos_p2 = src_strd;
792
793 for(edge = 0; edge < 4; edge++, pu1_src += 4, pu1_p2 += 4)
794 {
795 pu1_src_temp = pu1_src;
796 pu1_p2_temp = pu1_p2;
797
798 /* Filter Decision */
799 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff);
800 if(!u1_bs)
801 continue;
802 /* tc0 */
803 tc0 = pu1_cliptab[u1_bs];
804
805 for(i = 0; i < 4; ++i, pu1_src_temp++, pu1_p2_temp++)
806 {
807 q0 = pu1_src_temp[pos_q0];
808 q1 = pu1_src_temp[pos_q1];
809 p0 = pu1_p2_temp[pos_p0];
810 p1 = pu1_p2_temp[pos_p1];
811
812 /* Filter Decision */
813 if((ABS(p0 - q0) >= alpha) ||
814 (ABS(q1 - q0) >= beta) ||
815 (ABS(p1 - p0) >= beta))
816 continue;
817
818 q2 = pu1_src_temp[pos_q2];
819 p2 = pu1_p2_temp[pos_p2];
820
821 a_p = ABS(p2 - p0);
822 a_q = ABS(q2 - q0);
823
824 /* tc */
825 tc = tc0 + (a_p < beta) + (a_q < beta);
826 val = ((((q0 - p0) << 2) + (p1 - q1) + 4) >> 3);
827 delta = CLIP3(-tc, tc, val);
828 /* p0' */
829 val = p0 + delta;
830 pu1_p2_temp[pos_p0] = CLIP_U8(val);
831 /* q0' */
832 val = q0 - delta;
833 pu1_src_temp[pos_q0] = CLIP_U8(val);
834
835 /* Luma */
836 if(a_p < beta)
837 {
838 /* p1' */
839 val = ((p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1);
840 pu1_p2_temp[pos_p1] += CLIP3(-tc0, tc0, val);
841 }
842
843 if(a_q < beta)
844 {
845 /* q1' */
846 val = ((q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1);
847 pu1_src_temp[pos_q1] += CLIP3(-tc0, tc0, val);
848 }
849 }
850 }
851}
852
853/*****************************************************************************/
854/* */
855/* Function Name : ih264_deblk_chroma_horz_bslt4_bp() */
856/* */
857/* Description : This function performs filtering of a chroma block */
858/* horizontal edge when boundary strength is less than 4. */
859/* */
860/* Inputs : pu1_src - pointer to the src sample q0 of U */
861/* src_strd - source stride */
862/* alpha - alpha value for the boundary */
863/* beta - beta value for the boundary */
864/* u4_bs - packed Boundary strength array */
865/* pu1_cliptab - tc0_table */
866/* */
867/* Globals : None */
868/* */
869/* Processing : This operation is described in Sec. 8.7.2.3 under the */
870/* title "Filtering process for edges for bS less than 4" */
871/* in ITU T Rec H.264. */
872/* */
873/* Outputs : None */
874/* */
875/* Returns : None */
876/* */
877/* Issues : None */
878/* */
879/* Revision History: */
880/* */
881/* DD MM YYYY Author(s) Changes (Describe the changes made) */
882/* 28 11 2013 Ittiam Draft */
883/* */
884/*****************************************************************************/
885void ih264_deblk_chroma_horz_bslt4_bp(UWORD8 *pu1_src,
886 WORD32 src_strd,
887 WORD32 alpha,
888 WORD32 beta,
889 UWORD32 u4_bs,
890 const UWORD8 *pu1_cliptab)
891{
892 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/
893 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/
894 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
895 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
896 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
897 UWORD8 *pu1_p1_u; /* Pointer to the src sample p1 of plane U*/
898 UWORD8 *pu1_p1_v; /* Pointer to the src sample p1 of plane V*/
899 UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v;
900 WORD8 i = 0, edge;
901 WORD8 delta;
902 WORD8 tc;
903 WORD16 val;
904 UWORD8 u1_bs;
905 UWORD8 tc0;
906
907 pu1_p1_u = pu1_src_u - (src_strd << 1);
908 pu1_p1_v = pu1_src_v - (src_strd << 1);
909 pos_q0 = 0;
910 pos_q1 = src_strd;
911 pos_p0 = src_strd;
912 pos_p1 = 0;
913
914 for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4,
915 pu1_src_v += 4, pu1_p1_v += 4)
916 {
917 pu1_src_temp_u = pu1_src_u;
918 pu1_p1_temp_u = pu1_p1_u;
919 pu1_src_temp_v = pu1_src_v;
920 pu1_p1_temp_v = pu1_p1_v;
921
922 /* Filter Decision */
923 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff);
924 if(!u1_bs)
925 continue;
926 /* tc0 */
927 tc0 = pu1_cliptab[u1_bs];
928
929 for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2,
930 pu1_src_temp_v += 2, pu1_p1_temp_v += 2)
931 {
932 q0_u = pu1_src_temp_u[pos_q0];
933 q1_u = pu1_src_temp_u[pos_q1];
934 p0_u = pu1_p1_temp_u[pos_p0];
935 p1_u = pu1_p1_temp_u[pos_p1];
936
937 q0_v = pu1_src_temp_v[pos_q0];
938 q1_v = pu1_src_temp_v[pos_q1];
939 p0_v = pu1_p1_temp_v[pos_p0];
940 p1_v = pu1_p1_temp_v[pos_p1];
941
942 /* tc */
943 tc = tc0 + 1;
944 /* Filter Decision */
945 if(ABS(p0_u - q0_u) < alpha && ABS(q1_u - q0_u) < beta
946 && ABS(p1_u - p0_u) < beta)
947 {
948 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3);
949 delta = CLIP3(-tc, tc, val);
950 /* p0' */
951 val = p0_u + delta;
952 pu1_p1_temp_u[pos_p0] = CLIP_U8(val);
953 /* q0' */
954 val = q0_u - delta;
955 pu1_src_temp_u[pos_q0] = CLIP_U8(val);
956 }
957 /* Filter Decision */
958 if(ABS(p0_v - q0_v) < alpha && ABS(q1_v - q0_v) < beta
959 && ABS(p1_v - p0_v) < beta)
960 {
961 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3);
962 delta = CLIP3(-tc, tc, val);
963 /* p0' */
964 val = p0_v + delta;
965 pu1_p1_temp_v[pos_p0] = CLIP_U8(val);
966 /* q0' */
967 val = q0_v - delta;
968 pu1_src_temp_v[pos_q0] = CLIP_U8(val);
969 }
970 }
971 }
972}
973
974/*****************************************************************************/
975/* Function Definitions for vertical edge deblocking for double-call */
976/*****************************************************************************/
977
978/*****************************************************************************/
979/* */
980/* Function Name : ih264_deblk_luma_vert_bs4_mbaff() */
981/* */
982/* Description : This function performs filtering of a luma block */
983/* vertical edge when boundary strength is set to 4. */
984/* */
985/* Inputs : pu1_src - pointer to the src sample q0 */
986/* src_strd - source stride */
987/* alpha - alpha value for the boundary */
988/* beta - beta value for the boundary */
989/* */
990/* Globals : None */
991/* */
992/* Processing : When the function is called twice, this operation is as */
993/* described in Sec. 8.7.2.3 under the title "Filtering */
994/* process for edges for bS equal to 4" in ITU T Rec H.264. */
995/* */
996/* Outputs : None */
997/* */
998/* Returns : None */
999/* */
1000/* Issues : None */
1001/* */
1002/* Revision History: */
1003/* */
1004/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1005/* 29 12 2014 Kaushik Draft */
1006/* Senthoor */
1007/* */
1008/*****************************************************************************/
1009void ih264_deblk_luma_vert_bs4_mbaff(UWORD8 *pu1_src,
1010 WORD32 src_strd,
1011 WORD32 alpha,
1012 WORD32 beta)
1013{
1014 UWORD8 p3, p2, p1, p0, q0, q1, q2, q3;
1015 WORD32 pos_p3, pos_p2, pos_p1, pos_p0;
1016 WORD32 pos_q0, pos_q1, pos_q2, pos_q3;
1017 UWORD8 a_p, a_q; /* threshold variables */
1018 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */
1019 UWORD8 *pu1_src_temp;
1020 WORD8 i = 0, edge;
1021
1022 pos_q0 = 0;
1023 pos_q1 = 1;
1024 pos_q2 = 2;
1025 pos_q3 = 3;
1026 pos_p0 = -1;
1027 pos_p1 = -2;
1028 pos_p2 = -3;
1029 pos_p3 = -4;
1030
1031 for(edge = 0; edge < 4; edge++, pu1_src += blk_strd)
1032 {
1033 pu1_src_temp = pu1_src;
1034 for(i = 0; i < 2; ++i, pu1_src_temp += src_strd)
1035 {
1036 q0 = pu1_src_temp[pos_q0];
1037 q1 = pu1_src_temp[pos_q1];
1038 p0 = pu1_src_temp[pos_p0];
1039 p1 = pu1_src_temp[pos_p1];
1040
1041 /* Filter Decision */
1042 if((ABS(p0 - q0) >= alpha) ||
1043 (ABS(q1 - q0) >= beta) ||
1044 (ABS(p1 - p0) >= beta))
1045 continue;
1046
1047 p2 = pu1_src_temp[pos_p2];
1048 p3 = pu1_src_temp[pos_p3];
1049 q2 = pu1_src_temp[pos_q2];
1050 q3 = pu1_src_temp[pos_q3];
1051
1052 if(ABS(p0 - q0) < ((alpha >> 2) + 2))
1053 {
1054 /* Threshold Variables */
1055 a_p = (UWORD8)ABS(p2 - p0);
1056 a_q = (UWORD8)ABS(q2 - q0);
1057
1058 if(a_p < beta)
1059 {
1060 /* p0', p1', p2' */
1061 pu1_src_temp[pos_p0] = ((p2 + X2(p1) + X2(p0) + X2(q0) + q1
1062 + 4) >> 3);
1063 pu1_src_temp[pos_p1] = ((p2 + p1 + p0 + q0 + 2) >> 2);
1064 pu1_src_temp[pos_p2] =
1065 ((X2(p3) + X3(p2) + p1 + p0 + q0
1066 + 4) >> 3);
1067 }
1068 else
1069 {
1070 /* p0'*/
1071 pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2);
1072 }
1073
1074 if(a_q < beta)
1075 {
1076 /* q0', q1', q2' */
1077 pu1_src_temp[pos_q0] = (p1 + X2(p0) + X2(q0) + X2(q1) + q2
1078 + 4) >> 3;
1079 pu1_src_temp[pos_q1] = (p0 + q0 + q1 + q2 + 2) >> 2;
1080 pu1_src_temp[pos_q2] = (X2(q3) + X3(q2) + q1 + q0 + p0 + 4)
1081 >> 3;
1082 }
1083 else
1084 {
1085 /* q0'*/
1086 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2;
1087 }
1088 }
1089 else
1090 {
1091 /* p0', q0'*/
1092 pu1_src_temp[pos_p0] = ((X2(p1) + p0 + q1 + 2) >> 2);
1093 pu1_src_temp[pos_q0] = (X2(q1) + q0 + p1 + 2) >> 2;
1094 }
1095 }
1096 }
1097}
1098
1099/*****************************************************************************/
1100/* */
1101/* Function Name : ih264_deblk_chroma_vert_bs4_mbaff_bp() */
1102/* */
1103/* Description : This function performs filtering of a chroma block */
1104/* vertical edge when boundary strength is set to 4. */
1105/* */
1106/* Inputs : pu1_src - pointer to the src sample q0 of U */
1107/* src_strd - source stride */
1108/* alpha - alpha value for the boundary */
1109/* beta - beta value for the boundary */
1110/* */
1111/* Globals : None */
1112/* */
1113/* Processing : When the function is called twice, this operation is as */
1114/* described in Sec. 8.7.2.3 under the title "Filtering */
1115/* process for edges for bS equal to 4" in ITU T Rec H.264. */
1116/* */
1117/* Outputs : None */
1118/* */
1119/* Returns : None */
1120/* */
1121/* Issues : None */
1122/* */
1123/* Revision History: */
1124/* */
1125/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1126/* 29 12 2014 Kaushik Draft */
1127/* Senthoor */
1128/* */
1129/*****************************************************************************/
1130void ih264_deblk_chroma_vert_bs4_mbaff_bp(UWORD8 *pu1_src,
1131 WORD32 src_strd,
1132 WORD32 alpha,
1133 WORD32 beta)
1134{
1135 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */
1136 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */
1137 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
1138 WORD32 blk_strd = src_strd;
1139 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
1140 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
1141 WORD8 edge;
1142
1143 pos_q0 = 0;
1144 pos_q1 = 2;
1145 pos_p0 = -2;
1146 pos_p1 = -4;
1147
1148 for(edge = 0; edge < 4;
1149 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd)
1150 {
1151 pu1_src_temp_u = pu1_src_u;
1152 pu1_src_temp_v = pu1_src_v;
1153
1154 q0_u = pu1_src_temp_u[pos_q0];
1155 q1_u = pu1_src_temp_u[pos_q1];
1156 p0_u = pu1_src_temp_u[pos_p0];
1157 p1_u = pu1_src_temp_u[pos_p1];
1158 q0_v = pu1_src_temp_v[pos_q0];
1159 q1_v = pu1_src_temp_v[pos_q1];
1160 p0_v = pu1_src_temp_v[pos_p0];
1161 p1_v = pu1_src_temp_v[pos_p1];
1162
1163 /* Filter Decision */
1164 if((ABS(p0_u - q0_u) < alpha) &&
1165 (ABS(q1_u - q0_u) < beta) &&
1166 (ABS(p1_u - p0_u) < beta))
1167 {
1168 /* p0' */
1169 pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2);
1170 /* q0' */
1171 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2;
1172 }
1173
1174 /* Filter Decision */
1175 if(ABS(p0_v - q0_v) < alpha && ABS(q1_v - q0_v) < beta
1176 && ABS(p1_v - p0_v) < beta)
1177 {
1178 /* p0' */
1179 pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2);
1180 /* q0' */
1181 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2;
1182 }
1183 }
1184}
1185
1186/*****************************************************************************/
1187/* */
1188/* Function Name : ih264_deblk_luma_vert_bslt4_mbaff() */
1189/* */
1190/* Description : This function performs filtering of a luma block */
1191/* vertical edge when boundary strength is less than 4. */
1192/* */
1193/* Inputs : pu1_src - pointer to the src sample q0 */
1194/* src_strd - source stride */
1195/* alpha - alpha value for the boundary */
1196/* beta - beta value for the boundary */
1197/* u4_bs - packed Boundary strength array */
1198/* pu1_cliptab - tc0_table */
1199/* */
1200/* Globals : None */
1201/* */
1202/* Processing : When the function is called twice, this operation is as */
1203/* described in Sec. 8.7.2.3 under the title "Filtering */
1204/* process for edges for bS less than 4" in ITU T Rec H.264.*/
1205/* */
1206/* Outputs : None */
1207/* */
1208/* Returns : None */
1209/* */
1210/* Issues : None */
1211/* */
1212/* Revision History: */
1213/* */
1214/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1215/* 29 12 2014 Kaushik Draft */
1216/* Senthoor */
1217/* */
1218/*****************************************************************************/
1219void ih264_deblk_luma_vert_bslt4_mbaff(UWORD8 *pu1_src,
1220 WORD32 src_strd,
1221 WORD32 alpha,
1222 WORD32 beta,
1223 UWORD32 u4_bs,
1224 const UWORD8 *pu1_cliptab)
1225{
1226 WORD8 i = 0, edge;
1227 UWORD8 p2, p1, p0, q0, q1, q2;
1228 WORD32 pos_p2, pos_p1, pos_p0, pos_q0, pos_q1, pos_q2;
1229 UWORD8 a_p, a_q; /* Threshold variables */
1230 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */
1231 UWORD8 *pu1_src_temp;
1232 WORD8 delta;
1233 WORD8 tc;
1234 WORD16 val;
1235 UWORD8 tc0, u1_bs;
1236
1237 pos_q0 = 0;
1238 pos_q1 = 1;
1239 pos_q2 = 2;
1240 pos_p0 = -1;
1241 pos_p1 = -2;
1242 pos_p2 = -3;
1243
1244 for(edge = 0; edge < 4; edge++, pu1_src += blk_strd)
1245 {
1246 pu1_src_temp = pu1_src;
1247 /* Filter Decision */
1248 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff);
1249 if(!u1_bs)
1250 continue;
1251 /* tc0 */
1252 tc0 = pu1_cliptab[u1_bs];
1253 for(i = 0; i < 2; ++i, pu1_src_temp += src_strd)
1254 {
1255 q0 = pu1_src_temp[pos_q0];
1256 q1 = pu1_src_temp[pos_q1];
1257 p0 = pu1_src_temp[pos_p0];
1258 p1 = pu1_src_temp[pos_p1];
1259
1260 /* Filter Decision */
1261 if((ABS(p0 - q0) >= alpha) ||
1262 (ABS(q1 - q0) >= beta) ||
1263 (ABS(p1 - p0) >= beta))
1264 continue;
1265
1266 q2 = pu1_src_temp[pos_q2];
1267 p2 = pu1_src_temp[pos_p2];
1268
1269 a_p = ABS(p2 - p0);
1270 a_q = ABS(q2 - q0);
1271
1272 /* tc */
1273 tc = tc0 + (a_p < beta) + (a_q < beta);
1274
1275 val = ((((q0 - p0) << 2) + (p1 - q1) + 4) >> 3);
1276 delta = CLIP3(-tc, tc, val);
1277 /* p0' */
1278 val = p0 + delta;
1279 pu1_src_temp[pos_p0] = CLIP_U8(val);
1280 /* q0' */
1281 val = q0 - delta;
1282 pu1_src_temp[pos_q0] = CLIP_U8(val);
1283
1284 /* Luma only */
1285 if(a_p < beta)
1286 {
1287 /* p1' */
1288 val = ((p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1);
1289 pu1_src_temp[pos_p1] += CLIP3(-tc0, tc0, val);
1290 }
1291
1292 if(a_q < beta)
1293 {
1294 /* q1' */
1295 val = ((q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1);
1296 pu1_src_temp[pos_q1] += CLIP3(-tc0, tc0, val);
1297 }
1298 }
1299 }
1300}
1301
1302/*****************************************************************************/
1303/* */
1304/* Function Name : ih264_deblk_chroma_vert_bslt4_mbaff_bp() */
1305/* */
1306/* Description : This function performs filtering of a chroma block */
1307/* vertical edge when boundary strength is less than 4. */
1308/* */
1309/* Inputs : pu1_src - pointer to the src sample q0 of U */
1310/* src_strd - source stride */
1311/* alpha - alpha value for the boundary */
1312/* beta - beta value for the boundary */
1313/* u4_bs - packed Boundary strength array */
1314/* pu1_cliptab - tc0_table */
1315/* */
1316/* Globals : None */
1317/* */
1318/* Processing : When the function is called twice, this operation is as */
1319/* described in Sec. 8.7.2.3 under the title "Filtering */
1320/* process for edges for bS less than 4" in ITU T Rec H.264.*/
1321/* */
1322/* Outputs : None */
1323/* */
1324/* Returns : None */
1325/* */
1326/* Issues : None */
1327/* */
1328/* Revision History: */
1329/* */
1330/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1331/* 29 12 2014 Kaushik Draft */
1332/* Senthoor */
1333/* */
1334/*****************************************************************************/
1335void ih264_deblk_chroma_vert_bslt4_mbaff_bp(UWORD8 *pu1_src,
1336 WORD32 src_strd,
1337 WORD32 alpha,
1338 WORD32 beta,
1339 UWORD32 u4_bs,
1340 const UWORD8 *pu1_cliptab)
1341{
1342 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/
1343 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/
1344 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
1345 WORD32 blk_strd = src_strd;
1346 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
1347 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
1348 WORD8 edge;
1349 WORD8 delta;
1350 WORD8 tc;
1351 WORD16 val;
1352 UWORD8 tc0, u1_bs;
1353
1354 pos_q0 = 0;
1355 pos_q1 = 2;
1356 pos_p0 = -2;
1357 pos_p1 = -4;
1358
1359 for(edge = 0; edge < 4;
1360 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd)
1361 {
1362 pu1_src_temp_u = pu1_src_u;
1363 pu1_src_temp_v = pu1_src_v;
1364 /* Filter Decision */
1365 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff);
1366 if(!u1_bs)
1367 continue;
1368 /* tc0 */
1369 tc0 = pu1_cliptab[u1_bs];
1370 tc = tc0 + 1;
1371
1372 q0_u = pu1_src_temp_u[pos_q0];
1373 q1_u = pu1_src_temp_u[pos_q1];
1374 p0_u = pu1_src_temp_u[pos_p0];
1375 p1_u = pu1_src_temp_u[pos_p1];
1376
1377 q0_v = pu1_src_temp_v[pos_q0];
1378 q1_v = pu1_src_temp_v[pos_q1];
1379 p0_v = pu1_src_temp_v[pos_p0];
1380 p1_v = pu1_src_temp_v[pos_p1];
1381
1382 /* Filter Decision */
1383 if((ABS(p0_u - q0_u) < alpha) &&
1384 (ABS(q1_u - q0_u) < beta) &&
1385 (ABS(p1_u - p0_u) < beta))
1386 {
1387 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3);
1388 delta = CLIP3(-tc, tc, val);
1389 /* p0' */
1390 val = p0_u + delta;
1391 pu1_src_temp_u[pos_p0] = CLIP_U8(val);
1392 /* q0' */
1393 val = q0_u - delta;
1394 pu1_src_temp_u[pos_q0] = CLIP_U8(val);
1395 }
1396
1397 /* Filter Decision */
1398 if((ABS(p0_v - q0_v) < alpha) &&
1399 (ABS(q1_v - q0_v) < beta) &&
1400 (ABS(p1_v - p0_v) < beta))
1401 {
1402 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3);
1403 delta = CLIP3(-tc, tc, val);
1404 /* p0' */
1405 val = p0_v + delta;
1406 pu1_src_temp_v[pos_p0] = CLIP_U8(val);
1407 /* q0' */
1408 val = q0_v - delta;
1409 pu1_src_temp_v[pos_q0] = CLIP_U8(val);
1410 }
1411 }
1412}
1413
1414/*****************************************************************************/
1415/* Function Definitions for chroma deblocking in high profile */
1416/*****************************************************************************/
1417
1418/*****************************************************************************/
1419/* */
1420/* Function Name : ih264_deblk_chroma_vert_bs4() */
1421/* */
1422/* Description : This function performs filtering of a chroma block */
1423/* vertical edge when the boundary strength is set to 4 in */
1424/* high profile. */
1425/* */
1426/* Inputs : pu1_src - pointer to the src sample q0 of U */
1427/* src_strd - source stride */
1428/* alpha_cb - alpha value for the boundary in U */
1429/* beta_cb - beta value for the boundary in U */
1430/* alpha_cr - alpha value for the boundary in V */
1431/* beta_cr - beta value for the boundary in V */
1432/* */
1433/* Globals : None */
1434/* */
1435/* Processing : This operation is described in Sec. 8.7.2.4 under the */
1436/* title "Filtering process for edges for bS equal to 4" in */
1437/* ITU T Rec H.264 with alpha and beta values different in */
1438/* U and V. */
1439/* */
1440/* Outputs : None */
1441/* */
1442/* Returns : None */
1443/* */
1444/* Issues : None */
1445/* */
1446/* Revision History: */
1447/* */
1448/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1449/* 29 12 2014 Kaushik Draft */
1450/* Senthoor */
1451/* */
1452/*****************************************************************************/
1453void ih264_deblk_chroma_vert_bs4(UWORD8 *pu1_src,
1454 WORD32 src_strd,
1455 WORD32 alpha_cb,
1456 WORD32 beta_cb,
1457 WORD32 alpha_cr,
1458 WORD32 beta_cr)
1459{
1460 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */
1461 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */
1462 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
1463 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2*/
1464 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
1465 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
1466 WORD8 i = 0, edge;
1467
1468 pos_q0 = 0;
1469 pos_q1 = 2;
1470 pos_p0 = -2;
1471 pos_p1 = -4;
1472
1473 for(edge = 0; edge < 4;
1474 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd)
1475 {
1476 pu1_src_temp_u = pu1_src_u;
1477 pu1_src_temp_v = pu1_src_v;
1478 for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v +=
1479 src_strd)
1480 {
1481 q0_u = pu1_src_temp_u[pos_q0];
1482 q1_u = pu1_src_temp_u[pos_q1];
1483 p0_u = pu1_src_temp_u[pos_p0];
1484 p1_u = pu1_src_temp_u[pos_p1];
1485 q0_v = pu1_src_temp_v[pos_q0];
1486 q1_v = pu1_src_temp_v[pos_q1];
1487 p0_v = pu1_src_temp_v[pos_p0];
1488 p1_v = pu1_src_temp_v[pos_p1];
1489
1490 /* Filter Decision */
1491 if((ABS(p0_u - q0_u) < alpha_cb) &&
1492 (ABS(q1_u - q0_u) < beta_cb) &&
1493 (ABS(p1_u - p0_u) < beta_cb))
1494 {
1495 /* p0' */
1496 pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2);
1497 /* q0' */
1498 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2;
1499 }
1500
1501 /* Filter Decision */
1502 if((ABS(p0_v - q0_v) < alpha_cr) &&
1503 (ABS(q1_v - q0_v) < beta_cr) &&
1504 (ABS(p1_v - p0_v) < beta_cr))
1505 {
1506 /* p0' */
1507 pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2);
1508 /* q0' */
1509 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2;
1510 }
1511 }
1512 }
1513}
1514
1515/*****************************************************************************/
1516/* */
1517/* Function Name : ih264_deblk_chroma_horz_bs4() */
1518/* */
1519/* Description : This function performs filtering of a chroma block */
1520/* horizontal edge when the boundary strength is set to 4 */
1521/* in high profile. */
1522/* */
1523/* Inputs : pu1_src - pointer to the src sample q0 of U */
1524/* src_strd - source stride */
1525/* alpha_cb - alpha value for the boundary in U */
1526/* beta_cb - beta value for the boundary in U */
1527/* alpha_cr - alpha value for the boundary in V */
1528/* beta_cr - beta value for the boundary in V */
1529/* */
1530/* Globals : None */
1531/* */
1532/* Processing : This operation is described in Sec. 8.7.2.4 under the */
1533/* title "Filtering process for edges for bS equal to 4" in */
1534/* ITU T Rec H.264 with alpha and beta values different in */
1535/* U and V. */
1536/* */
1537/* Outputs : None */
1538/* */
1539/* Returns : None */
1540/* */
1541/* Issues : None */
1542/* */
1543/* Revision History: */
1544/* */
1545/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1546/* 29 12 2014 Kaushik Draft */
1547/* Senthoor */
1548/* */
1549/*****************************************************************************/
1550void ih264_deblk_chroma_horz_bs4(UWORD8 *pu1_src,
1551 WORD32 src_strd,
1552 WORD32 alpha_cb,
1553 WORD32 beta_cb,
1554 WORD32 alpha_cr,
1555 WORD32 beta_cr)
1556{
1557 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */
1558 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */
1559 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
1560 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
1561 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
1562 UWORD8 *pu1_p1_u; /* Pointer to the src sample p1 of U */
1563 UWORD8 *pu1_p1_v; /* Pointer to the src sample p1 of U */
1564 UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v;
1565 WORD8 i = 0, edge;
1566
1567 pu1_p1_u = pu1_src_u - (src_strd << 1);
1568 pu1_p1_v = pu1_src_v - (src_strd << 1);
1569 pos_q0 = 0;
1570 pos_q1 = src_strd;
1571 pos_p0 = src_strd;
1572 pos_p1 = 0;
1573
1574 for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4, pu1_src_v +=
1575 4, pu1_p1_v += 4)
1576 {
1577 pu1_src_temp_u = pu1_src_u;
1578 pu1_p1_temp_u = pu1_p1_u;
1579 pu1_src_temp_v = pu1_src_v;
1580 pu1_p1_temp_v = pu1_p1_v;
1581 for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2,
1582 pu1_src_temp_v += 2, pu1_p1_temp_v += 2)
1583 {
1584 q0_u = pu1_src_temp_u[pos_q0];
1585 q1_u = pu1_src_temp_u[pos_q1];
1586 p0_u = pu1_p1_temp_u[pos_p0];
1587 p1_u = pu1_p1_temp_u[pos_p1];
1588
1589 q0_v = pu1_src_temp_v[pos_q0];
1590 q1_v = pu1_src_temp_v[pos_q1];
1591 p0_v = pu1_p1_temp_v[pos_p0];
1592 p1_v = pu1_p1_temp_v[pos_p1];
1593
1594 /* Filter Decision */
1595 if(ABS(p0_u - q0_u) < alpha_cb && ABS(q1_u - q0_u) < beta_cb
1596 && ABS(p1_u - p0_u) < beta_cb)
1597 {
1598 /* p0' */
1599 pu1_p1_temp_u[pos_p0] = (X2(p1_u) + p0_u + q1_u + 2) >> 2;
1600 /* q0' */
1601 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2;
1602 }
1603
1604 /* Filter Decision */
1605 if(ABS(p0_v - q0_v) < alpha_cr && ABS(q1_v - q0_v) < beta_cr
1606 && ABS(p1_v - p0_v) < beta_cr)
1607 {
1608 /* p0' */
1609 pu1_p1_temp_v[pos_p0] = (X2(p1_v) + p0_v + q1_v + 2) >> 2;
1610 /* q0' */
1611 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2;
1612 }
1613 }
1614 }
1615}
1616
1617/*****************************************************************************/
1618/* */
1619/* Function Name : ih264_deblk_chroma_vert_bslt4() */
1620/* */
1621/* Description : This function performs filtering of a chroma block */
1622/* vertical edge when the boundary strength is less than 4 */
1623/* in high profile. */
1624/* */
1625/* Inputs : pu1_src - pointer to the src sample q0 of U */
1626/* src_strd - source stride */
1627/* alpha_cb - alpha value for the boundary in U */
1628/* beta_cb - beta value for the boundary in U */
1629/* alpha_cr - alpha value for the boundary in V */
1630/* beta_cr - beta value for the boundary in V */
1631/* u4_bs - packed Boundary strength array */
1632/* pu1_cliptab_cb - tc0_table for U */
1633/* pu1_cliptab_cr - tc0_table for V */
1634/* */
1635/* Globals : None */
1636/* */
1637/* Processing : This operation is described in Sec. 8.7.2.3 under the */
1638/* title "Filtering process for edges for bS less than 4" */
1639/* in ITU T Rec H.264 with alpha and beta values different */
1640/* in U and V. */
1641/* */
1642/* Outputs : None */
1643/* */
1644/* Returns : None */
1645/* */
1646/* Issues : None */
1647/* */
1648/* Revision History: */
1649/* */
1650/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1651/* 29 12 2014 Kaushik Draft */
1652/* Senthoor */
1653/* */
1654/*****************************************************************************/
1655void ih264_deblk_chroma_vert_bslt4(UWORD8 *pu1_src,
1656 WORD32 src_strd,
1657 WORD32 alpha_cb,
1658 WORD32 beta_cb,
1659 WORD32 alpha_cr,
1660 WORD32 beta_cr,
1661 UWORD32 u4_bs,
1662 const UWORD8 *pu1_cliptab_cb,
1663 const UWORD8 *pu1_cliptab_cr)
1664{
1665 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/
1666 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/
1667 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
1668 WORD32 blk_strd = src_strd << 1; /* block_increment = src_strd * 2 */
1669 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
1670 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
1671 WORD8 i = 0, edge;
1672 WORD8 delta;
1673 WORD8 tcb, tcr;
1674 WORD16 val;
1675 UWORD8 tcb0, tcr0, u1_bs;
1676
1677 pos_q0 = 0;
1678 pos_q1 = 2;
1679 pos_p0 = -2;
1680 pos_p1 = -4;
1681
1682 for(edge = 0; edge < 4;
1683 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd)
1684 {
1685 pu1_src_temp_u = pu1_src_u;
1686 pu1_src_temp_v = pu1_src_v;
1687 /* Filter Decision */
1688 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff);
1689 if(!u1_bs)
1690 continue;
1691 /* tc0 */
1692 tcb0 = pu1_cliptab_cb[u1_bs];
1693 tcr0 = pu1_cliptab_cr[u1_bs];
1694 tcb = tcb0 + 1;
1695 tcr = tcr0 + 1;
1696 for(i = 0; i < 2; ++i, pu1_src_temp_u += src_strd, pu1_src_temp_v +=
1697 src_strd)
1698 {
1699 q0_u = pu1_src_temp_u[pos_q0];
1700 q1_u = pu1_src_temp_u[pos_q1];
1701 p0_u = pu1_src_temp_u[pos_p0];
1702 p1_u = pu1_src_temp_u[pos_p1];
1703
1704 q0_v = pu1_src_temp_v[pos_q0];
1705 q1_v = pu1_src_temp_v[pos_q1];
1706 p0_v = pu1_src_temp_v[pos_p0];
1707 p1_v = pu1_src_temp_v[pos_p1];
1708
1709 /* Filter Decision */
1710 if(ABS(p0_u - q0_u) < alpha_cb && ABS(q1_u - q0_u) < beta_cb
1711 && ABS(p1_u - p0_u) < beta_cb)
1712 {
1713 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3);
1714 delta = CLIP3(-tcb, tcb, val);
1715 /* p0' */
1716 val = p0_u + delta;
1717 pu1_src_temp_u[pos_p0] = CLIP_U8(val);
1718 /* q0' */
1719 val = q0_u - delta;
1720 pu1_src_temp_u[pos_q0] = CLIP_U8(val);
1721 }
1722
1723 /* Filter Decision */
1724 if(ABS(p0_v - q0_v) < alpha_cr && ABS(q1_v - q0_v) < beta_cr
1725 && ABS(p1_v - p0_v) < beta_cr)
1726 {
1727 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3);
1728 delta = CLIP3(-tcr, tcr, val);
1729 /* p0' */
1730 val = p0_v + delta;
1731 pu1_src_temp_v[pos_p0] = CLIP_U8(val);
1732 /* q0' */
1733 val = q0_v - delta;
1734 pu1_src_temp_v[pos_q0] = CLIP_U8(val);
1735 }
1736 }
1737 }
1738}
1739
1740/*****************************************************************************/
1741/* */
1742/* Function Name : ih264_deblk_chroma_horz_bslt4() */
1743/* */
1744/* Description : This function performs filtering of a chroma block */
1745/* horizontal edge when the boundary strength is less than */
1746/* 4 in high profile. */
1747/* */
1748/* Inputs : pu1_src - pointer to the src sample q0 of U */
1749/* src_strd - source stride */
1750/* alpha_cb - alpha value for the boundary in U */
1751/* beta_cb - beta value for the boundary in U */
1752/* alpha_cr - alpha value for the boundary in V */
1753/* beta_cr - beta value for the boundary in V */
1754/* u4_bs - packed Boundary strength array */
1755/* pu1_cliptab_cb - tc0_table for U */
1756/* pu1_cliptab_cr - tc0_table for V */
1757/* */
1758/* Globals : None */
1759/* */
1760/* Processing : This operation is described in Sec. 8.7.2.3 under the */
1761/* title "Filtering process for edges for bS less than 4" */
1762/* in ITU T Rec H.264 with alpha and beta values different */
1763/* in U and V. */
1764/* */
1765/* Outputs : None */
1766/* */
1767/* Returns : None */
1768/* */
1769/* Issues : None */
1770/* */
1771/* Revision History: */
1772/* */
1773/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1774/* 29 12 2014 Kaushik Draft */
1775/* Senthoor */
1776/* */
1777/*****************************************************************************/
1778void ih264_deblk_chroma_horz_bslt4(UWORD8 *pu1_src,
1779 WORD32 src_strd,
1780 WORD32 alpha_cb,
1781 WORD32 beta_cb,
1782 WORD32 alpha_cr,
1783 WORD32 beta_cr,
1784 UWORD32 u4_bs,
1785 const UWORD8 *pu1_cliptab_cb,
1786 const UWORD8 *pu1_cliptab_cr)
1787{
1788 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/
1789 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/
1790 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
1791 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
1792 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
1793 UWORD8 *pu1_p1_u; /* Pointer to the src sample p1 of plane U*/
1794 UWORD8 *pu1_p1_v; /* Pointer to the src sample p1 of plane V*/
1795 UWORD8 *pu1_p1_temp_u, *pu1_p1_temp_v;
1796 WORD8 i = 0, edge;
1797 WORD8 delta;
1798 WORD8 tcb, tcr;
1799 WORD16 val;
1800 UWORD8 u1_bs;
1801 UWORD8 tcb0, tcr0;
1802
1803 pu1_p1_u = pu1_src_u - (src_strd << 1);
1804 pu1_p1_v = pu1_src_v - (src_strd << 1);
1805 pos_q0 = 0;
1806 pos_q1 = src_strd;
1807 pos_p0 = src_strd;
1808 pos_p1 = 0;
1809
1810 for(edge = 0; edge < 4; edge++, pu1_src_u += 4, pu1_p1_u += 4,
1811 pu1_src_v += 4, pu1_p1_v += 4)
1812 {
1813 pu1_src_temp_u = pu1_src_u;
1814 pu1_p1_temp_u = pu1_p1_u;
1815 pu1_src_temp_v = pu1_src_v;
1816 pu1_p1_temp_v = pu1_p1_v;
1817
1818 /* Filter Decision */
1819 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff);
1820 if(!u1_bs)
1821 continue;
1822 /* tc0 */
1823 tcb0 = pu1_cliptab_cb[u1_bs];
1824 tcr0 = pu1_cliptab_cr[u1_bs];
1825
1826 for(i = 0; i < 2; ++i, pu1_src_temp_u += 2, pu1_p1_temp_u += 2,
1827 pu1_src_temp_v += 2, pu1_p1_temp_v += 2)
1828 {
1829 q0_u = pu1_src_temp_u[pos_q0];
1830 q1_u = pu1_src_temp_u[pos_q1];
1831 p0_u = pu1_p1_temp_u[pos_p0];
1832 p1_u = pu1_p1_temp_u[pos_p1];
1833
1834 q0_v = pu1_src_temp_v[pos_q0];
1835 q1_v = pu1_src_temp_v[pos_q1];
1836 p0_v = pu1_p1_temp_v[pos_p0];
1837 p1_v = pu1_p1_temp_v[pos_p1];
1838
1839 /* tc */
1840 tcb = tcb0 + 1;
1841 tcr = tcr0 + 1;
1842 /* Filter Decision */
1843 if(ABS(p0_u - q0_u) < alpha_cb && ABS(q1_u - q0_u) < beta_cb
1844 && ABS(p1_u - p0_u) < beta_cb)
1845 {
1846 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3);
1847 delta = CLIP3(-tcb, tcb, val);
1848 /* p0' */
1849 val = p0_u + delta;
1850 pu1_p1_temp_u[pos_p0] = CLIP_U8(val);
1851 /* q0' */
1852 val = q0_u - delta;
1853 pu1_src_temp_u[pos_q0] = CLIP_U8(val);
1854 }
1855 /* Filter Decision */
1856 if(ABS(p0_v - q0_v) < alpha_cr && ABS(q1_v - q0_v) < beta_cr
1857 && ABS(p1_v - p0_v) < beta_cr)
1858 {
1859 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3);
1860 delta = CLIP3(-tcr, tcr, val);
1861 /* p0' */
1862 val = p0_v + delta;
1863 pu1_p1_temp_v[pos_p0] = CLIP_U8(val);
1864 /* q0' */
1865 val = q0_v - delta;
1866 pu1_src_temp_v[pos_q0] = CLIP_U8(val);
1867 }
1868 }
1869 }
1870}
1871
1872/*****************************************************************************/
1873/* */
1874/* Function Name : ih264_deblk_chroma_vert_bs4_mbaff() */
1875/* */
1876/* Description : This function performs filtering of a chroma block */
1877/* vertical edge when boundary strength is set to 4 in high */
1878/* profile. */
1879/* */
1880/* Inputs : pu1_src - pointer to the src sample q0 of U */
1881/* src_strd - source stride */
1882/* alpha_cb - alpha value for the boundary in U */
1883/* beta_cb - beta value for the boundary in U */
1884/* alpha_cr - alpha value for the boundary in V */
1885/* beta_cr - beta value for the boundary in V */
1886/* u4_bs - packed Boundary strength array */
1887/* pu1_cliptab_cb - tc0_table for U */
1888/* pu1_cliptab_cr - tc0_table for V */
1889/* */
1890/* Globals : None */
1891/* */
1892/* Processing : When the function is called twice, this operation is as */
1893/* described in Sec. 8.7.2.4 under the title "Filtering */
1894/* process for edges for bS equal to 4" in ITU T Rec H.264 */
1895/* with alpha and beta values different in U and V. */
1896/* */
1897/* Outputs : None */
1898/* */
1899/* Returns : None */
1900/* */
1901/* Issues : None */
1902/* */
1903/* Revision History: */
1904/* */
1905/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1906/* 29 12 2014 Kaushik Draft */
1907/* Senthoor */
1908/* */
1909/*****************************************************************************/
1910void ih264_deblk_chroma_vert_bs4_mbaff(UWORD8 *pu1_src,
1911 WORD32 src_strd,
1912 WORD32 alpha_cb,
1913 WORD32 beta_cb,
1914 WORD32 alpha_cr,
1915 WORD32 beta_cr)
1916{
1917 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of U */
1918 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of V */
1919 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
1920 WORD32 blk_strd = src_strd;
1921 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
1922 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
1923 WORD8 edge;
1924
1925 pos_q0 = 0;
1926 pos_q1 = 2;
1927 pos_p0 = -2;
1928 pos_p1 = -4;
1929
1930 for(edge = 0; edge < 4;
1931 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd)
1932 {
1933 pu1_src_temp_u = pu1_src_u;
1934 pu1_src_temp_v = pu1_src_v;
1935 q0_u = pu1_src_temp_u[pos_q0];
1936 q1_u = pu1_src_temp_u[pos_q1];
1937 p0_u = pu1_src_temp_u[pos_p0];
1938 p1_u = pu1_src_temp_u[pos_p1];
1939 q0_v = pu1_src_temp_v[pos_q0];
1940 q1_v = pu1_src_temp_v[pos_q1];
1941 p0_v = pu1_src_temp_v[pos_p0];
1942 p1_v = pu1_src_temp_v[pos_p1];
1943
1944 /* Filter Decision */
1945 if((ABS(p0_u - q0_u) < alpha_cb) &&
1946 (ABS(q1_u - q0_u) < beta_cb) &&
1947 (ABS(p1_u - p0_u) < beta_cb))
1948 {
1949 /* p0' */
1950 pu1_src_temp_u[pos_p0] = ((X2(p1_u) + p0_u + q1_u + 2) >> 2);
1951 /* q0' */
1952 pu1_src_temp_u[pos_q0] = (X2(q1_u) + q0_u + p1_u + 2) >> 2;
1953 }
1954
1955 /* Filter Decision */
1956 if((ABS(p0_v - q0_v) < alpha_cr) &&
1957 (ABS(q1_v - q0_v) < beta_cr) &&
1958 (ABS(p1_v - p0_v) < beta_cr))
1959 {
1960 /* p0' */
1961 pu1_src_temp_v[pos_p0] = ((X2(p1_v) + p0_v + q1_v + 2) >> 2);
1962 /* q0' */
1963 pu1_src_temp_v[pos_q0] = (X2(q1_v) + q0_v + p1_v + 2) >> 2;
1964 }
1965 }
1966}
1967
1968/*****************************************************************************/
1969/* */
1970/* Function Name : ih264_deblk_chroma_vert_bslt4_mbaff() */
1971/* */
1972/* Description : This function performs filtering of a chroma block */
1973/* vertical edge when boundary strength is less than 4 in */
1974/* high profile. */
1975/* */
1976/* Inputs : pu1_src - pointer to the src sample q0 of U */
1977/* src_strd - source stride */
1978/* alpha_cb - alpha value for the boundary in U */
1979/* beta_cb - beta value for the boundary in U */
1980/* alpha_cr - alpha value for the boundary in V */
1981/* beta_cr - beta value for the boundary in V */
1982/* u4_bs - packed Boundary strength array */
1983/* pu1_cliptab_cb - tc0_table for U */
1984/* pu1_cliptab_cr - tc0_table for V */
1985/* */
1986/* Globals : None */
1987/* */
1988/* Processing : When the function is called twice, this operation is as */
1989/* described in Sec. 8.7.2.4 under the title "Filtering */
1990/* process for edges for bS less than 4" in ITU T Rec H.264 */
1991/* with alpha and beta values different in U and V. */
1992/* */
1993/* Outputs : None */
1994/* */
1995/* Returns : None */
1996/* */
1997/* Issues : None */
1998/* */
1999/* Revision History: */
2000/* */
2001/* DD MM YYYY Author(s) Changes (Describe the changes made) */
2002/* 29 12 2014 Kaushik Draft */
2003/* Senthoor */
2004/* */
2005/*****************************************************************************/
2006void ih264_deblk_chroma_vert_bslt4_mbaff(UWORD8 *pu1_src,
2007 WORD32 src_strd,
2008 WORD32 alpha_cb,
2009 WORD32 beta_cb,
2010 WORD32 alpha_cr,
2011 WORD32 beta_cr,
2012 UWORD32 u4_bs,
2013 const UWORD8 *pu1_cliptab_cb,
2014 const UWORD8 *pu1_cliptab_cr)
2015{
2016 UWORD8 *pu1_src_u = pu1_src; /* Pointer to the src sample q0 of plane U*/
2017 UWORD8 *pu1_src_v = pu1_src + 1; /* Pointer to the src sample q0 of plane V*/
2018 UWORD8 p1_u, p0_u, q0_u, q1_u, p1_v, p0_v, q0_v, q1_v;
2019 WORD32 blk_strd = src_strd;
2020 WORD32 pos_p1, pos_p0, pos_q0, pos_q1;
2021 UWORD8 *pu1_src_temp_u, *pu1_src_temp_v;
2022 WORD8 edge;
2023 WORD8 delta;
2024 WORD8 tcb, tcr;
2025 WORD16 val;
2026 UWORD8 tcb0, tcr0, u1_bs;
2027
2028 pos_q0 = 0;
2029 pos_q1 = 2;
2030 pos_p0 = -2;
2031 pos_p1 = -4;
2032
2033 for(edge = 0; edge < 4;
2034 edge++, pu1_src_u += blk_strd, pu1_src_v += blk_strd)
2035 {
2036 pu1_src_temp_u = pu1_src_u;
2037 pu1_src_temp_v = pu1_src_v;
2038 /* Filter Decision */
2039 u1_bs = (UWORD8)((u4_bs >> ((3 - edge) << 3)) & 0x0ff);
2040 if(!u1_bs)
2041 continue;
2042 /* tc0 */
2043 tcb0 = pu1_cliptab_cb[u1_bs];
2044 tcr0 = pu1_cliptab_cr[u1_bs];
2045 tcb = tcb0 + 1;
2046 tcr = tcr0 + 1;
2047 q0_u = pu1_src_temp_u[pos_q0];
2048 q1_u = pu1_src_temp_u[pos_q1];
2049 p0_u = pu1_src_temp_u[pos_p0];
2050 p1_u = pu1_src_temp_u[pos_p1];
2051
2052 q0_v = pu1_src_temp_v[pos_q0];
2053 q1_v = pu1_src_temp_v[pos_q1];
2054 p0_v = pu1_src_temp_v[pos_p0];
2055 p1_v = pu1_src_temp_v[pos_p1];
2056
2057 /* Filter Decision */
2058 if((ABS(p0_u - q0_u) < alpha_cb) &&
2059 (ABS(q1_u - q0_u) < beta_cb) &&
2060 (ABS(p1_u - p0_u) < beta_cb))
2061 {
2062 val = ((((q0_u - p0_u) << 2) + (p1_u - q1_u) + 4) >> 3);
2063 delta = CLIP3(-tcb, tcb, val);
2064 /* p0' */
2065 val = p0_u + delta;
2066 pu1_src_temp_u[pos_p0] = CLIP_U8(val);
2067 /* q0' */
2068 val = q0_u - delta;
2069 pu1_src_temp_u[pos_q0] = CLIP_U8(val);
2070 }
2071
2072 /* Filter Decision */
2073 if((ABS(p0_v - q0_v) < alpha_cr) &&
2074 (ABS(q1_v - q0_v) < beta_cr) &&
2075 (ABS(p1_v - p0_v) < beta_cr))
2076 {
2077 val = ((((q0_v - p0_v) << 2) + (p1_v - q1_v) + 4) >> 3);
2078 delta = CLIP3(-tcr, tcr, val);
2079 /* p0' */
2080 val = p0_v + delta;
2081 pu1_src_temp_v[pos_p0] = CLIP_U8(val);
2082 /* q0' */
2083 val = q0_v - delta;
2084 pu1_src_temp_v[pos_q0] = CLIP_U8(val);
2085 }
2086 }
2087}