Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libavc / refs/heads/int/p/fp2 / . / decoder / ih264d_compute_bs.c
blob: 4a6750a41c90670d20b4ee8c5aa5f5f54c7ebbe3 [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#include "ih264_typedefs.h"
22#include "ih264_macros.h"
23#include "ih264_platform_macros.h"
24#include "ih264d_structs.h"
25#include "ih264d_defs.h"
26#include "ih264d_deblocking.h"
27#include "string.h"
28#include "ih264d_debug.h"
29#include "ih264d_tables.h"
30
31UWORD16 ih264d_update_csbp_8x8(UWORD16 u2_luma_csbp)
32{
33 UWORD16 u2_mod_csbp;
34
35 u2_mod_csbp = u2_luma_csbp;
36
37 if(u2_mod_csbp & 0x0033)
38 {
39 u2_mod_csbp |= 0x0033;
40 }
41
42 if(u2_mod_csbp & 0x00CC)
43 {
44 u2_mod_csbp |= 0x00CC;
45 }
46
47 if(u2_mod_csbp & 0x3300)
48 {
49 u2_mod_csbp |= 0x3300;
50 }
51
52 if(u2_mod_csbp & 0xCC00)
53 {
54 u2_mod_csbp |= 0xCC00;
55 }
56
57 return u2_mod_csbp;
58}
59
60/*****************************************************************************/
61/* */
62/* Function Name : ih264d_fill_bs2_horz_vert */
63/* */
64/* Description : This function fills boundray strength (=2) for all horz */
65/* and vert edges of current mb based on coded sub block */
66/* pattern of current, top and left mb */
67/* Inputs : */
68/* pu4_bs : Base pointer of BS table which gets updated */
69/* u4_left_mb_csbp : left mb's coded sub block pattern */
70/* u4_top_mb_csbp : top mb's coded sub block pattern */
71/* u4_cur_mb_csbp : current mb's coded sub block pattern */
72/* */
73/* Globals : <Does it use any global variables?> */
74/* Processing : */
75/* */
76/* csbp for each 4x4 block in a mb is bit packet in reverse */
77/* raster scan order for each mb as shown below: */
78/* 15|14|13|12|11|10|9|8|7|6|5|4|3|2|1|0. */
79/* */
80/* BS=2 for a 4x4 edge if any of adjacent blocks forming edge */
81/* are coded. Keeping this in mind, bs=2 for all horz and vert */
82/* edges can be derived using a lookup table for each edge */
83/* after "ORing" the csbp values as follows: */
84/* (C means current Mb, T means top mb and L means left mb) */
85/* */
86/* All Horz edges: */
87/* 15C|14C|13C|12C|11C|10C|9C|8C|7C|6C|5C|4C|3C |2C |1C |0C */
88/* (or with) 11C|10C| 9C| 8C| 7C|6C |5C|4C|3C|2C|1C|0C|15T|14T|13T|12T */
89/* -----BS[3]-----|----BS[2]----|---BS[1]---|----BS[0]-----| */
90/* */
91/* All Vert edges: */
92/* 15C|14C|13C|12C|11C|10C|9C| 8C|7C|6C|5C|4C|3C |2C |1C |0C */
93/* (or with) 14C|13C|12C|15L|10C| 9C|8C|11L|6C|5C|4C|7L|2C |1C |0C |3L */
94/* Do 4x4 transpose of resulting pattern to get vertBS[4]-BS[7] */
95/* */
96/* Outputs : <What does the function produce?> */
97/* Returns : <What does the function return?> */
98/* */
99/* Issues : <List any issues or problems with this function> */
100/* */
101/* Revision History: */
102/* */
103/* DD MM YYYY Author(s) Changes (Describe the changes made) */
104/* 16 10 2008 Jay Draft */
105/* */
106/*****************************************************************************/
107#define CSBP_LEFT_BLOCK_MASK 0x1111
108#define CSBP_RIGHT_BLOCK_MASK 0x8888
109
110void ih264d_fill_bs2_horz_vert(UWORD32 *pu4_bs, /* Base pointer of BS table */
111 WORD32 u4_left_mb_csbp, /* csbp of left mb */
112 WORD32 u4_top_mb_csbp, /* csbp of top mb */
113 WORD32 u4_cur_mb_csbp, /* csbp of current mb */
114 const UWORD32 *pu4_packed_bs2, const UWORD16 *pu2_4x4_v2h_reorder)
115{
116 /*************************************************************************/
117 /*u4_nbr_horz_csbp=11C|10C|9C|8C|7C|6C|5C|4C|3C|2C|1C|0C|15T|14T|13T|12T */
118 /*************************************************************************/
119 UWORD32 u4_nbr_horz_csbp = (u4_cur_mb_csbp << 4) | (u4_top_mb_csbp >> 12);
120 UWORD32 u4_horz_bs2_dec = u4_cur_mb_csbp | u4_nbr_horz_csbp;
121
122 /*************************************************************************/
123 /*u4_left_mb_masked_csbp = 15L|0|0|0|11L|0|0|0|7L|0|0|0|3L|0|0|0 */
124 /*************************************************************************/
125 UWORD32 u4_left_mb_masked_csbp = u4_left_mb_csbp & CSBP_RIGHT_BLOCK_MASK;
126
127 /*************************************************************************/
128 /*u4_cur_mb_masked_csbp =14C|13C|12C|x|10C|9C|8C|x|6C|5C|4C|x|2C|1C|0C|x */
129 /*************************************************************************/
130 UWORD32 u4_cur_mb_masked_csbp = (u4_cur_mb_csbp << 1)
131 & (~CSBP_LEFT_BLOCK_MASK);
132
133 /*************************************************************************/
134 /*u4_nbr_vert_csbp=14C|13C|12C|15L|10C|9C|8C|11L|6C|5C|4C|7L|2C|1C|0C|3L */
135 /*************************************************************************/
136 UWORD32 u4_nbr_vert_csbp = (u4_cur_mb_masked_csbp)
137 | (u4_left_mb_masked_csbp >> 3);
138
139 UWORD32 u4_vert_bs2_dec = u4_cur_mb_csbp | u4_nbr_vert_csbp;
140
141 UWORD32 u4_reordered_vert_bs2_dec, u4_temp;
142
143 PROFILE_DISABLE_BOUNDARY_STRENGTH()
144
145 /*************************************************************************/
146 /* Fill horz edges (0,1,2,3) boundary strengths 2 using look up table */
147 /*************************************************************************/
148 pu4_bs[0] = pu4_packed_bs2[u4_horz_bs2_dec & 0xF];
149 pu4_bs[1] = pu4_packed_bs2[(u4_horz_bs2_dec >> 4) & 0xF];
150 pu4_bs[2] = pu4_packed_bs2[(u4_horz_bs2_dec >> 8) & 0xF];
151 pu4_bs[3] = pu4_packed_bs2[(u4_horz_bs2_dec >> 12) & 0xF];
152
153 /*************************************************************************/
154 /* Do 4x4 tranpose of u4_vert_bs2_dec by using look up table for reorder */
155 /*************************************************************************/
156 u4_reordered_vert_bs2_dec = pu2_4x4_v2h_reorder[u4_vert_bs2_dec & 0xF];
157 u4_temp = pu2_4x4_v2h_reorder[(u4_vert_bs2_dec >> 4) & 0xF];
158 u4_reordered_vert_bs2_dec |= (u4_temp << 1);
159 u4_temp = pu2_4x4_v2h_reorder[(u4_vert_bs2_dec >> 8) & 0xF];
160 u4_reordered_vert_bs2_dec |= (u4_temp << 2);
161 u4_temp = pu2_4x4_v2h_reorder[(u4_vert_bs2_dec >> 12) & 0xF];
162 u4_reordered_vert_bs2_dec |= (u4_temp << 3);
163
164 /*************************************************************************/
165 /* Fill vert edges (4,5,6,7) boundary strengths 2 using look up table */
166 /*************************************************************************/
167 pu4_bs[4] = pu4_packed_bs2[u4_reordered_vert_bs2_dec & 0xF];
168 pu4_bs[5] = pu4_packed_bs2[(u4_reordered_vert_bs2_dec >> 4) & 0xF];
169 pu4_bs[6] = pu4_packed_bs2[(u4_reordered_vert_bs2_dec >> 8) & 0xF];
170 pu4_bs[7] = pu4_packed_bs2[(u4_reordered_vert_bs2_dec >> 12) & 0xF];
171}
172
173/*****************************************************************************/
174/* */
175/* Function Name : ih264d_fill_bs1_16x16mb_pslice */
176/* */
177/* Description : This function fills boundray strength (=1) for those */
178/* horz and vert mb edges of 16x16mb which are set to 0 by */
179/* ih264d_fill_bs2_horz_vert. This function is used for p slices */
180/* */
181/* Inputs : <What inputs does the function take?> */
182/* Globals : <Does it use any global variables?> */
183/* Processing : If any motion vector component of adjacent 4x4 blocks */
184/* differs by more than 1 integer pel or if reference */
185/* pictures are different, Bs is set to 1. */
186/* */
187/* Outputs : <What does the function produce?> */
188/* Returns : <What does the function return?> */
189/* */
190/* Issues : <List any issues or problems with this function> */
191/* */
192/* Revision History: */
193/* */
194/* DD MM YYYY Author(s) Changes (Describe the changes made) */
195/* 16 10 2008 Jay Draft */
196/* */
197/*****************************************************************************/
198void ih264d_fill_bs1_16x16mb_pslice(mv_pred_t *ps_cur_mv_pred,
199 mv_pred_t *ps_top_mv_pred,
200 void **ppv_map_ref_idx_to_poc,
201 UWORD32 *pu4_bs_table, /* pointer to the BsTable array */
202 mv_pred_t *ps_leftmost_mv_pred,
203 neighbouradd_t *ps_left_addr,
204 void **u4_pic_addrress, /* picture address for BS calc */
205 WORD32 i4_ver_mvlimit)
206{
207 WORD16 i2_q_mv0, i2_q_mv1;
208 WORD16 i2_p_mv0, i2_p_mv1;
209 void *pv_cur_pic_addr0, *pv_cur_pic_addr1;
210 void *pv_nbr_pic_addr0, *pv_nbr_pic_addr1;
211 void **ppv_map_ref_idx_to_poc_l0; //,*ppv_map_ref_idx_to_poc_l1;
212 UWORD32 i;
213 UWORD32 u4_bs_horz = pu4_bs_table[0];
214 UWORD32 u4_bs_vert = pu4_bs_table[4];
215
216 PROFILE_DISABLE_BOUNDARY_STRENGTH()
217
218 ppv_map_ref_idx_to_poc_l0 = ppv_map_ref_idx_to_poc;
219
220 i2_q_mv0 = ps_cur_mv_pred->i2_mv[0];
221 i2_q_mv1 = ps_cur_mv_pred->i2_mv[1];
222 pv_cur_pic_addr0 = ppv_map_ref_idx_to_poc_l0[ps_cur_mv_pred->i1_ref_frame[0]];
223 pv_cur_pic_addr1 = 0;
224
225 /*********************************/
226 /* Computing Bs for the top edge */
227 /*********************************/
228 for(i = 0; i < 4; i++, ps_top_mv_pred++)
229 {
230 UWORD32 u4_idx = 24 - (i << 3);
231
232 /*********************************/
233 /* check if Bs is already set */
234 /*********************************/
235 if(!((u4_bs_horz >> u4_idx) & 0xf))
236 {
237 /************************************************************/
238 /* If Bs is not set, use left edge and current edge mvs and */
239 /* reference pictures addresses to evaluate Bs==1 */
240 /************************************************************/
241 UWORD32 u4_bs_temp1;
242 UWORD32 u4_bs;
243
244 /*********************************************************/
245 /* If any motion vector component differs by more than 1 */
246 /* integer pel or if reference pictures are different Bs */
247 /* is set to 1. Note that this condition shall be met for*/
248 /* both (fwd-fwd,bwd-bwd) and (fwd-bwd,bwd-fwd) direction*/
249 /*********************************************************/
250 i2_p_mv0 = ps_top_mv_pred->i2_mv[0];
251 i2_p_mv1 = ps_top_mv_pred->i2_mv[1];
252 pv_nbr_pic_addr0 = u4_pic_addrress[i & 2];
253 pv_nbr_pic_addr1 = u4_pic_addrress[1 + (i & 2)];
254
255 u4_bs_temp1 = ((ABS((i2_p_mv0 - i2_q_mv0)) >= 4) ||
256 (ABS((i2_p_mv1 - i2_q_mv1)) >= i4_ver_mvlimit));
257
258 u4_bs = ((pv_cur_pic_addr0 != pv_nbr_pic_addr0)
259 || (pv_cur_pic_addr1 != pv_nbr_pic_addr1)
260 || u4_bs_temp1);
261
262 u4_bs_horz |= (u4_bs << u4_idx);
263 }
264 }
265 pu4_bs_table[0] = u4_bs_horz;
266
267 /***********************************/
268 /* Computing Bs for the left edge */
269 /***********************************/
270 for(i = 0; i < 4; i++, ps_leftmost_mv_pred += 4)
271 {
272 UWORD32 u4_idx = 24 - (i << 3);
273
274 /*********************************/
275 /* check if Bs is already set */
276 /*********************************/
277 if(!((u4_bs_vert >> u4_idx) & 0xf))
278 {
279 /****************************************************/
280 /* If Bs is not set, evalaute conditions for Bs=1 */
281 /****************************************************/
282 UWORD32 u4_bs_temp1;
283 UWORD32 u4_bs;
284 /*********************************************************/
285 /* If any motion vector component differs by more than 1 */
286 /* integer pel or if reference pictures are different Bs */
287 /* is set to 1. Note that this condition shall be met for*/
288 /* both (fwd-fwd,bwd-bwd) and (fwd-bwd,bwd-fwd) direction*/
289 /*********************************************************/
290
291 i2_p_mv0 = ps_leftmost_mv_pred->i2_mv[0];
292 i2_p_mv1 = ps_leftmost_mv_pred->i2_mv[1];
293 pv_nbr_pic_addr0 = ps_left_addr->u4_add[i & 2];
294 pv_nbr_pic_addr1 = ps_left_addr->u4_add[1 + (i & 2)];
295
296 u4_bs_temp1 =
297 ((ABS((i2_p_mv0 - i2_q_mv0))
298 >= 4)
299 | (ABS((i2_p_mv1 - i2_q_mv1))
300 >= i4_ver_mvlimit));
301
302 u4_bs = ((pv_cur_pic_addr0 != pv_nbr_pic_addr0)
303 || (pv_cur_pic_addr1 != pv_nbr_pic_addr1)
304 || u4_bs_temp1);
305
306 u4_bs_vert |= (u4_bs << u4_idx);
307 }
308 }
309 pu4_bs_table[4] = u4_bs_vert;
310
311 return;
312}
313
314/*****************************************************************************/
315/* */
316/* Function Name : ih264d_fill_bs1_non16x16mb_pslice */
317/* */
318/* Description : This function fills boundray strength (=1) for those */
319/* horz and vert edges of non16x16mb which are set to 0 by */
320/* ih264d_fill_bs2_horz_vert. This function is used for p slices */
321/* */
322/* Inputs : <What inputs does the function take?> */
323/* Globals : <Does it use any global variables?> */
324/* Processing : If any motion vector component of adjacent 4x4 blocks */
325/* differs by more than 1 integer pel or if reference */
326/* pictures are different, Bs is set to 1. */
327/* */
328/* Outputs : <What does the function produce?> */
329/* Returns : <What does the function return?> */
330/* */
331/* Issues : <List any issues or problems with this function> */
332/* */
333/* Revision History: */
334/* */
335/* DD MM YYYY Author(s) Changes (Describe the changes made) */
336/* 16 10 2008 Jay Draft */
337/* */
338/*****************************************************************************/
339void ih264d_fill_bs1_non16x16mb_pslice(mv_pred_t *ps_cur_mv_pred,
340 mv_pred_t *ps_top_mv_pred,
341 void **ppv_map_ref_idx_to_poc,
342 UWORD32 *pu4_bs_table, /* pointer to the BsTable array */
343 mv_pred_t *ps_leftmost_mv_pred,
344 neighbouradd_t *ps_left_addr,
345 void **u4_pic_addrress,
346 WORD32 i4_ver_mvlimit)
347{
348 UWORD32 edge;
349 void **ppv_map_ref_idx_to_poc_l0; //,*ppv_map_ref_idx_to_poc_l1;
350
351 PROFILE_DISABLE_BOUNDARY_STRENGTH()
352
353 ppv_map_ref_idx_to_poc_l0 = ppv_map_ref_idx_to_poc;
354
355
356 for(edge = 0; edge < 4; edge++, ps_top_mv_pred = ps_cur_mv_pred - 4)
357 {
358 /*********************************************************************/
359 /* Each iteration of this loop fills the four BS values of one HORIZ */
360 /* edge and one BS value for each of the four VERT edges. */
361 /*********************************************************************/
362 WORD32 i;
363 UWORD32 u4_vert_idx = 24 - (edge << 3);
364 UWORD32 u4_bs_horz = pu4_bs_table[edge];
365 mv_pred_t *ps_left_mv_pred = ps_leftmost_mv_pred + (edge << 2);
366
367 for(i = 0; i < 4; i++, ps_top_mv_pred++, ps_cur_mv_pred++)
368 {
369 WORD16 i2_cur_mv0, i2_cur_mv1;
370 WORD8 i1_cur_ref0;
371 void *pv_cur_pic_addr0, *pv_cur_pic_addr1 = 0;
372 void *pv_nbr_pic_addr0, *pv_nbr_pic_addr1;
373
374 /******************************************************/
375 /* Each iteration of this inner loop computes a HORIZ */
376 /* and a VERT BS value for a 4x4 block */
377 /******************************************************/
378 UWORD32 u4_bs_vert = (pu4_bs_table[i + 4] >> u4_vert_idx) & 0xf;
379 UWORD32 u4_horz_idx = 24 - (i << 3);
380
381 /*****************************************************/
382 /* check if vert Bs for this block is already set */
383 /*****************************************************/
384 if(!u4_bs_vert)
385 {
386 WORD16 i2_left_mv0, i2_left_mv1;
387 /************************************************************/
388 /* If Bs is not set, use left edge and current edge mvs and */
389 /* reference pictures addresses to evaluate Bs==1 */
390 /************************************************************/
391 i2_left_mv0 = ps_left_mv_pred->i2_mv[0];
392 i2_left_mv1 = ps_left_mv_pred->i2_mv[1];
393
394 i2_cur_mv0 = ps_cur_mv_pred->i2_mv[0];
395 i2_cur_mv1 = ps_cur_mv_pred->i2_mv[1];
396
397 i1_cur_ref0 = ps_cur_mv_pred->i1_ref_frame[0];
398
399 pv_cur_pic_addr0 = ppv_map_ref_idx_to_poc_l0[i1_cur_ref0];
400 if(i)
401 {
402 WORD8 i1_left_ref0 = ps_left_mv_pred->i1_ref_frame[0];
403 pv_nbr_pic_addr0 = ppv_map_ref_idx_to_poc_l0[i1_left_ref0];
404 pv_nbr_pic_addr1 = 0;
405 }
406 else
407 {
408 pv_nbr_pic_addr0 = ps_left_addr->u4_add[edge & 2];
409 pv_nbr_pic_addr1 = ps_left_addr->u4_add[1 + (edge & 2)];
410 }
411
412 {
413 UWORD32 u4_bs_temp1;
414 /*********************************************************/
415 /* If any motion vector component differs by more than 1 */
416 /* integer pel or if reference pictures are different Bs */
417 /* is set to 1. Note that this condition shall be met for*/
418 /* both (fwd-fwd,bwd-bwd) and (fwd-bwd,bwd-fwd) direction*/
419 /*********************************************************/
420
421 u4_bs_temp1 =
422 ((ABS((i2_left_mv0 - i2_cur_mv0))
423 >= 4)
424 | (ABS((i2_left_mv1
425 - i2_cur_mv1))
426 >= i4_ver_mvlimit));
427
428 u4_bs_vert = ((pv_nbr_pic_addr0 != pv_cur_pic_addr0)
429 || (pv_nbr_pic_addr1 != pv_cur_pic_addr1)
430 || u4_bs_temp1);
431
432 pu4_bs_table[i + 4] |= (u4_bs_vert << u4_vert_idx);
433 }
434 }
435
436 /*****************************************************/
437 /* check if horz Bs for this block is already set */
438 /*****************************************************/
439 if(!((u4_bs_horz >> u4_horz_idx) & 0xf))
440 {
441 WORD16 i2_top_mv0, i2_top_mv1;
442 /************************************************************/
443 /* If Bs is not set, use top edge and current edge mvs and */
444 /* reference pictures addresses to evaluate Bs==1 */
445 /************************************************************/
446 i2_cur_mv0 = ps_cur_mv_pred->i2_mv[0];
447 i2_cur_mv1 = ps_cur_mv_pred->i2_mv[1];
448
449 i1_cur_ref0 = ps_cur_mv_pred->i1_ref_frame[0];
450
451 i2_top_mv0 = ps_top_mv_pred->i2_mv[0];
452 i2_top_mv1 = ps_top_mv_pred->i2_mv[1];
453
454 pv_cur_pic_addr0 = ppv_map_ref_idx_to_poc_l0[i1_cur_ref0];
455 if(edge)
456 {
457 WORD8 i1_top_ref0 = ps_top_mv_pred->i1_ref_frame[0];
458 pv_nbr_pic_addr0 = ppv_map_ref_idx_to_poc_l0[i1_top_ref0];
459 pv_nbr_pic_addr1 = 0;
460 }
461 else
462 {
463 pv_nbr_pic_addr0 = u4_pic_addrress[i & 2];
464 pv_nbr_pic_addr1 = u4_pic_addrress[1 + (i & 2)];
465 }
466
467 {
468 UWORD32 u4_bs_temp1;
469 UWORD32 u4_bs;
470 /*********************************************************/
471 /* If any motion vector component differs by more than 1 */
472 /* integer pel or if reference pictures are different Bs */
473 /* is set to 1. Note that this condition shall be met for*/
474 /* both (fwd-fwd,bwd-bwd) and (fwd-bwd,bwd-fwd) direction*/
475 /*********************************************************/
476
477 u4_bs_temp1 =
478 ((ABS((i2_top_mv0 - i2_cur_mv0))
479 >= 4)
480 | (ABS((i2_top_mv1
481 - i2_cur_mv1))
482 >= i4_ver_mvlimit));
483
484 u4_bs = ((pv_nbr_pic_addr0 != pv_cur_pic_addr0)
485 || (pv_nbr_pic_addr1 != pv_cur_pic_addr1)
486 || u4_bs_temp1);
487
488 u4_bs_horz |= (u4_bs << u4_horz_idx);
489 }
490 }
491
492 ps_left_mv_pred = ps_cur_mv_pred;
493 }
494
495 pu4_bs_table[edge] = u4_bs_horz;
496 }
497}
498
499/*****************************************************************************/
500/* */
501/* Function Name : ih264d_fill_bs1_16x16mb_bslice */
502/* */
503/* Description : This function fills boundray strength (=1) for those */
504/* horz and vert mb edges of 16x16mb which are set to 0 by */
505/* ih264d_fill_bs2_horz_vert. This function is used for b slices */
506/* */
507/* Inputs : <What inputs does the function take?> */
508/* Globals : <Does it use any global variables?> */
509/* Processing : If any motion vector component of adjacent 4x4 blocks */
510/* differs by more than 1 integer pel or if reference */
511/* pictures are different, Bs is set to 1. */
512/* */
513/* Outputs : <What does the function produce?> */
514/* Returns : <What does the function return?> */
515/* */
516/* Issues : <List any issues or problems with this function> */
517/* */
518/* Revision History: */
519/* */
520/* DD MM YYYY Author(s) Changes (Describe the changes made) */
521/* 16 10 2008 Jay Draft */
522/* */
523/*****************************************************************************/
524void ih264d_fill_bs1_16x16mb_bslice(mv_pred_t *ps_cur_mv_pred,
525 mv_pred_t *ps_top_mv_pred,
526 void **ppv_map_ref_idx_to_poc,
527 UWORD32 *pu4_bs_table, /* pointer to the BsTable array */
528 mv_pred_t *ps_leftmost_mv_pred,
529 neighbouradd_t *ps_left_addr,
530 void **u4_pic_addrress,
531 WORD32 i4_ver_mvlimit)
532{
533 WORD16 i2_q_mv0, i2_q_mv1, i2_q_mv2, i2_q_mv3;
534 WORD16 i2_p_mv0, i2_p_mv1, i2_p_mv2, i2_p_mv3;
535 void *pv_cur_pic_addr0, *pv_cur_pic_addr1;
536 void *pv_nbr_pic_addr0, *pv_nbr_pic_addr1;
537 void **ppv_map_ref_idx_to_poc_l0, **ppv_map_ref_idx_to_poc_l1;
538 UWORD32 i;
539 UWORD32 u4_bs_horz = pu4_bs_table[0];
540 UWORD32 u4_bs_vert = pu4_bs_table[4];
541
542 PROFILE_DISABLE_BOUNDARY_STRENGTH()
543
544 ppv_map_ref_idx_to_poc_l0 = ppv_map_ref_idx_to_poc;
545 ppv_map_ref_idx_to_poc_l1 = ppv_map_ref_idx_to_poc + POC_LIST_L0_TO_L1_DIFF;
546 i2_q_mv0 = ps_cur_mv_pred->i2_mv[0];
547 i2_q_mv1 = ps_cur_mv_pred->i2_mv[1];
548 i2_q_mv2 = ps_cur_mv_pred->i2_mv[2];
549 i2_q_mv3 = ps_cur_mv_pred->i2_mv[3];
550 pv_cur_pic_addr0 = ppv_map_ref_idx_to_poc_l0[ps_cur_mv_pred->i1_ref_frame[0]];
551 pv_cur_pic_addr1 = ppv_map_ref_idx_to_poc_l1[ps_cur_mv_pred->i1_ref_frame[1]];
552
553 /*********************************/
554 /* Computing Bs for the top edge */
555 /*********************************/
556 for(i = 0; i < 4; i++, ps_top_mv_pred++)
557 {
558 UWORD32 u4_idx = 24 - (i << 3);
559
560 /*********************************/
561 /* check if Bs is already set */
562 /*********************************/
563 if(!((u4_bs_horz >> u4_idx) & 0xf))
564 {
565 /************************************************************/
566 /* If Bs is not set, use left edge and current edge mvs and */
567 /* reference pictures addresses to evaluate Bs==1 */
568 /************************************************************/
569 UWORD32 u4_bs_temp1, u4_bs_temp2;
570 UWORD32 u4_bs;
571
572 /*********************************************************/
573 /* If any motion vector component differs by more than 1 */
574 /* integer pel or if reference pictures are different Bs */
575 /* is set to 1. Note that this condition shall be met for*/
576 /* both (fwd-fwd,bwd-bwd) and (fwd-bwd,bwd-fwd) direction*/
577 /*********************************************************/
578 i2_p_mv0 = ps_top_mv_pred->i2_mv[0];
579 i2_p_mv1 = ps_top_mv_pred->i2_mv[1];
580 i2_p_mv2 = ps_top_mv_pred->i2_mv[2];
581 i2_p_mv3 = ps_top_mv_pred->i2_mv[3];
582 pv_nbr_pic_addr0 = u4_pic_addrress[i & 2];
583 pv_nbr_pic_addr1 = u4_pic_addrress[1 + (i & 2)];
584
585 u4_bs_temp1 =
586 ((ABS((i2_p_mv0 - i2_q_mv0))
587 >= 4)
588 | (ABS((i2_p_mv1 - i2_q_mv1))
589 >= i4_ver_mvlimit)
590 | (ABS((i2_p_mv2 - i2_q_mv2))
591 >= 4)
592 | (ABS((i2_p_mv3 - i2_q_mv3))
593 >= i4_ver_mvlimit));
594
595 u4_bs_temp2 =
596 ((ABS((i2_p_mv0 - i2_q_mv2))
597 >= 4)
598 | (ABS((i2_p_mv1 - i2_q_mv3))
599 >= i4_ver_mvlimit)
600 | (ABS((i2_p_mv2 - i2_q_mv0))
601 >= 4)
602 | (ABS((i2_p_mv3 - i2_q_mv1))
603 >= i4_ver_mvlimit));
604
605 u4_bs = ((pv_cur_pic_addr0 != pv_nbr_pic_addr0)
606 || (pv_cur_pic_addr1 != pv_nbr_pic_addr1)
607 || u4_bs_temp1)
608 && ((pv_cur_pic_addr0 != pv_nbr_pic_addr1)
609 || (pv_cur_pic_addr1
610 != pv_nbr_pic_addr0)
611 || u4_bs_temp2);
612
613 u4_bs_horz |= (u4_bs << u4_idx);
614 }
615 }
616 pu4_bs_table[0] = u4_bs_horz;
617
618 /***********************************/
619 /* Computing Bs for the left edge */
620 /***********************************/
621 for(i = 0; i < 4; i++, ps_leftmost_mv_pred += 4)
622 {
623 UWORD32 u4_idx = 24 - (i << 3);
624
625 /*********************************/
626 /* check if Bs is already set */
627 /*********************************/
628 if(!((u4_bs_vert >> u4_idx) & 0xf))
629 {
630 /****************************************************/
631 /* If Bs is not set, evalaute conditions for Bs=1 */
632 /****************************************************/
633 UWORD32 u4_bs_temp1, u4_bs_temp2;
634 UWORD32 u4_bs;
635 /*********************************************************/
636 /* If any motion vector component differs by more than 1 */
637 /* integer pel or if reference pictures are different Bs */
638 /* is set to 1. Note that this condition shall be met for*/
639 /* both (fwd-fwd,bwd-bwd) and (fwd-bwd,bwd-fwd) direction*/
640 /*********************************************************/
641
642 i2_p_mv0 = ps_leftmost_mv_pred->i2_mv[0];
643 i2_p_mv1 = ps_leftmost_mv_pred->i2_mv[1];
644 i2_p_mv2 = ps_leftmost_mv_pred->i2_mv[2];
645 i2_p_mv3 = ps_leftmost_mv_pred->i2_mv[3];
646 pv_nbr_pic_addr0 = ps_left_addr->u4_add[i & 2];
647 pv_nbr_pic_addr1 = ps_left_addr->u4_add[1 + (i & 2)];
648
649 u4_bs_temp1 =
650 ((ABS((i2_p_mv0 - i2_q_mv0))
651 >= 4)
652 | (ABS((i2_p_mv1 - i2_q_mv1))
653 >= i4_ver_mvlimit)
654 | (ABS((i2_p_mv2 - i2_q_mv2))
655 >= 4)
656 | (ABS((i2_p_mv3 - i2_q_mv3))
657 >= i4_ver_mvlimit));
658
659 u4_bs_temp2 =
660 ((ABS((i2_p_mv0 - i2_q_mv2))
661 >= 4)
662 | (ABS((i2_p_mv1 - i2_q_mv3))
663 >= i4_ver_mvlimit)
664 | (ABS((i2_p_mv2 - i2_q_mv0))
665 >= 4)
666 | (ABS((i2_p_mv3 - i2_q_mv1))
667 >= i4_ver_mvlimit));
668
669 u4_bs = ((pv_cur_pic_addr0 != pv_nbr_pic_addr0)
670 || (pv_cur_pic_addr1 != pv_nbr_pic_addr1)
671 || u4_bs_temp1)
672 && ((pv_cur_pic_addr0 != pv_nbr_pic_addr1)
673 || (pv_cur_pic_addr1
674 != pv_nbr_pic_addr0)
675 || u4_bs_temp2);
676
677 u4_bs_vert |= (u4_bs << u4_idx);
678 }
679 }
680 pu4_bs_table[4] = u4_bs_vert;
681
682 return;
683}
684
685/*****************************************************************************/
686/* */
687/* Function Name : ih264d_fill_bs1_non16x16mb_bslice */
688/* */
689/* Description : This function fills boundray strength (=1) for those */
690/* horz and vert edges of non16x16mb which are set to 0 by */
691/* ih264d_fill_bs2_horz_vert. This function is used for b slices */
692/* */
693/* Inputs : <What inputs does the function take?> */
694/* Globals : <Does it use any global variables?> */
695/* Processing : If any motion vector component of adjacent 4x4 blocks */
696/* differs by more than 1 integer pel or if reference */
697/* pictures are different, Bs is set to 1. */
698/* */
699/* Outputs : <What does the function produce?> */
700/* Returns : <What does the function return?> */
701/* */
702/* Issues : <List any issues or problems with this function> */
703/* */
704/* Revision History: */
705/* */
706/* DD MM YYYY Author(s) Changes (Describe the changes made) */
707/* 16 10 2008 Jay Draft */
708/* */
709/*****************************************************************************/
710void ih264d_fill_bs1_non16x16mb_bslice(mv_pred_t *ps_cur_mv_pred,
711 mv_pred_t *ps_top_mv_pred,
712 void **ppv_map_ref_idx_to_poc,
713 UWORD32 *pu4_bs_table, /* pointer to the BsTable array */
714 mv_pred_t *ps_leftmost_mv_pred,
715 neighbouradd_t *ps_left_addr,
716 void **u4_pic_addrress,
717 WORD32 i4_ver_mvlimit)
718{
719 UWORD32 edge;
720 void **ppv_map_ref_idx_to_poc_l0, **ppv_map_ref_idx_to_poc_l1;
721 ppv_map_ref_idx_to_poc_l0 = ppv_map_ref_idx_to_poc;
722 ppv_map_ref_idx_to_poc_l1 = ppv_map_ref_idx_to_poc + POC_LIST_L0_TO_L1_DIFF;
723
724 PROFILE_DISABLE_BOUNDARY_STRENGTH()
725
726 for(edge = 0; edge < 4; edge++, ps_top_mv_pred = ps_cur_mv_pred - 4)
727 {
728 /*********************************************************************/
729 /* Each iteration of this loop fills the four BS values of one HORIZ */
730 /* edge and one BS value for each of the four VERT edges. */
731 /*********************************************************************/
732 WORD32 i;
733 UWORD32 u4_vert_idx = 24 - (edge << 3);
734 UWORD32 u4_bs_horz = pu4_bs_table[edge];
735 mv_pred_t *ps_left_mv_pred = ps_leftmost_mv_pred + (edge << 2);
736
737 for(i = 0; i < 4; i++, ps_top_mv_pred++, ps_cur_mv_pred++)
738 {
739 WORD16 i2_cur_mv0, i2_cur_mv1, i16_curMv2, i16_curMv3;
740 WORD8 i1_cur_ref0, i1_cur_ref1;
741 void *pv_cur_pic_addr0, *pv_cur_pic_addr1;
742 void *pv_nbr_pic_addr0, *pv_nbr_pic_addr1;
743
744 /******************************************************/
745 /* Each iteration of this inner loop computes a HORIZ */
746 /* and a VERT BS value for a 4x4 block */
747 /******************************************************/
748 UWORD32 u4_bs_vert = (pu4_bs_table[i + 4] >> u4_vert_idx) & 0xf;
749 UWORD32 u4_horz_idx = 24 - (i << 3);
750
751 /*****************************************************/
752 /* check if vert Bs for this block is already set */
753 /*****************************************************/
754 if(!u4_bs_vert)
755 {
756 WORD16 i2_left_mv0, i2_left_mv1, i2_left_mv2, i2_left_mv3;
757 /************************************************************/
758 /* If Bs is not set, use left edge and current edge mvs and */
759 /* reference pictures addresses to evaluate Bs==1 */
760 /************************************************************/
761 i2_left_mv0 = ps_left_mv_pred->i2_mv[0];
762 i2_left_mv1 = ps_left_mv_pred->i2_mv[1];
763 i2_left_mv2 = ps_left_mv_pred->i2_mv[2];
764 i2_left_mv3 = ps_left_mv_pred->i2_mv[3];
765
766 i2_cur_mv0 = ps_cur_mv_pred->i2_mv[0];
767 i2_cur_mv1 = ps_cur_mv_pred->i2_mv[1];
768 i16_curMv2 = ps_cur_mv_pred->i2_mv[2];
769 i16_curMv3 = ps_cur_mv_pred->i2_mv[3];
770 i1_cur_ref0 = ps_cur_mv_pred->i1_ref_frame[0];
771 i1_cur_ref1 = ps_cur_mv_pred->i1_ref_frame[1];
772 pv_cur_pic_addr0 = ppv_map_ref_idx_to_poc_l0[i1_cur_ref0];
773 pv_cur_pic_addr1 = ppv_map_ref_idx_to_poc_l1[i1_cur_ref1];
774
775 if(i)
776 {
777 WORD8 i1_left_ref0, i1_left_ref1;
778 i1_left_ref0 = ps_left_mv_pred->i1_ref_frame[0];
779 i1_left_ref1 = ps_left_mv_pred->i1_ref_frame[1];
780 pv_nbr_pic_addr0 = ppv_map_ref_idx_to_poc_l0[i1_left_ref0];
781 pv_nbr_pic_addr1 = ppv_map_ref_idx_to_poc_l1[i1_left_ref1];
782 }
783 else
784 {
785 pv_nbr_pic_addr0 = ps_left_addr->u4_add[edge & 2];
786 pv_nbr_pic_addr1 = ps_left_addr->u4_add[1 + (edge & 2)];
787 }
788
789 {
790 UWORD32 u4_bs_temp1, u4_bs_temp2;
791 /*********************************************************/
792 /* If any motion vector component differs by more than 1 */
793 /* integer pel or if reference pictures are different Bs */
794 /* is set to 1. Note that this condition shall be met for*/
795 /* both (fwd-fwd,bwd-bwd) and (fwd-bwd,bwd-fwd) direction*/
796 /*********************************************************/
797
798 u4_bs_temp1 =
799 ((ABS((i2_left_mv0 - i2_cur_mv0))
800 >= 4)
801 | (ABS((i2_left_mv1
802 - i2_cur_mv1))
803 >= i4_ver_mvlimit)
804 | (ABS((i2_left_mv2
805 - i16_curMv2))
806 >= 4)
807 | (ABS((i2_left_mv3
808 - i16_curMv3))
809 >= i4_ver_mvlimit));
810
811 u4_bs_temp2 =
812 ((ABS((i2_left_mv0 - i16_curMv2))
813 >= 4)
814 | (ABS((i2_left_mv1
815 - i16_curMv3))
816 >= i4_ver_mvlimit)
817 | (ABS((i2_left_mv2
818 - i2_cur_mv0))
819 >= 4)
820 | (ABS((i2_left_mv3
821 - i2_cur_mv1))
822 >= i4_ver_mvlimit));
823
824 u4_bs_vert =
825 ((pv_nbr_pic_addr0 != pv_cur_pic_addr0)
826 || (pv_nbr_pic_addr1
827 != pv_cur_pic_addr1)
828 || u4_bs_temp1)
829 && ((pv_nbr_pic_addr0
830 != pv_cur_pic_addr1)
831 || (pv_nbr_pic_addr1
832 != pv_cur_pic_addr0)
833 || u4_bs_temp2);
834
835 pu4_bs_table[i + 4] |= (u4_bs_vert << u4_vert_idx);
836 }
837 }
838
839 /*****************************************************/
840 /* check if horz Bs for this block is already set */
841 /*****************************************************/
842 if(!((u4_bs_horz >> u4_horz_idx) & 0xf))
843 {
844 WORD16 i2_top_mv0, i2_top_mv1, i16_topMv2, i16_topMv3;
845 /************************************************************/
846 /* If Bs is not set, use top edge and current edge mvs and */
847 /* reference pictures addresses to evaluate Bs==1 */
848 /************************************************************/
849 i2_cur_mv0 = ps_cur_mv_pred->i2_mv[0];
850 i2_cur_mv1 = ps_cur_mv_pred->i2_mv[1];
851 i16_curMv2 = ps_cur_mv_pred->i2_mv[2];
852 i16_curMv3 = ps_cur_mv_pred->i2_mv[3];
853 i1_cur_ref0 = ps_cur_mv_pred->i1_ref_frame[0];
854 i1_cur_ref1 = ps_cur_mv_pred->i1_ref_frame[1];
855
856 i2_top_mv0 = ps_top_mv_pred->i2_mv[0];
857 i2_top_mv1 = ps_top_mv_pred->i2_mv[1];
858 i16_topMv2 = ps_top_mv_pred->i2_mv[2];
859 i16_topMv3 = ps_top_mv_pred->i2_mv[3];
860 pv_cur_pic_addr0 = ppv_map_ref_idx_to_poc_l0[i1_cur_ref0];
861 pv_cur_pic_addr1 = ppv_map_ref_idx_to_poc_l1[i1_cur_ref1];
862 if(edge)
863 {
864 WORD8 i1_top_ref0, i1_top_ref1;
865 i1_top_ref0 = ps_top_mv_pred->i1_ref_frame[0];
866 i1_top_ref1 = ps_top_mv_pred->i1_ref_frame[1];
867 pv_nbr_pic_addr0 = ppv_map_ref_idx_to_poc_l0[i1_top_ref0];
868 pv_nbr_pic_addr1 = ppv_map_ref_idx_to_poc_l1[i1_top_ref1];
869 }
870 else
871 {
872 pv_nbr_pic_addr0 = u4_pic_addrress[i & 2];
873 pv_nbr_pic_addr1 = u4_pic_addrress[1 + (i & 2)];
874 }
875
876 {
877 UWORD32 u4_bs_temp1, u4_bs_temp2;
878 UWORD32 u4_bs;
879 /*********************************************************/
880 /* If any motion vector component differs by more than 1 */
881 /* integer pel or if reference pictures are different Bs */
882 /* is set to 1. Note that this condition shall be met for*/
883 /* both (fwd-fwd,bwd-bwd) and (fwd-bwd,bwd-fwd) direction*/
884 /*********************************************************/
885
886 u4_bs_temp1 =
887 ((ABS((i2_top_mv0 - i2_cur_mv0))
888 >= 4)
889 | (ABS((i2_top_mv1
890 - i2_cur_mv1))
891 >= i4_ver_mvlimit)
892 | (ABS((i16_topMv2
893 - i16_curMv2))
894 >= 4)
895 | (ABS((i16_topMv3
896 - i16_curMv3))
897 >= i4_ver_mvlimit));
898
899 u4_bs_temp2 =
900 ((ABS((i2_top_mv0 - i16_curMv2))
901 >= 4)
902 | (ABS((i2_top_mv1
903 - i16_curMv3))
904 >= i4_ver_mvlimit)
905 | (ABS((i16_topMv2
906 - i2_cur_mv0))
907 >= 4)
908 | (ABS((i16_topMv3
909 - i2_cur_mv1))
910 >= i4_ver_mvlimit));
911
912 u4_bs =
913 ((pv_nbr_pic_addr0 != pv_cur_pic_addr0)
914 || (pv_nbr_pic_addr1
915 != pv_cur_pic_addr1)
916 || u4_bs_temp1)
917 && ((pv_nbr_pic_addr0
918 != pv_cur_pic_addr1)
919 || (pv_nbr_pic_addr1
920 != pv_cur_pic_addr0)
921 || u4_bs_temp2);
922
923 u4_bs_horz |= (u4_bs << u4_horz_idx);
924 }
925 }
926
927 ps_left_mv_pred = ps_cur_mv_pred;
928 }
929
930 pu4_bs_table[edge] = u4_bs_horz;
931 }
932}
933
934/*****************************************************************************/
935/* */
936/* Function Name : ih264d_fill_bs_xtra_left_edge_cur_fld */
937/* */
938/* Description : This function fills boundray strength (= 2 or 1) for */
939/* xtra left mb edge when cur mb is field and left mb is */
940/* frame. */
941/* Inputs : */
942/* */
943/* Globals : <Does it use any global variables?> */
944/* Processing : */
945/* */
946/* */
947/* Outputs : <What does the function produce?> */
948/* Returns : <What does the function return?> */
949/* */
950/* Issues : <List any issues or problems with this function> */
951/* */
952/* Revision History: */
953/* */
954/* DD MM YYYY Author(s) Changes (Describe the changes made) */
955/* 16 10 2008 Jay Draft */
956/* */
957/*****************************************************************************/
958void ih264d_fill_bs_xtra_left_edge_cur_fld(UWORD32 *pu4_bs, /* Base pointer of BS table */
959 WORD32 u4_left_mb_t_csbp, /* left mbpair's top csbp */
960 WORD32 u4_left_mb_b_csbp, /* left mbpair's bottom csbp*/
961 WORD32 u4_cur_mb_csbp, /* csbp of current mb */
962 UWORD32 u4_cur_mb_top /* is top or bottom mb */
963
964 )
965{
966 const UWORD32 *pu4_packed_bs = (const UWORD32 *)gau4_ih264d_packed_bs2;
967 UWORD32 u4_cur, u4_left, u4_or;
968 UNUSED(u4_cur_mb_top);
969
970 PROFILE_DISABLE_BOUNDARY_STRENGTH()
971
972 u4_left_mb_t_csbp = ((u4_left_mb_t_csbp & 0x0008) >> 3)
973 + ((u4_left_mb_t_csbp & 0x0080) >> 6)
974 + ((u4_left_mb_t_csbp & 0x0800) >> 9)
975 + ((u4_left_mb_t_csbp & 0x8000) >> 12);
976
977 u4_left_mb_b_csbp = ((u4_left_mb_b_csbp & 0x0008) << 1)
978 + ((u4_left_mb_b_csbp & 0x0080) >> 2)
979 + ((u4_left_mb_b_csbp & 0x0800) >> 5)
980 + ((u4_left_mb_b_csbp & 0x8000) >> 8);
981
982 /*********************************************************************/
983 /* u4_cur = 0|0|0|0|0|0|0|0|12C|12C|8C|8C|4C|4C|0C|0C */
984 /*********************************************************************/
985 u4_cur = (u4_cur_mb_csbp & 0x0001) + ((u4_cur_mb_csbp & 0x0001) << 1)
986 + ((u4_cur_mb_csbp & 0x0010) >> 2)
987 + ((u4_cur_mb_csbp & 0x0010) >> 1)
988 + ((u4_cur_mb_csbp & 0x0100) >> 4)
989 + ((u4_cur_mb_csbp & 0x0100) >> 3)
990 + ((u4_cur_mb_csbp & 0x1000) >> 6)
991 + ((u4_cur_mb_csbp & 0x1000) >> 5);
992
993 /*********************************************************************/
994 /* u4_left =0|0|0|0|0|0|0|0|15Lb|11Lb|7Lb|3Lb|15Lt|11Lt|7Lt|3Lt */
995 /*********************************************************************/
996 u4_left = u4_left_mb_t_csbp + u4_left_mb_b_csbp;
997
998 u4_or = (u4_cur | u4_left);
999 /*********************************************************************/
1000 /* Fill vert edges (4,9) boundary strengths using look up table */
1001 /*********************************************************************/
1002 pu4_packed_bs += 16;
1003 pu4_bs[4] = pu4_packed_bs[u4_or & 0xF];
1004 pu4_bs[9] = pu4_packed_bs[(u4_or >> 4)];
1005}
1006
1007/*****************************************************************************/
1008/* */
1009/* Function Name : ih264d_fill_bs_xtra_left_edge_cur_frm */
1010/* */
1011/* Description : This function fills boundray strength (= 2 or 1) for */
1012/* xtra left mb edge when cur mb is frame and left mb is */
1013/* field. */
1014/* Inputs : */
1015/* */
1016/* Globals : <Does it use any global variables?> */
1017/* Processing : */
1018/* */
1019/* */
1020/* Outputs : <What does the function produce?> */
1021/* Returns : <What does the function return?> */
1022/* */
1023/* Issues : <List any issues or problems with this function> */
1024/* */
1025/* Revision History: */
1026/* */
1027/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1028/* 16 10 2008 Jay Draft */
1029/* */
1030/*****************************************************************************/
1031void ih264d_fill_bs_xtra_left_edge_cur_frm(UWORD32 *pu4_bs, /* Base pointer of BS table */
1032 WORD32 u4_left_mb_t_csbp, /* left mbpair's top csbp */
1033 WORD32 u4_left_mb_b_csbp, /* left mbpair's bottom csbp*/
1034 WORD32 u4_cur_mb_csbp, /* csbp of current mb */
1035 UWORD32 u4_cur_mb_bot /* is top or bottom mb */
1036
1037 )
1038{
1039 const UWORD32 *pu4_packed_bs = (const UWORD32 *)gau4_ih264d_packed_bs2;
1040 UWORD32 u4_cur, u4_left, u4_or;
1041 UWORD32 u4_right_shift = (u4_cur_mb_bot << 3);
1042
1043 PROFILE_DISABLE_BOUNDARY_STRENGTH()
1044
1045 u4_left_mb_t_csbp >>= u4_right_shift;
1046 u4_left_mb_b_csbp >>= u4_right_shift;
1047
1048 u4_left_mb_t_csbp = ((u4_left_mb_t_csbp & 0x08) >> 3)
1049 + ((u4_left_mb_t_csbp & 0x08) >> 2)
1050 + ((u4_left_mb_t_csbp & 0x80) >> 5)
1051 + ((u4_left_mb_t_csbp & 0x80) >> 4);
1052
1053 u4_left_mb_b_csbp = ((u4_left_mb_b_csbp & 0x08) << 1)
1054 + ((u4_left_mb_b_csbp & 0x08) << 2)
1055 + ((u4_left_mb_b_csbp & 0x80) >> 1)
1056 + ((u4_left_mb_b_csbp & 0x80));
1057
1058 u4_cur = ((u4_cur_mb_csbp & 0x0001)) + ((u4_cur_mb_csbp & 0x0010) >> 3)
1059 + ((u4_cur_mb_csbp & 0x0100) >> 6)
1060 + ((u4_cur_mb_csbp & 0x1000) >> 9);
1061
1062 u4_cur += (u4_cur << 4);
1063
1064 u4_left = u4_left_mb_t_csbp + u4_left_mb_b_csbp;
1065
1066 u4_or = (u4_cur | u4_left);
1067 /*********************************************************************/
1068 /* Fill vert edges (4,9) boundary strengths using look up table */
1069 /*********************************************************************/
1070 pu4_packed_bs += 16;
1071 pu4_bs[4] = pu4_packed_bs[u4_or & 0xF];
1072 pu4_bs[9] = pu4_packed_bs[(u4_or >> 4)];
1073}
1074
1075/*****************************************************************************/
1076/* */
1077/* Function Name : ih264d_fill_bs_xtra_top_edge */
1078/* */
1079/* Description : This function fills boundray strength (= 2 or 1) for */
1080/* xtra top mb edge when cur mb is top mb of frame mb pair */
1081/* and top mbpair is field coded. */
1082/* Inputs : */
1083/* */
1084/* Globals : <Does it use any global variables?> */
1085/* Processing : */
1086/* */
1087/* */
1088/* Outputs : <What does the function produce?> */
1089/* Returns : <What does the function return?> */
1090/* */
1091/* Issues : <List any issues or problems with this function> */
1092/* */
1093/* Revision History: */
1094/* */
1095/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1096/* 16 10 2008 Jay Draft */
1097/* */
1098/*****************************************************************************/
1099void ih264d_fill_bs_xtra_top_edge(UWORD32 *pu4_bs, /* Base pointer of BS table */
1100 WORD32 u4_topmb_t_csbp, /* top mbpair's top csbp */
1101 WORD32 u4_topmb_b_csbp, /* top mbpair's bottom csbp*/
1102 WORD32 u4_cur_mb_csbp /* csbp of current mb */
1103
1104 )
1105{
1106 const UWORD32 *pu4_packed_bs = (const UWORD32 *)gau4_ih264d_packed_bs2;
1107 UWORD32 u4_or;
1108
1109 u4_cur_mb_csbp &= 0xf;
1110 u4_topmb_t_csbp >>= 12;
1111 u4_topmb_b_csbp >>= 12;
1112
1113 u4_or = (u4_cur_mb_csbp | u4_topmb_t_csbp);
1114 /*********************************************************************/
1115 /* Fill vert edges (0,8) boundary strengths using look up table */
1116 /*********************************************************************/
1117 pu4_packed_bs += 16;
1118 pu4_bs[8] = pu4_packed_bs[u4_or];
1119
1120 u4_or = (u4_cur_mb_csbp | u4_topmb_b_csbp);
1121 pu4_bs[0] = pu4_packed_bs[u4_or];
1122}
1123
1124/*****************************************************************************/
1125/* */
1126/* Function Name : ih264d_compute_bs_non_mbaff */
1127/* */
1128/* Description : This function computes the pointers of left,top & current*/
1129/* : Nnz, MvPred & deblk_mb_t and supplies to FillBs function for*/
1130/* : Boundary Strength Calculation */
1131/* Inputs : <What inputs does the function take?> */
1132/* Processing : This functions calls deblock MB in the MB increment order*/
1133/* */
1134/* Outputs : Produces the Boundary Strength for Current Mb */
1135/* Returns : None */
1136/* */
1137/* Revision History: */
1138/* */
1139/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1140/* ITTIAM */
1141/*****************************************************************************/
1142
1143void ih264d_compute_bs_non_mbaff(dec_struct_t * ps_dec,
1144 dec_mb_info_t * ps_cur_mb_info,
1145 const UWORD16 u2_mbxn_mb)
1146{
1147 /* Mvpred and Nnz for top and Courrent */
1148 mv_pred_t *ps_cur_mv_pred, *ps_top_mv_pred = NULL, *ps_left_mv_pred;
1149 /* deblk_mb_t Params */
1150 deblk_mb_t *ps_cur_mb_params; /*< Parameters of current MacroBlock */
1151 deblkmb_neighbour_t *ps_deblk_top_mb;
1152
1153 /* Reference Index to POC mapping*/
1154 void ** apv_map_ref_idx_to_poc;
1155 UWORD32 u4_leftmbtype;
1156
1157 UWORD16 u2_left_csbp, u2_top_csbp, u2_cur_csbp;
1158
1159 /* Set of flags */
1160 UWORD32 u4_cur_mb_intra, u1_top_mb_typ, u4_cur_mb_fld;
1161 UWORD32 u1_cur_mb_type;
1162 UWORD32 * pu4_bs_table;
1163
1164 /* Neighbour availability */
1165 /* Initialization */
1166 const UWORD32 u2_mbx = ps_cur_mb_info->u2_mbx;
1167 const UWORD32 u2_mby = ps_cur_mb_info->u2_mby;
1168 const UWORD32 u1_pingpong = u2_mbx & 0x01;
1169
1170 PROFILE_DISABLE_BOUNDARY_STRENGTH()
1171
1172 ps_deblk_top_mb = ps_dec->ps_deblk_top_mb + u2_mbx;
1173
1174
1175 /* Pointer assignment for Current DeblkMB, Current Mv Pred */
1176 ps_cur_mb_params = ps_dec->ps_deblk_mbn + u2_mbxn_mb;
1177 ps_cur_mv_pred = ps_dec->ps_mv_cur + (u2_mbxn_mb << 4);
1178
1179 apv_map_ref_idx_to_poc = ps_dec->ppv_map_ref_idx_to_poc + 1;
1180 u1_cur_mb_type = ps_cur_mb_params->u1_mb_type;
1181 u1_top_mb_typ = ps_deblk_top_mb->u1_mb_type;
1182 ps_deblk_top_mb->u1_mb_type = u1_cur_mb_type;
1183
1184 {
1185 UWORD8 mb_qp_temp;
1186
1187 ps_cur_mb_params->u1_topmb_qp = ps_deblk_top_mb->u1_mb_qp;
1188 ps_deblk_top_mb->u1_mb_qp = ps_cur_mb_params->u1_mb_qp;
1189
1190 ps_cur_mb_params->u1_left_mb_qp = ps_dec->deblk_left_mb[1].u1_mb_qp;
1191 ps_dec->deblk_left_mb[1].u1_mb_qp = ps_cur_mb_params->u1_mb_qp;
1192
1193 }
1194
1195 /* if no deblocking required for current Mb then continue */
1196 /* Check next Mbs in Mb group */
1197 if(ps_cur_mb_params->u1_deblocking_mode & MB_DISABLE_FILTERING)
1198 {
1199 void ** pu4_map_ref_idx_to_poc_l1 = apv_map_ref_idx_to_poc +
1200 POC_LIST_L0_TO_L1_DIFF;
1201 {
1202 /* Store Parameter for Top MvPred refernce frame Address */
1203
1204 void ** ppv_top_mv_pred_addr = ps_cur_mb_info->ps_curmb->u4_pic_addrress;
1205 WORD8 * p1_refTop0 = (ps_cur_mv_pred + 12)->i1_ref_frame;
1206 WORD8 * p1_refTop1 = (ps_cur_mv_pred + 14)->i1_ref_frame;
1207
1208 /* Store Left addresses for Next Mb */
1209 void ** ppv_left_mv_pred_addr =
1210 ps_dec->ps_left_mvpred_addr[!u1_pingpong][1].u4_add;
1211 WORD8 * p1_refleft0 = (ps_cur_mv_pred + 3)->i1_ref_frame;
1212
1213
1214 ppv_top_mv_pred_addr[0] = apv_map_ref_idx_to_poc[p1_refTop0[0]];
1215 ppv_top_mv_pred_addr[1] = pu4_map_ref_idx_to_poc_l1[p1_refTop0[1]];
1216
1217 ppv_left_mv_pred_addr[2] = apv_map_ref_idx_to_poc[p1_refTop1[0]];
1218 ppv_top_mv_pred_addr[2] = apv_map_ref_idx_to_poc[p1_refTop1[0]];
1219 ppv_left_mv_pred_addr[3] = pu4_map_ref_idx_to_poc_l1[p1_refTop1[1]];
1220 ppv_top_mv_pred_addr[3] = pu4_map_ref_idx_to_poc_l1[p1_refTop1[1]];
1221
1222 ppv_left_mv_pred_addr[0] = apv_map_ref_idx_to_poc[p1_refleft0[0]];
1223 ppv_left_mv_pred_addr[1] = pu4_map_ref_idx_to_poc_l1[p1_refleft0[1]];
1224 //}
1225 /* Storing the leftMbtype for next Mb */
1226 ps_dec->deblk_left_mb[1].u1_mb_type = ps_cur_mb_params->u1_mb_type;
1227 }
1228
1229 return;
1230 }
1231
1232 /* Flag for extra left Edge */
1233 ps_cur_mb_params->u1_single_call = 1;
1234
1235 /* Update the Left deblk_mb_t and Left MvPred Parameters */
1236 if(!u2_mbx)
1237 {
1238 u4_leftmbtype = 0;
1239
1240 /* Initialize the ps_left_mv_pred with Junk but Valid Location */
1241 /* to avoid invalid memory access */
1242 /* this is read only pointer */
1243 ps_left_mv_pred = ps_dec->ps_mv_cur + 3;
1244 }
1245 else
1246 {
1247 u4_leftmbtype = ps_dec->deblk_left_mb[1].u1_mb_type;
1248
1249 /* Come to Left Most Edge of the MB */
1250 ps_left_mv_pred = (u2_mbxn_mb) ?
1251 ps_dec->ps_mv_cur + ((u2_mbxn_mb - 1) << 4) + 3 :
1252 ps_dec->ps_mv_left + 3;
1253 }
1254
1255 if(!u2_mby)
1256 u1_top_mb_typ = 0;
1257
1258 /* MvPred Pointer Calculation */
1259 /* CHANGED CODE */
1260 ps_top_mv_pred = ps_cur_mv_pred - (ps_dec->u2_frm_wd_in_mbs << 4) + 12;
1261
1262 u4_cur_mb_intra = u1_cur_mb_type & D_INTRA_MB;
1263 u4_cur_mb_fld = !!(u1_cur_mb_type & D_FLD_MB);
1264 /* Compute BS function */
1265 pu4_bs_table = ps_cur_mb_params->u4_bs_table;
1266
1267 u2_cur_csbp = ps_cur_mb_info->ps_curmb->u2_luma_csbp;
1268 u2_left_csbp = ps_cur_mb_info->ps_left_mb->u2_luma_csbp;
1269 u2_top_csbp = ps_cur_mb_info->ps_top_mb->u2_luma_csbp;
1270 /* Compute BS function */
1271 if(ps_dec->ps_cur_sps->u1_profile_idc == HIGH_PROFILE_IDC)
1272 {
1273 if(ps_cur_mb_info->u1_tran_form8x8 == 1)
1274 {
1275 u2_cur_csbp = ih264d_update_csbp_8x8(
1276 ps_cur_mb_info->ps_curmb->u2_luma_csbp);
1277 }
1278
1279 if(ps_cur_mb_info->ps_left_mb->u1_tran_form8x8 == 1)
1280 {
1281 u2_left_csbp = ih264d_update_csbp_8x8(
1282 ps_cur_mb_info->ps_left_mb->u2_luma_csbp);
1283 }
1284
1285 if(ps_cur_mb_info->ps_top_mb->u1_tran_form8x8 == 1)
1286 {
1287 u2_top_csbp = ih264d_update_csbp_8x8(
1288 ps_cur_mb_info->ps_top_mb->u2_luma_csbp);
1289 }
1290 }
1291 if(u4_cur_mb_intra)
1292 {
1293
1294 pu4_bs_table[4] = 0x04040404;
1295 pu4_bs_table[0] = u4_cur_mb_fld ? 0x03030303 : 0x04040404;
1296 pu4_bs_table[1] = 0x03030303;
1297 pu4_bs_table[2] = 0x03030303;
1298 pu4_bs_table[3] = 0x03030303;
1299 pu4_bs_table[5] = 0x03030303;
1300 pu4_bs_table[6] = 0x03030303;
1301 pu4_bs_table[7] = 0x03030303;
1302 }
1303 else
1304 {
1305 UWORD32 u4_is_non16x16 = !!(u1_cur_mb_type & D_PRED_NON_16x16);
1306 UWORD32 u4_is_b = ps_dec->u1_B;
1307
1308 ih264d_fill_bs2_horz_vert(
1309 pu4_bs_table, u2_left_csbp, u2_top_csbp, u2_cur_csbp,
1310 (const UWORD32 *)(gau4_ih264d_packed_bs2),
1311 (const UWORD16 *)(gau2_ih264d_4x4_v2h_reorder));
1312
1313 if(u4_leftmbtype & D_INTRA_MB)
1314 pu4_bs_table[4] = 0x04040404;
1315
1316 if(u1_top_mb_typ & D_INTRA_MB)
1317 pu4_bs_table[0] = u4_cur_mb_fld ? 0x03030303 : 0x04040404;
1318
1319 ps_dec->pf_fill_bs1[u4_is_b][u4_is_non16x16](
1320 ps_cur_mv_pred, ps_top_mv_pred, apv_map_ref_idx_to_poc,
1321 pu4_bs_table, ps_left_mv_pred,
1322 &(ps_dec->ps_left_mvpred_addr[u1_pingpong][1]),
1323 ps_cur_mb_info->ps_top_mb->u4_pic_addrress,
1324 (4 >> u4_cur_mb_fld));
1325 }
1326
1327 {
1328 void ** pu4_map_ref_idx_to_poc_l1 = apv_map_ref_idx_to_poc +
1329 POC_LIST_L0_TO_L1_DIFF;
1330 {
1331 /* Store Parameter for Top MvPred refernce frame Address */
1332
1333 void ** ppv_top_mv_pred_addr = ps_cur_mb_info->ps_curmb->u4_pic_addrress;
1334 WORD8 * p1_refTop0 = (ps_cur_mv_pred + 12)->i1_ref_frame;
1335 WORD8 * p1_refTop1 = (ps_cur_mv_pred + 14)->i1_ref_frame;
1336
1337 /* Store Left addresses for Next Mb */
1338 void ** ppv_left_mv_pred_addr =
1339 ps_dec->ps_left_mvpred_addr[!u1_pingpong][1].u4_add;
1340 WORD8 * p1_refleft0 = (ps_cur_mv_pred + 3)->i1_ref_frame;
1341
1342 ppv_top_mv_pred_addr[0] = apv_map_ref_idx_to_poc[p1_refTop0[0]];
1343 ppv_top_mv_pred_addr[1] = pu4_map_ref_idx_to_poc_l1[p1_refTop0[1]];
1344
1345 ppv_left_mv_pred_addr[2] = apv_map_ref_idx_to_poc[p1_refTop1[0]];
1346 ppv_top_mv_pred_addr[2] = apv_map_ref_idx_to_poc[p1_refTop1[0]];
1347 ppv_left_mv_pred_addr[3] = pu4_map_ref_idx_to_poc_l1[p1_refTop1[1]];
1348 ppv_top_mv_pred_addr[3] = pu4_map_ref_idx_to_poc_l1[p1_refTop1[1]];
1349
1350 ppv_left_mv_pred_addr[0] = apv_map_ref_idx_to_poc[p1_refleft0[0]];
1351 ppv_left_mv_pred_addr[1] = pu4_map_ref_idx_to_poc_l1[p1_refleft0[1]];
1352
1353 /* Storing the leftMbtype for next Mb */
1354 ps_dec->deblk_left_mb[1].u1_mb_type = ps_cur_mb_params->u1_mb_type;
1355
1356 }
1357 }
1358
1359 /* For transform 8x8 disable deblocking of the intrernal edges of a 8x8 block */
1360 if(ps_cur_mb_info->u1_tran_form8x8)
1361 {
1362 pu4_bs_table[1] = 0;
1363 pu4_bs_table[3] = 0;
1364 pu4_bs_table[5] = 0;
1365 pu4_bs_table[7] = 0;
1366 }
1367}
1368
1369/*****************************************************************************/
1370/* */
1371/* Function Name : ih264d_compute_bs_mbaff */
1372/* */
1373/* Description : This function computes the pointers of left,top & current*/
1374/* : Nnz, MvPred & deblk_mb_t and supplies to FillBs function for*/
1375/* : Boundary Strength Calculation */
1376/* Inputs : <What inputs does the function take?> */
1377/* Processing : This functions calls deblock MB in the MB increment order*/
1378/* */
1379/* Outputs : Produces the Boundary Strength for Current Mb */
1380/* Returns : None */
1381/* */
1382/* Revision History: */
1383/* */
1384/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1385/* ITTIAM */
1386/*****************************************************************************/
1387
1388void ih264d_compute_bs_mbaff(dec_struct_t * ps_dec,
1389 dec_mb_info_t * ps_cur_mb_info,
1390 const UWORD16 u2_mbxn_mb)
1391{
1392 /* Mvpred and Nnz for top and Courrent */
1393 mv_pred_t *ps_cur_mv_pred, *ps_top_mv_pred = NULL, *ps_left_mv_pred;
1394 /* deblk_mb_t Params */
1395 deblk_mb_t *ps_cur_mb_params; /*< Parameters of current MacroBlock */
1396 neighbouradd_t * ps_left_ngbr;
1397 deblkmb_neighbour_t *ps_deblk_top_mb;
1398 /* Reference Index to POC mapping*/
1399 void ** apv_map_ref_idx_to_poc;
1400
1401 UWORD32 u4_leftmbtype;
1402
1403
1404 UWORD16 u2_left_csbp, u2_top_csbp, u2_cur_csbp;
1405
1406 /* Set of flags */
1407 UWORD32 u4_cur_mb_intra, u4_cur_mb_fld, u4_top_mb_fld, u1_top_mb_typ, u4_left_mb_fld;
1408 UWORD32 u1_cur_mb_type;
1409 UWORD32 * pu4_bs_table;
1410 const UWORD32 u4_bot_mb = (1 - ps_cur_mb_info->u1_topmb);
1411 /* Initialization */
1412 const UWORD32 u2_mbx = ps_cur_mb_info->u2_mbx;
1413 const UWORD32 u2_mby = ps_cur_mb_info->u2_mby;
1414 /* Load From u1_pingpong and Store in !u1_pingpong */
1415 const UWORD32 u1_pingpong = u2_mbx & 0x01;
1416
1417 PROFILE_DISABLE_BOUNDARY_STRENGTH()
1418
1419 ps_deblk_top_mb = ps_dec->ps_deblk_top_mb + (u2_mbx << 1);
1420
1421
1422 /************************************************/
1423 /* Initialize the left Mb type */
1424 /* Left MvPred */
1425 /************************************************/
1426
1427 if(!u2_mbx)
1428 {
1429 /************************************************************/
1430 /* Initialize the ps_left_mv_pred with Junk but Valid Location */
1431 /* to avoid invalid memory access */
1432 /* this is read only pointer */
1433 /************************************************************/
1434 ps_left_mv_pred = ps_dec->ps_mv_cur + 16;
1435 }
1436 else
1437 {
1438 /* Come to Left Most Edge of the MB */
1439 ps_left_mv_pred = (u2_mbxn_mb) ?
1440 ps_dec->ps_mv_cur + ((u2_mbxn_mb - 1) << 5) + 3 :
1441 ps_dec->ps_mv_left + 3;
1442
1443 ps_left_mv_pred += (u4_bot_mb << 4);
1444 }
1445
1446 u4_leftmbtype = ps_dec->deblk_left_mb[u4_bot_mb].u1_mb_type;
1447
1448 ps_left_ngbr = &(ps_dec->ps_left_mvpred_addr[u1_pingpong][u4_bot_mb]);
1449
1450 /************************************************/
1451 /* Pointer Assignment for Current Mb Parameters */
1452 /* Pointer Assignment for Current MvPred */
1453 /************************************************/
1454 ps_cur_mb_params = ps_dec->ps_deblk_mbn + (u2_mbxn_mb << 1) + u4_bot_mb;
1455 u1_cur_mb_type = ps_cur_mb_params->u1_mb_type;
1456
1457 ps_cur_mv_pred = ps_dec->ps_mv_cur + (u2_mbxn_mb << 5);
1458 ps_cur_mv_pred += (u4_bot_mb << 4);
1459
1460 /********************************************/
1461 /* Pointer Assignment for Top Mb Parameters */
1462 /* Pointer Assignment for Top MvPred and */
1463 /* Pointer Assignment for Top Nnz */
1464 /********************************************/
1465
1466 /* CHANGED CODE */
1467 ps_top_mv_pred = ps_cur_mv_pred - (ps_dec->u2_frm_wd_in_mbs << 5) + 12;
1468
1469 u4_cur_mb_fld = !!(u1_cur_mb_type & D_FLD_MB);
1470 u4_left_mb_fld = !!(ps_dec->deblk_left_mb[0].u1_mb_type & D_FLD_MB);
1471
1472 if(u4_left_mb_fld != u4_cur_mb_fld)
1473 {
1474 /* Flag for extra left Edge */
1475 ps_cur_mb_params->u1_single_call = 0;
1476
1477 if(u4_bot_mb)
1478 {
1479 ps_left_ngbr--;
1480 ps_left_mv_pred -= 16;
1481 }
1482 }
1483 else
1484 ps_cur_mb_params->u1_single_call = 1;
1485
1486 apv_map_ref_idx_to_poc = ps_dec->ppv_map_ref_idx_to_poc + 1;
1487 if(u4_cur_mb_fld)
1488 {
1489 if(u4_bot_mb)
1490 {
1491 apv_map_ref_idx_to_poc += BOT_LIST_FLD_L0;
1492 }
1493 else
1494 {
1495 apv_map_ref_idx_to_poc += TOP_LIST_FLD_L0;
1496 }
1497 }
1498
1499 /**********************************************************/
1500 /* if no deblocking required for current Mb then continue */
1501 /**********************************************************/
1502 if(ps_cur_mb_params->u1_deblocking_mode & MB_DISABLE_FILTERING)
1503 {
1504 void ** pu4_map_ref_idx_to_poc_l1 = apv_map_ref_idx_to_poc +
1505 POC_LIST_L0_TO_L1_DIFF;
1506
1507 {
1508 /* Store Parameter for Top MvPred refernce frame Address */
1509
1510 void ** ppv_top_mv_pred_addr = ps_cur_mb_info->ps_curmb->u4_pic_addrress;
1511 void ** ppv_left_mv_pred_addr =
1512 ps_dec->ps_left_mvpred_addr[!u1_pingpong][u4_bot_mb].u4_add;
1513 WORD8 * p1_refTop0 = (ps_cur_mv_pred + 12)->i1_ref_frame;
1514 WORD8 * p1_refTop1 = (ps_cur_mv_pred + 14)->i1_ref_frame;
1515 WORD8 * p1_refLeft0 = (ps_cur_mv_pred + 3)->i1_ref_frame;
1516 ppv_top_mv_pred_addr[0] = apv_map_ref_idx_to_poc[p1_refTop0[0]];
1517 ppv_top_mv_pred_addr[1] = pu4_map_ref_idx_to_poc_l1[p1_refTop0[1]];
1518 ppv_left_mv_pred_addr[2] = apv_map_ref_idx_to_poc[p1_refTop1[0]];
1519 ppv_top_mv_pred_addr[2] = apv_map_ref_idx_to_poc[p1_refTop1[0]];
1520 ppv_left_mv_pred_addr[3] = pu4_map_ref_idx_to_poc_l1[p1_refTop1[1]];
1521 ppv_top_mv_pred_addr[3] = pu4_map_ref_idx_to_poc_l1[p1_refTop1[1]];
1522 ppv_left_mv_pred_addr[0] = apv_map_ref_idx_to_poc[p1_refLeft0[0]];
1523 ppv_left_mv_pred_addr[1] = pu4_map_ref_idx_to_poc_l1[p1_refLeft0[1]];
1524 }
1525 if(u4_bot_mb)
1526 {
1527 /* store The Left Mb Type*/
1528 ps_dec->deblk_left_mb[0].u1_mb_type =
1529 (ps_cur_mb_params - 1)->u1_mb_type;
1530 ps_dec->deblk_left_mb[1].u1_mb_type = ps_cur_mb_params->u1_mb_type;
1531
1532 }
1533 ps_deblk_top_mb[u4_bot_mb].u1_mb_type = u1_cur_mb_type;
1534 return;
1535 }
1536
1537 if(u2_mby)
1538 {
1539 u1_top_mb_typ = ps_deblk_top_mb[1].u1_mb_type;
1540 u4_top_mb_fld = !!(u1_top_mb_typ & D_FLD_MB);
1541
1542 if(!u4_bot_mb)
1543 {
1544 if(u4_top_mb_fld & u4_cur_mb_fld)
1545 u1_top_mb_typ = ps_deblk_top_mb[0].u1_mb_type;
1546 else
1547 {
1548 ps_top_mv_pred += 16;
1549 }
1550 }
1551 }
1552 else
1553 {
1554 u4_top_mb_fld = u4_cur_mb_fld;
1555 u1_top_mb_typ = 0;
1556 }
1557
1558 if(u4_bot_mb & !u4_cur_mb_fld)
1559 {
1560 u1_top_mb_typ = ps_deblk_top_mb[0].u1_mb_type;
1561 u4_top_mb_fld = u4_cur_mb_fld;
1562 ps_top_mv_pred = ps_cur_mv_pred - 4;
1563 }
1564
1565 pu4_bs_table = ps_cur_mb_params->u4_bs_table;
1566 u4_cur_mb_intra = u1_cur_mb_type & D_INTRA_MB;
1567
1568 u2_cur_csbp = ps_cur_mb_info->ps_curmb->u2_luma_csbp;
1569 u2_left_csbp = ps_cur_mb_info->ps_left_mb->u2_luma_csbp;
1570 u2_top_csbp = ps_cur_mb_info->ps_top_mb->u2_luma_csbp;
1571 /* Compute BS function */
1572 if(ps_dec->ps_cur_sps->u1_profile_idc == HIGH_PROFILE_IDC)
1573 {
1574
1575 if(ps_cur_mb_info->u1_tran_form8x8 == 1)
1576 {
1577 u2_cur_csbp = ih264d_update_csbp_8x8(
1578 ps_cur_mb_info->ps_curmb->u2_luma_csbp);
1579 }
1580
1581 if(ps_cur_mb_info->ps_left_mb->u1_tran_form8x8 == 1)
1582 {
1583 u2_left_csbp = ih264d_update_csbp_8x8(
1584 ps_cur_mb_info->ps_left_mb->u2_luma_csbp);
1585 }
1586
1587 if(ps_cur_mb_info->ps_top_mb->u1_tran_form8x8 == 1)
1588 {
1589 u2_top_csbp = ih264d_update_csbp_8x8(
1590 ps_cur_mb_info->ps_top_mb->u2_luma_csbp);
1591 }
1592 }
1593 if(u4_cur_mb_intra)
1594 {
1595
1596 pu4_bs_table[4] = 0x04040404;
1597 if((0 == u4_cur_mb_fld) && (0 == u4_top_mb_fld))
1598 {
1599 pu4_bs_table[0] = 0x04040404;
1600 }
1601 else
1602 {
1603 pu4_bs_table[0] = 0x03030303;
1604 }
1605
1606 pu4_bs_table[1] = 0x03030303;
1607 pu4_bs_table[2] = 0x03030303;
1608 pu4_bs_table[3] = 0x03030303;
1609 pu4_bs_table[5] = 0x03030303;
1610 pu4_bs_table[6] = 0x03030303;
1611 pu4_bs_table[7] = 0x03030303;
1612
1613 /*********************************************************************/
1614 /* Fill Bs of xtra top and left edge unconditionally to avoid checks */
1615 /*********************************************************************/
1616 pu4_bs_table[8] = 0x03030303;
1617 pu4_bs_table[9] = 0x04040404;
1618 }
1619 else
1620 {
1621 UWORD32 u4_is_non16x16 = !!(u1_cur_mb_type & D_PRED_NON_16x16);
1622 UWORD32 u4_is_b = ps_dec->u1_B;
1623
1624 ih264d_fill_bs2_horz_vert(
1625 pu4_bs_table, u2_left_csbp, u2_top_csbp, u2_cur_csbp,
1626 (const UWORD32 *)(gau4_ih264d_packed_bs2),
1627 (const UWORD16 *)(gau2_ih264d_4x4_v2h_reorder));
1628
1629 if(u4_leftmbtype & D_INTRA_MB)
1630 pu4_bs_table[4] = 0x04040404;
1631
1632 if(u1_top_mb_typ & D_INTRA_MB)
1633 pu4_bs_table[0] = u4_cur_mb_fld ? 0x03030303 : 0x04040404;
1634 else if(u4_cur_mb_fld != u4_top_mb_fld)
1635 {
1636 /****************************************************/
1637 /* Setting BS for mixed mode edge=1 when (Bs!=2) */
1638 /****************************************************/
1639 pu4_bs_table[0] = (pu4_bs_table[0] >> 1) + 0x01010101;
1640 }
1641
1642 {
1643 /* Call to Compute Boundary Strength for Extra Left Edge */
1644 if(u2_mbx
1645 && !(ps_cur_mb_params->u1_deblocking_mode
1646 & MB_DISABLE_LEFT_EDGE))
1647 {
1648 if(u4_cur_mb_fld != u4_left_mb_fld)
1649 {
1650 UWORD32 u4_left_mb_t_csbp =
1651 ps_cur_mb_info->ps_left_mb[0].u2_luma_csbp;
1652 UWORD32 u4_left_mb_b_csbp =
1653 ps_cur_mb_info->ps_left_mb[1].u2_luma_csbp;
1654 if(1 == ps_cur_mb_info->ps_left_mb[0].u1_tran_form8x8)
1655 {
1656 u4_left_mb_t_csbp = (UWORD32)ih264d_update_csbp_8x8(
1657 (UWORD16)u4_left_mb_t_csbp);
1658 }
1659
1660 if(1 == ps_cur_mb_info->ps_left_mb[1].u1_tran_form8x8)
1661 {
1662 u4_left_mb_b_csbp = (UWORD32)ih264d_update_csbp_8x8(
1663 (UWORD16)u4_left_mb_b_csbp);
1664 }
1665 ps_dec->pf_fill_bs_xtra_left_edge[u4_cur_mb_fld](
1666 pu4_bs_table, u4_left_mb_t_csbp,
1667 u4_left_mb_b_csbp, u2_cur_csbp, u4_bot_mb);
1668
1669 if(ps_dec->deblk_left_mb[0].u1_mb_type & D_INTRA_MB)
1670 pu4_bs_table[4] = 0x04040404;
1671
1672 if(ps_dec->deblk_left_mb[1].u1_mb_type & D_INTRA_MB)
1673 pu4_bs_table[9] = 0x04040404;
1674
1675 }
1676 }
1677 /* Call to Compute Boundary Strength for Extra Top Edge */
1678 if(u2_mby
1679 && !(ps_cur_mb_params->u1_deblocking_mode
1680 & MB_DISABLE_TOP_EDGE))
1681 {
1682 if((((!u4_bot_mb) & (!u4_cur_mb_fld)) && u4_top_mb_fld))
1683 {
1684 UWORD32 u4_topmb_t_csbp =
1685 ps_cur_mb_info->ps_top_mb[-1].u2_luma_csbp;
1686 UWORD32 u4_topmb_b_csbp =
1687 ps_cur_mb_info->ps_top_mb[0].u2_luma_csbp;
1688 if(1 == ps_cur_mb_info->ps_top_mb[-1].u1_tran_form8x8)
1689 {
1690 u4_topmb_t_csbp = (UWORD32)ih264d_update_csbp_8x8(
1691 (UWORD16)u4_topmb_t_csbp);
1692 }
1693
1694 if(1 == ps_cur_mb_info->ps_top_mb[0].u1_tran_form8x8)
1695 {
1696 u4_topmb_b_csbp = (UWORD32)ih264d_update_csbp_8x8(
1697 (UWORD16)u4_topmb_b_csbp);
1698 }
1699 ih264d_fill_bs_xtra_top_edge(pu4_bs_table, u4_topmb_t_csbp,
1700 u4_topmb_b_csbp, u2_cur_csbp);
1701
1702 if(ps_deblk_top_mb[0].u1_mb_type & D_INTRA_MB)
1703 pu4_bs_table[8] = 0x03030303;
1704
1705 if(ps_deblk_top_mb[1].u1_mb_type & D_INTRA_MB)
1706 pu4_bs_table[0] = 0x03030303;
1707 }
1708 }
1709 }
1710
1711 ps_dec->pf_fill_bs1[u4_is_b][u4_is_non16x16](
1712 ps_cur_mv_pred, ps_top_mv_pred, apv_map_ref_idx_to_poc,
1713 pu4_bs_table, ps_left_mv_pred, ps_left_ngbr,
1714 ps_cur_mb_info->ps_top_mb->u4_pic_addrress,
1715 (4 >> u4_cur_mb_fld));
1716 }
1717
1718 {
1719 void ** pu4_map_ref_idx_to_poc_l1 = apv_map_ref_idx_to_poc +
1720 POC_LIST_L0_TO_L1_DIFF;
1721
1722 {
1723 /* Store Parameter for Top MvPred refernce frame Address */
1724 void ** ppv_top_mv_pred_addr = ps_cur_mb_info->ps_curmb->u4_pic_addrress;
1725 void ** ppv_left_mv_pred_addr =
1726 ps_dec->ps_left_mvpred_addr[!u1_pingpong][u4_bot_mb].u4_add;
1727 WORD8 * p1_refTop0 = (ps_cur_mv_pred + 12)->i1_ref_frame;
1728 WORD8 * p1_refTop1 = (ps_cur_mv_pred + 14)->i1_ref_frame;
1729 WORD8 * p1_refLeft0 = (ps_cur_mv_pred + 3)->i1_ref_frame;
1730 ppv_top_mv_pred_addr[0] = apv_map_ref_idx_to_poc[p1_refTop0[0]];
1731 ppv_top_mv_pred_addr[1] = pu4_map_ref_idx_to_poc_l1[p1_refTop0[1]];
1732 ppv_left_mv_pred_addr[2] = apv_map_ref_idx_to_poc[p1_refTop1[0]];
1733 ppv_top_mv_pred_addr[2] = apv_map_ref_idx_to_poc[p1_refTop1[0]];
1734 ppv_left_mv_pred_addr[3] = pu4_map_ref_idx_to_poc_l1[p1_refTop1[1]];
1735 ppv_top_mv_pred_addr[3] = pu4_map_ref_idx_to_poc_l1[p1_refTop1[1]];
1736 ppv_left_mv_pred_addr[0] = apv_map_ref_idx_to_poc[p1_refLeft0[0]];
1737 ppv_left_mv_pred_addr[1] = pu4_map_ref_idx_to_poc_l1[p1_refLeft0[1]];
1738 }
1739 if(u4_bot_mb)
1740 {
1741 /* store The Left Mb Type*/
1742 ps_dec->deblk_left_mb[0].u1_mb_type =
1743 (ps_cur_mb_params - 1)->u1_mb_type;
1744 ps_dec->deblk_left_mb[1].u1_mb_type = ps_cur_mb_params->u1_mb_type;
1745
1746 }
1747 ps_deblk_top_mb[u4_bot_mb].u1_mb_type = u1_cur_mb_type;
1748 }
1749 /* For transform 8x8 disable deblocking of the intrernal edges of a 8x8 block */
1750 if(ps_cur_mb_info->u1_tran_form8x8)
1751 {
1752 pu4_bs_table[1] = 0;
1753 pu4_bs_table[3] = 0;
1754 pu4_bs_table[5] = 0;
1755 pu4_bs_table[7] = 0;
1756 }
1757
1758}
1759
1760
1761
1762/*!
1763 **************************************************************************
1764 * \if Function name : ih264d_fill_bs_for_mb \endif
1765 *
1766 * \brief
1767 * Determines the boundary strength (Bs), for the complete MB. Bs is
1768 * determined for each block boundary between two neighbouring 4x4
1769 * luma blocks, then packed in a UWORD32, first Bs placed in MSB and
1770 * so on. Such packed Bs values for all 8 edges are kept in an array.
1771 *
1772 * \return
1773 * Returns the packed boundary strength(Bs) MSB -> LSB Bs0|Bs1|Bs2|Bs3
1774 *
1775 **************************************************************************
1776 */
1777
1778void ih264d_fill_bs_for_mb(deblk_mb_t * ps_cur_mb_params,
1779 deblk_mb_t * ps_top_mb_params,
1780 deblk_mb_t * ps_left_mb_params,
1781 mv_pred_t *ps_cur_mv_pred,
1782 mv_pred_t *ps_top_mv_pred,
1783 UWORD8 *puc_cur_nnz,
1784 UWORD8 *puc_top_nnz,
1785 void **ppv_map_ref_idx_to_poc,
1786 UWORD32 ui_mbAff,
1787 UWORD32 ui_bs_table[], /* pointer to the BsTable array */
1788 mv_pred_t *ps_leftmost_mv_pred,
1789 neighbouradd_t *ps_left_addr,
1790 neighbouradd_t *ps_top_add)
1791{
1792 UWORD32 u4_bs_horz = 0;
1793 UWORD8 edge, u1_top_intra = 0, u1_left_intra = 0;
1794 mv_pred_t *ps_left_mv_pred;
1795 WORD16 i2_cur_mv0, i2_cur_mv1, i16_curMv2, i16_curMv3;
1796 WORD16 i2_left_mv0, i2_left_mv1, i2_left_mv2, i2_left_mv3;
1797 WORD16 i2_top_mv0, i2_top_mv1, i16_topMv2, i16_topMv3;
1798 WORD8 i1_cur_ref0, i1_cur_ref1, i1_left_ref0, i1_left_ref1, i1_top_ref0, i1_top_ref1;
1799 UWORD8 uc_cur_nnz, uc_left_nnz, uc_top_nnz, u1_mb_type, uc_Bslice;
1800 void **ppv_map_ref_idx_to_poc_l0, **ppv_map_ref_idx_to_poc_l1;
1801 UWORD8 uc_temp;
1802 UWORD8 uc_cur_mb_fld, uc_top_mb_fld;
1803 UWORD32 c_mv_limit;
1804
1805 u1_mb_type = ps_cur_mb_params->u1_mb_type;
1806 uc_Bslice = u1_mb_type & D_B_SLICE;
1807 ppv_map_ref_idx_to_poc_l0 = ppv_map_ref_idx_to_poc;
1808 ppv_map_ref_idx_to_poc_l1 = ppv_map_ref_idx_to_poc + POC_LIST_L0_TO_L1_DIFF;
1809
1810 ps_top_mb_params = ps_top_mb_params ? ps_top_mb_params : ps_cur_mb_params;
1811 u1_top_intra = ps_top_mb_params->u1_mb_type & D_INTRA_MB;
1812 u1_left_intra = ps_left_mb_params->u1_mb_type & D_INTRA_MB;
1813
1814 ui_bs_table[4] = 0x04040404; //Default for INTRA MB Boundary edges.
1815 uc_cur_mb_fld = (ps_cur_mb_params->u1_mb_type & D_FLD_MB) >> 7;
1816 uc_top_mb_fld = (ps_top_mb_params->u1_mb_type & D_FLD_MB) >> 7;
1817
1818 c_mv_limit = 4 >> uc_cur_mb_fld;
1819 if((0 == uc_cur_mb_fld) && (0 == uc_top_mb_fld))
1820 {
1821 ui_bs_table[0] = 0x04040404;
1822 }
1823 else
1824 {
1825 ui_bs_table[0] = 0x03030303;
1826 }
1827
1828 for(edge = 0; edge < 4;
1829 edge++, ps_top_mv_pred = ps_cur_mv_pred - 4, puc_top_nnz =
1830 puc_cur_nnz - 4)
1831 {
1832 //Each iteration of this loop fills the four BS values of one HORIZ edge and
1833 //one BS value for each of the four VERT edges.
1834 WORD8 i = 0;
1835 UWORD8 uc_bs_horiz, uc_bs_vert;
1836 UWORD32 ui_cnd;
1837 void *ui_ref_pic_addr[4];
1838 UWORD8 uc_mixed_mode_edge;
1839
1840 uc_mixed_mode_edge = 0;
1841
1842 uc_temp = (ui_mbAff << 4) + 13;
1843
1844 uc_cur_nnz = *(puc_cur_nnz - uc_temp);
1845 ps_left_mv_pred = ps_leftmost_mv_pred + (edge << 2);
1846
1847 for(i = 0; i < 4; i++, ps_top_mv_pred++, ps_cur_mv_pred++)
1848 {
1849 //Each iteration of this inner loop computes a HORIZ
1850 //and a VERT BS value for a 4x4 block
1851
1852 uc_left_nnz = uc_cur_nnz;
1853 uc_cur_nnz = *puc_cur_nnz++;
1854 uc_top_nnz = *puc_top_nnz++;
1855
1856 //VERT edge is assigned BS values first
1857 ui_cnd = !(uc_left_nnz || uc_cur_nnz);
1858 uc_bs_vert = 2;
1859
1860 if(ui_cnd)
1861 {
1862 i2_left_mv0 = ps_left_mv_pred->i2_mv[0];
1863 i2_left_mv1 = ps_left_mv_pred->i2_mv[1];
1864 i2_left_mv2 = ps_left_mv_pred->i2_mv[2];
1865 i2_left_mv3 = ps_left_mv_pred->i2_mv[3];
1866
1867 i2_cur_mv0 = ps_cur_mv_pred->i2_mv[0];
1868 i2_cur_mv1 = ps_cur_mv_pred->i2_mv[1];
1869 i16_curMv2 = ps_cur_mv_pred->i2_mv[2];
1870 i16_curMv3 = ps_cur_mv_pred->i2_mv[3];
1871 i1_cur_ref0 = ps_cur_mv_pred->i1_ref_frame[0];
1872 i1_cur_ref1 = ps_cur_mv_pred->i1_ref_frame[1];
1873 ui_ref_pic_addr[2] = ppv_map_ref_idx_to_poc_l0[i1_cur_ref0];
1874 ui_ref_pic_addr[3] = ppv_map_ref_idx_to_poc_l1[i1_cur_ref1];
1875
1876 if(i)
1877 {
1878 i1_left_ref0 = ps_left_mv_pred->i1_ref_frame[0];
1879 i1_left_ref1 = ps_left_mv_pred->i1_ref_frame[1];
1880 ui_ref_pic_addr[0] = ppv_map_ref_idx_to_poc_l0[i1_left_ref0];
1881 ui_ref_pic_addr[1] = ppv_map_ref_idx_to_poc_l1[i1_left_ref1];
1882 }
1883 else
1884 {
1885 ui_ref_pic_addr[0] = ps_left_addr->u4_add[edge & 2];
1886 ui_ref_pic_addr[1] = ps_left_addr->u4_add[1 + (edge & 2)];
1887 }
1888 if(!uc_Bslice)
1889 {
1890 uc_bs_vert =
1891 (ui_ref_pic_addr[0] != ui_ref_pic_addr[2])
1892 | (ABS((i2_left_mv0
1893 - i2_cur_mv0))
1894 >= 4)
1895 | (ABS((i2_left_mv1
1896 - i2_cur_mv1))
1897 >= (UWORD8)c_mv_limit);
1898 }
1899 else
1900 {
1901 UWORD8 uc_bs_temp1, uc_bs_temp2;
1902
1903 uc_bs_vert = 1;
1904
1905 uc_bs_temp1 =
1906 ((ABS((i2_left_mv0 - i2_cur_mv0))
1907 >= 4)
1908 | (ABS((i2_left_mv1
1909 - i2_cur_mv1))
1910 >= (UWORD8)c_mv_limit)
1911 | (ABS((i2_left_mv2
1912 - i16_curMv2))
1913 >= 4)
1914 | (ABS((i2_left_mv3
1915 - i16_curMv3))
1916 >= (UWORD8)c_mv_limit));
1917
1918 uc_bs_temp2 =
1919 ((ABS((i2_left_mv0 - i16_curMv2))
1920 >= 4)
1921 | (ABS((i2_left_mv1
1922 - i16_curMv3))
1923 >= (UWORD8)c_mv_limit)
1924 | (ABS((i2_left_mv2
1925 - i2_cur_mv0))
1926 >= 4)
1927 | (ABS((i2_left_mv3
1928 - i2_cur_mv1))
1929 >= (UWORD8)c_mv_limit));
1930
1931 uc_bs_vert =
1932 (((ui_ref_pic_addr[0] != ui_ref_pic_addr[2])
1933 || (ui_ref_pic_addr[1]
1934 != ui_ref_pic_addr[3]))
1935 || (uc_bs_temp1))
1936 && (((ui_ref_pic_addr[0]
1937 != ui_ref_pic_addr[3])
1938 || (ui_ref_pic_addr[1]
1939 != ui_ref_pic_addr[2]))
1940 || (uc_bs_temp2));
1941
1942 }
1943 }
1944 //Fill the VERT BS, only if valid i.e.,
1945 //if it is a non-edge OR it is an edge, which is not yet filled
1946 uc_bs_vert = (!i && u1_left_intra) ? 4 : uc_bs_vert;
1947 ui_bs_table[i + 4] = (ui_bs_table[i + 4] << 8) | uc_bs_vert;
1948
1949 //HORIZ edge is assigned BS values next
1950 ui_cnd = !(uc_top_nnz || uc_cur_nnz);
1951 uc_bs_horiz = 2;
1952
1953 if(ui_cnd)
1954 {
1955 uc_mixed_mode_edge =
1956 (0 == edge) ? (uc_top_mb_fld != uc_cur_mb_fld) : 0;
1957 ui_cnd = 1 - uc_mixed_mode_edge;
1958 uc_bs_horiz = uc_mixed_mode_edge;
1959 }
1960
1961 if(ui_cnd)
1962 {
1963 i2_cur_mv0 = ps_cur_mv_pred->i2_mv[0];
1964 i2_cur_mv1 = ps_cur_mv_pred->i2_mv[1];
1965 i16_curMv2 = ps_cur_mv_pred->i2_mv[2];
1966 i16_curMv3 = ps_cur_mv_pred->i2_mv[3];
1967 i1_cur_ref0 = ps_cur_mv_pred->i1_ref_frame[0];
1968 i1_cur_ref1 = ps_cur_mv_pred->i1_ref_frame[1];
1969
1970 i2_top_mv0 = ps_top_mv_pred->i2_mv[0];
1971 i2_top_mv1 = ps_top_mv_pred->i2_mv[1];
1972 i16_topMv2 = ps_top_mv_pred->i2_mv[2];
1973 i16_topMv3 = ps_top_mv_pred->i2_mv[3];
1974 ui_ref_pic_addr[2] = ppv_map_ref_idx_to_poc_l0[i1_cur_ref0];
1975 ui_ref_pic_addr[3] = ppv_map_ref_idx_to_poc_l1[i1_cur_ref1];
1976 if(edge)
1977 {
1978 i1_top_ref0 = ps_top_mv_pred->i1_ref_frame[0];
1979 i1_top_ref1 = ps_top_mv_pred->i1_ref_frame[1];
1980 ui_ref_pic_addr[0] = ppv_map_ref_idx_to_poc_l0[i1_top_ref0];
1981 ui_ref_pic_addr[1] = ppv_map_ref_idx_to_poc_l1[i1_top_ref1];
1982 }
1983 else
1984 {
1985 ui_ref_pic_addr[0] = ps_top_add->u4_add[i & 2];
1986 ui_ref_pic_addr[1] = ps_top_add->u4_add[1 + (i & 2)];
1987 }
1988 if(!uc_Bslice)
1989 {
1990 uc_bs_horiz =
1991 (ui_ref_pic_addr[0] != ui_ref_pic_addr[2])
1992 | (ABS((i2_top_mv0
1993 - i2_cur_mv0))
1994 >= 4)
1995 | (ABS((i2_top_mv1
1996 - i2_cur_mv1))
1997 >= (UWORD8)c_mv_limit);
1998 }
1999 else
2000 {
2001 UWORD8 uc_bs_temp1, uc_bs_temp2;
2002
2003 uc_bs_horiz = 1;
2004
2005 uc_bs_temp1 =
2006 ((ABS((i2_top_mv0 - i2_cur_mv0))
2007 >= 4)
2008 | (ABS((i2_top_mv1
2009 - i2_cur_mv1))
2010 >= (UWORD8)c_mv_limit)
2011 | (ABS((i16_topMv2
2012 - i16_curMv2))
2013 >= 4)
2014 | (ABS((i16_topMv3
2015 - i16_curMv3))
2016 >= (UWORD8)c_mv_limit));
2017
2018 uc_bs_temp2 =
2019 ((ABS((i2_top_mv0 - i16_curMv2))
2020 >= 4)
2021 | (ABS((i2_top_mv1
2022 - i16_curMv3))
2023 >= (UWORD8)c_mv_limit)
2024 | (ABS((i16_topMv2
2025 - i2_cur_mv0))
2026 >= 4)
2027 | (ABS((i16_topMv3
2028 - i2_cur_mv1))
2029 >= (UWORD8)c_mv_limit));
2030
2031 uc_bs_horiz =
2032 (((ui_ref_pic_addr[0] != ui_ref_pic_addr[2])
2033 || (ui_ref_pic_addr[1]
2034 != ui_ref_pic_addr[3]))
2035 || (uc_bs_temp1))
2036 && (((ui_ref_pic_addr[0]
2037 != ui_ref_pic_addr[3])
2038 || (ui_ref_pic_addr[1]
2039 != ui_ref_pic_addr[2]))
2040 || (uc_bs_temp2));
2041
2042 }
2043 }
2044 ps_left_mv_pred = ps_cur_mv_pred;
2045 u4_bs_horz = (u4_bs_horz << 8) + uc_bs_horiz;
2046 }
2047 //Fill the HORIZ BS, only if valid i.e.,
2048 //if it is a non-edge OR it is an edge, which is not yet filled
2049 if(edge || (!edge && !u1_top_intra))
2050 ui_bs_table[edge] = u4_bs_horz;
2051 }
2052}
2053
2054/*!
2055 **************************************************************************
2056 * \if Function name : ih264d_fill_bs_for_extra_left_edge \endif
2057 *
2058 * \brief
2059 * Fills the boundary strength (Bs), for the top extra edge. ock
2060 *
2061 * \return
2062 * Returns the packed boundary strength(Bs) MSB -> LSB Bs0|Bs1|Bs2|Bs3
2063 *
2064 **************************************************************************
2065 */
2066void ih264d_fill_bs_for_extra_left_edge(deblk_mb_t *ps_cur_deblk_mb,
2067 deblk_mb_t *ps_leftDeblkMb,
2068 UWORD8* puc_cur_nnz,
2069 UWORD8 uc_botMb)
2070{
2071 /* Set the Flag in uc_deblocking_mode variable of current MB*/
2072 /* for mixed mode edge*/
2073 ps_cur_deblk_mb->u1_single_call = 0;
2074
2075 if(ps_cur_deblk_mb->u1_mb_type & D_INTRA_MB)
2076 {
2077 ps_cur_deblk_mb->u4_bs_table[4] = 0x04040404;
2078 ps_cur_deblk_mb->u4_bs_table[9] = 0x04040404;
2079 }
2080 else if((ps_leftDeblkMb->u1_mb_type & D_INTRA_MB)
2081 && ((ps_leftDeblkMb + 1)->u1_mb_type & D_INTRA_MB))
2082 {
2083 ps_cur_deblk_mb->u4_bs_table[4] = 0x04040404;
2084 ps_cur_deblk_mb->u4_bs_table[9] = 0x04040404;
2085 }
2086 else
2087 {
2088 /* Get strengths of left MB edge */
2089 UWORD32 u4_bs;
2090 UWORD8 uc_Bs;
2091 WORD32 i;
2092 UWORD32 ui_curMbFld;
2093 UWORD8 *puc_left_nnz;
2094 UWORD32 ui_bs_left_edge[2];
2095
2096 ui_curMbFld = (ps_cur_deblk_mb->u1_mb_type & D_FLD_MB) >> 7;
2097
2098 puc_left_nnz = puc_cur_nnz - 29;
2099 if((ui_curMbFld == 0) && uc_botMb)
2100 {
2101 puc_left_nnz -= 8;
2102 }
2103 else if(ui_curMbFld && uc_botMb)
2104 {
2105 puc_left_nnz -= 16;
2106 }
2107
2108 if(ui_curMbFld)
2109 {
2110 if(ps_leftDeblkMb->u1_mb_type & D_INTRA_MB)
2111 {
2112 ui_bs_left_edge[0] = 0x04040404;
2113 puc_left_nnz += 16;
2114 puc_cur_nnz += 8;
2115 }
2116 else
2117 {
2118 u4_bs = 0;
2119 for(i = 4; i > 0; i--)
2120 {
2121 uc_Bs = ((*puc_cur_nnz || *puc_left_nnz)) ? 2 : 1;
2122 u4_bs = (u4_bs << 8) | uc_Bs;
2123 puc_left_nnz += 4;
2124 if(i & 0x01)
2125 puc_cur_nnz += 4;
2126 }
2127 ui_bs_left_edge[0] = u4_bs;
2128 }
2129
2130 if((ps_leftDeblkMb + 1)->u1_mb_type & D_INTRA_MB)
2131 {
2132 ui_bs_left_edge[1] = 0x04040404;
2133 }
2134 else
2135 {
2136 u4_bs = 0;
2137 for(i = 4; i > 0; i--)
2138 {
2139 uc_Bs = ((*puc_cur_nnz || *puc_left_nnz)) ? 2 : 1;
2140 u4_bs = (u4_bs << 8) | uc_Bs;
2141 puc_left_nnz += 4;
2142 if(i & 0x01)
2143 puc_cur_nnz += 4;
2144 }
2145 ui_bs_left_edge[1] = u4_bs;
2146 }
2147 }
2148 else
2149 {
2150 UWORD8 *puc_curNnzB, *puc_leftNnzB;
2151 puc_curNnzB = puc_cur_nnz;
2152 puc_leftNnzB = puc_left_nnz + 16;
2153 if(ps_leftDeblkMb->u1_mb_type & D_INTRA_MB)
2154 {
2155 ui_bs_left_edge[0] = 0x04040404;
2156 }
2157 else
2158 {
2159 u4_bs = 0;
2160 for(i = 4; i > 0; i--, puc_cur_nnz += 4)
2161 {
2162 uc_Bs = ((*puc_cur_nnz || *puc_left_nnz)) ? 2 : 1;
2163 u4_bs = (u4_bs << 8) | uc_Bs;
2164 if(i & 0x01)
2165 puc_left_nnz += 4;
2166 }
2167 ui_bs_left_edge[0] = u4_bs;
2168 }
2169
2170 if((ps_leftDeblkMb + 1)->u1_mb_type & D_INTRA_MB)
2171 {
2172 ui_bs_left_edge[1] = 0x04040404;
2173 }
2174 else
2175 {
2176 u4_bs = 0;
2177 for(i = 4; i > 0; i--, puc_curNnzB += 4)
2178 {
2179 uc_Bs = ((*puc_curNnzB || *puc_leftNnzB)) ? 2 : 1;
2180 u4_bs = (u4_bs << 8) | uc_Bs;
2181 if(i & 0x01)
2182 puc_leftNnzB += 4;
2183 }
2184 ui_bs_left_edge[1] = u4_bs;
2185 }
2186 }
2187 /* Copy The Values in Cur Deblk Mb Parameters */
2188 ps_cur_deblk_mb->u4_bs_table[4] = ui_bs_left_edge[0];
2189 ps_cur_deblk_mb->u4_bs_table[9] = ui_bs_left_edge[1];
2190 }
2191
2192}
2193
2194/*!
2195 **************************************************************************
2196 * \if Function name : ih264d_fill_bs_for_extra_top_edge \endif
2197 *
2198 * \brief
2199 * Fills the boundary strength (Bs), for the top extra edge. ock
2200 *
2201 * \return
2202 * Returns the packed boundary strength(Bs) MSB -> LSB Bs0|Bs1|Bs2|Bs3
2203 *
2204 **************************************************************************
2205 */
2206void ih264d_fill_bs_for_extra_top_edge(deblk_mb_t *ps_cur_mb_params,
2207 UWORD8 u1_Edge0_mb_typ,
2208 UWORD8 u1_Edge1_mb_typ,
2209 UWORD8 *pu1_curNnz,
2210 UWORD8 *pu1_topNnz)
2211{
2212 UWORD32 u4_bs;
2213 UWORD8 uc_Bs;
2214 WORD32 i;
2215 UWORD8 *pu1_cur_nnz_tmp;
2216 UWORD8 *pu1_top_nnz_tmp;
2217 UWORD8 u1_top_edge;
2218 UWORD8 u1_top_mb_type;
2219 for(u1_top_edge = 0; u1_top_edge < 2; u1_top_edge++)
2220 {
2221 u1_top_mb_type = u1_top_edge ? u1_Edge1_mb_typ : u1_Edge0_mb_typ;
2222 pu1_cur_nnz_tmp = pu1_curNnz;
2223 pu1_top_nnz_tmp = pu1_topNnz + (u1_top_edge << 2);
2224
2225 if((ps_cur_mb_params->u1_mb_type & D_INTRA_MB)
2226 + (u1_top_mb_type & D_INTRA_MB))
2227 {
2228 u4_bs = 0x03030303;
2229 }
2230 else
2231 {
2232 u4_bs = 0;
2233 for(i = 4; i > 0; i--, pu1_cur_nnz_tmp += 1, pu1_top_nnz_tmp += 1)
2234 {
2235 uc_Bs = ((*pu1_cur_nnz_tmp || *pu1_top_nnz_tmp)) ? 2 : 1;
2236 u4_bs = (u4_bs << 8) | uc_Bs;
2237 }
2238 }
2239 if(u1_top_edge)
2240 ps_cur_mb_params->u4_bs_table[0] = u4_bs;
2241 else
2242 ps_cur_mb_params->u4_bs_table[8] = u4_bs;
2243 }
2244}
2245
2246
2247void ih264d_fill_bs_mbedge_4(dec_struct_t * ps_dec,
2248 dec_mb_info_t * ps_cur_mb_info,
2249 const UWORD16 u2_mbxn_mb)
2250{
2251
2252 /* deblk_mb_t Params */
2253 deblk_mb_t *ps_cur_mb_params; /*< Parameters of current MacroBlock */
2254 deblkmb_neighbour_t *ps_deblk_top_mb;
2255 UWORD32 * pu4_bs_table;
2256 UWORD8 u1_cur_mb_type;
2257
2258 /* Neighbour availability */
2259 /* Initialization */
2260 const UWORD32 u2_mbx = ps_cur_mb_info->u2_mbx;
2261 const UWORD32 u2_mby = ps_cur_mb_info->u2_mby;
2262 const UWORD32 u1_pingpong = u2_mbx & 0x01;
2263 ps_deblk_top_mb = ps_dec->ps_deblk_top_mb + u2_mbx;
2264
2265
2266 /* Pointer assignment for Current DeblkMB, Current Mv Pred */
2267 ps_cur_mb_params = ps_dec->ps_deblk_mbn + u2_mbxn_mb;
2268
2269 u1_cur_mb_type = ps_cur_mb_params->u1_mb_type;
2270
2271 ps_deblk_top_mb->u1_mb_type = u1_cur_mb_type;
2272
2273 {
2274 UWORD8 mb_qp_temp;
2275
2276 ps_cur_mb_params->u1_topmb_qp = ps_deblk_top_mb->u1_mb_qp;
2277 ps_deblk_top_mb->u1_mb_qp = ps_cur_mb_params->u1_mb_qp;
2278
2279 ps_cur_mb_params->u1_left_mb_qp = ps_dec->deblk_left_mb[1].u1_mb_qp;
2280 ps_dec->deblk_left_mb[1].u1_mb_qp = ps_cur_mb_params->u1_mb_qp;
2281
2282 }
2283
2284 ps_cur_mb_params->u1_single_call = 1;
2285
2286 ps_dec->deblk_left_mb[1].u1_mb_type = ps_cur_mb_params->u1_mb_type;
2287 /* if no deblocking required for current Mb then continue */
2288 /* Check next Mbs in Mb group */
2289 if(ps_cur_mb_params->u1_deblocking_mode & MB_DISABLE_FILTERING)
2290 {
2291 /* Storing the leftMbtype for next Mb */
2292 return;
2293 }
2294
2295 /* Compute BS function */
2296 pu4_bs_table = ps_cur_mb_params->u4_bs_table;
2297
2298 pu4_bs_table[4] = 0x04040404;
2299 pu4_bs_table[0] = 0x04040404;
2300 pu4_bs_table[1] = 0;
2301 pu4_bs_table[2] = 0;
2302 pu4_bs_table[3] = 0;
2303 pu4_bs_table[5] = 0;
2304 pu4_bs_table[6] = 0;
2305 pu4_bs_table[7] = 0;
2306
2307}
2308
2309void ih264d_fill_bs_mbedge_2(dec_struct_t * ps_dec,
2310 dec_mb_info_t * ps_cur_mb_info,
2311 const UWORD16 u2_mbxn_mb)
2312{
2313
2314 /* deblk_mb_t Params */
2315 deblk_mb_t *ps_cur_mb_params; /*< Parameters of current MacroBlock */
2316 deblkmb_neighbour_t *ps_deblk_top_mb;
2317 UWORD32 * pu4_bs_table;
2318 UWORD8 u1_cur_mb_type;
2319
2320 /* Neighbour availability */
2321 /* Initialization */
2322 const UWORD32 u2_mbx = ps_cur_mb_info->u2_mbx;
2323 const UWORD32 u2_mby = ps_cur_mb_info->u2_mby;
2324 const UWORD32 u1_pingpong = u2_mbx & 0x01;
2325 ps_deblk_top_mb = ps_dec->ps_deblk_top_mb + u2_mbx;
2326
2327
2328 /* Pointer assignment for Current DeblkMB, Current Mv Pred */
2329 ps_cur_mb_params = ps_dec->ps_deblk_mbn + u2_mbxn_mb;
2330
2331 u1_cur_mb_type = ps_cur_mb_params->u1_mb_type;
2332
2333 ps_deblk_top_mb->u1_mb_type = u1_cur_mb_type;
2334
2335 {
2336 UWORD8 mb_qp_temp;
2337
2338 ps_cur_mb_params->u1_topmb_qp = ps_deblk_top_mb->u1_mb_qp;
2339 ps_deblk_top_mb->u1_mb_qp = ps_cur_mb_params->u1_mb_qp;
2340
2341 ps_cur_mb_params->u1_left_mb_qp = ps_dec->deblk_left_mb[1].u1_mb_qp;
2342 ps_dec->deblk_left_mb[1].u1_mb_qp = ps_cur_mb_params->u1_mb_qp;
2343
2344 }
2345
2346 ps_cur_mb_params->u1_single_call = 1;
2347
2348 ps_dec->deblk_left_mb[1].u1_mb_type = ps_cur_mb_params->u1_mb_type;
2349 /* if no deblocking required for current Mb then continue */
2350 /* Check next Mbs in Mb group */
2351 if(ps_cur_mb_params->u1_deblocking_mode & MB_DISABLE_FILTERING)
2352 {
2353 /* Storing the leftMbtype for next Mb */
2354 return;
2355 }
2356
2357 /* Compute BS function */
2358 pu4_bs_table = ps_cur_mb_params->u4_bs_table;
2359
2360 {
2361 UWORD32 top_mb_csbp, left_mb_csbp, cur_mb_csbp;
2362 UWORD32 top_edge, left_edge;
2363
2364 top_mb_csbp = ps_cur_mb_info->ps_top_mb->u2_luma_csbp;
2365 left_mb_csbp = ps_cur_mb_info->ps_left_mb->u2_luma_csbp;
2366 cur_mb_csbp = ps_cur_mb_info->ps_curmb->u2_luma_csbp;
2367
2368 top_mb_csbp = top_mb_csbp >> 12;
2369 top_edge = top_mb_csbp | (cur_mb_csbp & 0xf);
2370
2371 if(top_edge)
2372 pu4_bs_table[0] = 0x02020202;
2373 else
2374 pu4_bs_table[0] = 0;
2375
2376 cur_mb_csbp = cur_mb_csbp & CSBP_LEFT_BLOCK_MASK;
2377 left_mb_csbp = left_mb_csbp & CSBP_RIGHT_BLOCK_MASK;
2378
2379 left_edge = cur_mb_csbp | left_mb_csbp;
2380
2381 if(left_edge)
2382 pu4_bs_table[4] = 0x02020202;
2383 else
2384 pu4_bs_table[4] = 0;
2385
2386 pu4_bs_table[1] = 0;
2387 pu4_bs_table[2] = 0;
2388 pu4_bs_table[3] = 0;
2389 pu4_bs_table[5] = 0;
2390 pu4_bs_table[6] = 0;
2391 pu4_bs_table[7] = 0;
2392 }
2393
2394}