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 ih264d_process_bslice.c
23 *
24 * \brief
25 * Contains routines that decode B slice type
26 *
27 * Detailed_description
28 *
29 * \date
30 * 21/12/2002
31 *
32 * \author NS
33 **************************************************************************
34 */
35 #include "ih264_typedefs.h"
36 #include "ih264_macros.h"
37 #include "ih264_platform_macros.h"
38
39 #include <string.h>
40 #include "ih264d_structs.h"
41 #include "ih264d_bitstrm.h"
42 #include "ih264d_parse_cavlc.h"
43 #include "ih264d_mb_utils.h"
44 #include "ih264d_mvpred.h"
45 #include "ih264d_inter_pred.h"
46 #include "ih264d_process_pslice.h"
47 #include "ih264d_error_handler.h"
48 #include "ih264d_tables.h"
49 #include "ih264d_parse_slice.h"
50 #include "ih264d_process_pslice.h"
51 #include "ih264d_process_bslice.h"
52 #include "ih264d_tables.h"
53 #include "ih264d_parse_islice.h"
54 #include "ih264d_mvpred.h"
55
56 void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec);
57 //UWORD32 g_hits = 0;
58 //UWORD32 g_miss = 0;
59 /*!
60 **************************************************************************
61 * \if Function name : ih264d_decode_spatial_direct \endif
62 *
63 * \brief
64 * Decodes spatial direct mode.
65 *
66 * \return
67 * None.
68 * Arunoday T
69 **************************************************************************
70 */
ih264d_decode_spatial_direct(dec_struct_t * ps_dec,UWORD8 u1_wd_x,dec_mb_info_t * ps_cur_mb_info,UWORD8 u1_mb_num)71 WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
72 UWORD8 u1_wd_x,
73 dec_mb_info_t * ps_cur_mb_info,
74 UWORD8 u1_mb_num)
75 {
76 mv_pred_t s_mv_pred, *ps_mv;
77 UWORD8 u1_col_zero_flag, u1_sub_mb_num, u1_direct_zero_pred_flag = 0;
78 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
79 mv_pred_t *ps_mv_ntop_start;
80 mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
81 UWORD8 partition_size, sub_partition, u1_mb_partw, u1_mb_parth;
82 UWORD8 i;
83 WORD8 i1_pred, i1_ref_frame0, i1_ref_frame1;
84 struct pic_buffer_t *ps_ref_frame = NULL, *ps_col_pic, *ps_pic_buff0 = NULL,
85 *ps_pic_buff1 = NULL;
86
87 UWORD8 u1_zero_pred_cond_f, u1_zero_pred_cond_b;
88 WORD16 i2_def_mv[2], i2_spat_pred_mv[4], *pi2_final_mv0, *pi2_final_mv1;
89 UWORD16 ui2_mask_fwd = 0, ui2_mask_bwd = 0, u2_mask = 0;
90 UWORD32 *pui32_weight_ofsts = NULL;
91 directmv_t s_mvdirect;
92 UWORD8 u1_colz;
93 UWORD8 u1_final_ref_idx = 0;
94 const UWORD8 *pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
95 const UWORD8 *pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw;
96 const UWORD16 sub_mask_table[] =
97 { 0x33, 0x3, 0x11, 0x1 };
98 const UWORD16 mask_table[] =
99 { 0xffff, /*16x16 NA */
100 0xff, /* 16x8*/
101 0x3333, /* 8x16*/
102 0x33 };/* 8x8*/
103 mv_pred_t s_temp_mv_pred;
104 WORD32 ret = 0;
105
106 /* CHANGED CODE */
107 ps_mv_ntop_start = ps_dec->ps_mv_cur + (u1_mb_num << 4)
108 - (ps_dec->u2_frm_wd_in_mbs << (4 + u1_mbaff)) + 12;
109
110 /* assign default values for MotionVector as zero */
111 i2_def_mv[0] = 0;
112 i2_def_mv[1] = 0;
113
114 u1_direct_zero_pred_flag = ps_dec->pf_mvpred(ps_dec, ps_cur_mb_info, ps_mv_nmb_start,
115 ps_mv_ntop_start, &s_mv_pred, 0, 4,
116 0, 1, B_DIRECT_SPATIAL);
117
118 i2_spat_pred_mv[0] = s_mv_pred.i2_mv[0];
119 i2_spat_pred_mv[1] = s_mv_pred.i2_mv[1];
120 i2_spat_pred_mv[2] = s_mv_pred.i2_mv[2];
121 i2_spat_pred_mv[3] = s_mv_pred.i2_mv[3];
122
123 i1_ref_frame0 = s_mv_pred.i1_ref_frame[0];
124 i1_ref_frame1 = s_mv_pred.i1_ref_frame[1];
125
126 i1_ref_frame0 = (i1_ref_frame0 < 0) ? -1 : i1_ref_frame0;
127 i1_ref_frame1 = (i1_ref_frame1 < 0) ? -1 : i1_ref_frame1;
128
129 i1_pred = 0;
130
131 {
132 WORD8 u1_ref_idx, u1_ref_idx1;
133 UWORD32 uc_Idx, uc_Idx1;
134 UWORD8 u1_scale_ref = (ps_dec->ps_cur_slice->u1_mbaff_frame_flag
135 && ps_cur_mb_info->u1_mb_field_decodingflag);
136 u1_final_ref_idx = i1_ref_frame0;
137 if(i1_ref_frame0 >= 0)
138 {
139 /* convert RefIdx if it is MbAff */
140 u1_ref_idx = i1_ref_frame0;
141 u1_ref_idx1 = i1_ref_frame0;
142 if(u1_scale_ref)
143 {
144 u1_ref_idx1 = u1_ref_idx >> 1;
145 if((u1_ref_idx & 0x01) != (1 - ps_cur_mb_info->u1_topmb))
146 u1_ref_idx1 += MAX_REF_BUFS;
147 }
148 /* If i1_ref_frame0 < 0 then refIdxCol is obtained from ps_pic_buff1 */
149 ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][u1_ref_idx1];
150 ps_ref_frame = ps_pic_buff0;
151 i1_pred = PRED_L0;
152 }
153
154 if(i1_ref_frame1 >= 0)
155 {
156 /* convert RefIdx if it is MbAff */
157 u1_ref_idx = i1_ref_frame1;
158 u1_ref_idx1 = i1_ref_frame1;
159 if(u1_scale_ref)
160 {
161 u1_ref_idx1 = u1_ref_idx >> 1;
162 if((u1_ref_idx & 0x01) != (1 - ps_cur_mb_info->u1_topmb))
163 u1_ref_idx1 += MAX_REF_BUFS;
164 }
165 ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][u1_ref_idx1];
166 i1_pred = i1_pred | PRED_L1;
167 }
168 if(i1_ref_frame0 < 0)
169 {
170 ps_ref_frame = ps_pic_buff1;
171 u1_final_ref_idx = i1_ref_frame1;
172 }
173
174 u1_zero_pred_cond_f = (u1_direct_zero_pred_flag) || (i1_ref_frame0 < 0);
175 u1_zero_pred_cond_b = (u1_direct_zero_pred_flag) || (i1_ref_frame1 < 0);
176
177 if(ps_dec->ps_cur_pps->u1_wted_bipred_idc)
178 {
179 uc_Idx = ((i1_ref_frame0 < 1) ? 0 : i1_ref_frame0)
180 * ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1];
181 if(u1_scale_ref)
182 uc_Idx >>= 1;
183 uc_Idx1 = (i1_ref_frame1 < 0) ? 0 : i1_ref_frame1;
184 uc_Idx += (u1_scale_ref) ? (uc_Idx1 >> 1) : uc_Idx1;
185 pui32_weight_ofsts =
186 (UWORD32*)&ps_dec->pu4_wt_ofsts[2 * X3(uc_Idx)];
187
188 if(i1_ref_frame0 < 0)
189 pui32_weight_ofsts += 1;
190
191 if(u1_scale_ref && (ps_dec->ps_cur_pps->u1_wted_bipred_idc == 2))
192 {
193 WORD16 i2_ref_idx;
194 i2_ref_idx = MAX(i1_ref_frame0, 0);
195 i2_ref_idx *= (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1]
196 << 1);
197 i2_ref_idx += MAX(i1_ref_frame1, 0);
198 if(!ps_cur_mb_info->u1_topmb)
199 i2_ref_idx +=
200 (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0]
201 << 1)
202 * (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1]
203 << 1);
204 pui32_weight_ofsts = (UWORD32*)&ps_dec->pu4_mbaff_wt_mat[2
205 * X3(i2_ref_idx)];
206 }
207 }
208 }
209
210 s_temp_mv_pred.i1_ref_frame[0] = i1_ref_frame0;
211 s_temp_mv_pred.i1_ref_frame[1] = i1_ref_frame1;
212 s_temp_mv_pred.u1_col_ref_pic_idx = ps_ref_frame->u1_mv_buf_id;
213 s_temp_mv_pred.u1_pic_type = ps_ref_frame->u1_pic_type;
214
215 /**********************************************************************/
216 /* Call the function which gets the number of partitions and */
217 /* partition info of colocated Mb */
218 /**********************************************************************/
219
220 ps_dec->pf_parse_mvdirect(ps_dec, ps_dec->ps_col_pic, &s_mvdirect, u1_wd_x,
221 ps_dec->i4_submb_ofst, ps_cur_mb_info);
222 ps_col_pic = ps_dec->ps_col_pic;
223 if((s_mvdirect.u1_col_zeroflag_change == 0) || u1_direct_zero_pred_flag)
224 {
225 WORD16 i2_mv_x, i2_mv_y, i2_mvX1, i2_mvY1;
226 /* Most probable case */
227 u1_col_zero_flag = *(ps_col_pic->pu1_col_zero_flag
228 + s_mvdirect.i4_mv_indices[0]);
229 u1_col_zero_flag = u1_col_zero_flag & 0x01;
230
231 if(u1_zero_pred_cond_f || ((i1_ref_frame0 == 0) && (u1_col_zero_flag == 1)))
232 {
233 i2_mv_x = 0;
234 i2_mv_y = 0;
235 }
236 else
237 {
238 i2_mv_x = i2_spat_pred_mv[0];
239 i2_mv_y = i2_spat_pred_mv[1];
240
241 }
242
243 if(u1_zero_pred_cond_b || ((i1_ref_frame1 == 0) && (u1_col_zero_flag == 1)))
244 {
245 i2_mvX1 = 0;
246 i2_mvY1 = 0;
247 }
248 else
249 {
250 i2_mvX1 = i2_spat_pred_mv[2];
251 i2_mvY1 = i2_spat_pred_mv[3];
252 }
253
254 u1_sub_mb_num = ps_dec->u1_sub_mb_num;
255 u1_mb_partw = (u1_wd_x >> 2);
256
257
258 if(i1_ref_frame0 >= 0)
259 {
260 {
261 pred_info_pkd_t *ps_pred_pkd;
262 WORD16 i2_mv[2];
263 WORD8 i1_ref_idx= 0;
264
265 i2_mv[0] = i2_mv_x;
266 i2_mv[1] = i2_mv_y;
267
268 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
269 ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u1_sub_mb_num,i1_pred,
270 ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
271 ps_pic_buff0->u1_pic_type);
272 ps_dec->u4_pred_info_pkd_idx++;
273 ps_cur_mb_info->u1_num_pred_parts++;
274
275
276 }
277
278 }
279
280 if(i1_ref_frame1 >= 0)
281 {
282 {
283 pred_info_pkd_t *ps_pred_pkd;
284 WORD16 i2_mv[2];
285 WORD8 i1_ref_idx= 0;
286
287 i2_mv[0] = i2_mvX1;
288 i2_mv[1] = i2_mvY1;
289
290 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
291 ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u1_sub_mb_num,i1_pred,
292 ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
293 ps_pic_buff1->u1_pic_type);
294 ps_dec->u4_pred_info_pkd_idx++;
295 ps_cur_mb_info->u1_num_pred_parts++;
296
297
298 }
299 }
300
301
302 /* Replication optimisation */
303 s_temp_mv_pred.i2_mv[0] = i2_mv_x;
304 s_temp_mv_pred.i2_mv[1] = i2_mv_y;
305 s_temp_mv_pred.i2_mv[2] = i2_mvX1;
306 s_temp_mv_pred.i2_mv[3] = i2_mvY1;
307
308 /* Calculating colocated zero information */
309 {
310 /*************************************/
311 /* If(bit2 and bit3 set) */
312 /* then */
313 /* (bit0 and bit1) => submmbmode */
314 /* (bit2 and bit3) => mbmode */
315 /* else */
316 /* (bit0 and bit1) => mbmode */
317 /*************************************/
318 /*UWORD8 u1_packed_mb_sub_mb_mode = sub_partition ?
319 (s_mvdirect.i1_partitionsize[0]) : ((s_mvdirect.i1_partitionsize[0]) << 2);*/
320 UWORD8 u1_packed_mb_sub_mb_mode = (u1_mb_partw == 2) ? 0x03 : 0;
321
322 if(i1_ref_frame0 < 0)
323 {
324 i2_mv_x = i2_mvX1;
325 i2_mv_y = i2_mvY1;
326 }
327
328 /* Change from left shift 4 to 6 - Varun */
329 u1_colz = (ps_cur_mb_info->u1_mb_field_decodingflag << 1)
330 | ((u1_final_ref_idx == 0) && (ABS(i2_mv_x) <= 1)
331 && (ABS(i2_mv_y) <= 1));
332 u1_colz |= (u1_packed_mb_sub_mb_mode << 6);
333 }
334 ps_mv = ps_mv_nmb_start + u1_sub_mb_num;
335 ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz,
336 u1_mb_partw, u1_mb_partw);
337 if(u1_wd_x == MB_SIZE)
338 ps_dec->u1_currB_type = 0;
339
340
341
342 return OK;
343 }
344 /***************************************************************************/
345 /* If present MB is 16x16 and the partition of colocated Mb is >= PRED_8x8 */
346 /* i.e 8x8 or less than 8x8 partitions then set up DMA for (0,0) and */
347 /* spatially predicted motion vector and do the multiplexing after */
348 /* motion compensation */
349 /***************************************************************************/
350
351
352 if((u1_wd_x == MB_SIZE) && (s_mvdirect.i1_num_partitions > 2))
353 {
354 ps_cur_mb_info->u1_Mux = 1;
355 if(i1_ref_frame0 >= 0)
356 {
357
358 {
359 pred_info_pkd_t *ps_pred_pkd;
360 WORD8 i1_ref_idx= 0;
361
362 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
363 ih264d_fill_pred_info(&(i2_spat_pred_mv[0]),4,4,0,i1_pred,
364 ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
365 ps_pic_buff0->u1_pic_type);
366 ps_dec->u4_pred_info_pkd_idx++;
367 ps_cur_mb_info->u1_num_pred_parts++;
368
369
370 }
371
372 /****** (0,0) Motion vectors DMA *****/
373 {
374 pred_info_pkd_t *ps_pred_pkd;
375 WORD16 i2_mv[2];
376 WORD8 i1_ref_idx= 0;
377
378 i2_mv[0] = 0;
379 i2_mv[1] = 0;
380
381 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
382 ih264d_fill_pred_info(i2_mv,4,4,0,i1_pred,
383 ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
384 ps_pic_buff0->u1_pic_type);
385 ps_dec->u4_pred_info_pkd_idx++;
386 ps_cur_mb_info->u1_num_pred_parts++;
387
388
389 }
390 }
391 if(i1_ref_frame1 >= 0)
392 {
393 {
394 pred_info_pkd_t *ps_pred_pkd;
395 WORD16 i2_mv[2];
396 WORD8 i1_ref_idx= 0;
397
398 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
399 ih264d_fill_pred_info(&(i2_spat_pred_mv[2]),4,4,0,i1_pred,
400 ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
401 ps_pic_buff1->u1_pic_type);
402 ps_dec->u4_pred_info_pkd_idx++;
403 ps_cur_mb_info->u1_num_pred_parts++;
404
405
406 }
407
408 /****** (0,0) Motion vectors DMA *****/
409
410 {
411 pred_info_pkd_t *ps_pred_pkd;
412 WORD16 i2_mv[2];
413 WORD8 i1_ref_idx= 0;
414
415 i2_mv[0] = 0;
416 i2_mv[1] = 0;
417
418 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
419 ih264d_fill_pred_info(i2_mv,4,4,0,i1_pred,
420 ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
421 ps_pic_buff1->u1_pic_type);
422 ps_dec->u4_pred_info_pkd_idx++;
423 ps_cur_mb_info->u1_num_pred_parts++;
424
425
426 }
427 }
428 }
429
430 /*u1_col = *(ps_col_pic->pu1_col_zero_flag + s_mvdirect.i4_mv_indices[0]);
431 u1_col &= 1;
432 u1_init = 0;*/
433
434 for(i = 0; i < s_mvdirect.i1_num_partitions; i++)
435 {
436 partition_size = s_mvdirect.i1_partitionsize[i];
437 u1_sub_mb_num = s_mvdirect.i1_submb_num[i];
438
439 sub_partition = partition_size >> 2;
440 partition_size &= 0x3;
441 u1_mb_partw = pu1_mb_partw[partition_size];
442 u1_mb_parth = pu1_mb_parth[partition_size];
443 u2_mask = mask_table[partition_size];
444 if(sub_partition != 0)
445 {
446 u1_mb_partw >>= 1;
447 u1_mb_parth >>= 1;
448 u2_mask = sub_mask_table[partition_size];
449 }
450
451 u1_col_zero_flag = *(ps_col_pic->pu1_col_zero_flag
452 + s_mvdirect.i4_mv_indices[i]);
453 u1_col_zero_flag = u1_col_zero_flag & 0x01;
454
455 /*if(u1_col != u1_col_zero_flag)
456 u1_init = 1;*/
457
458 if(u1_zero_pred_cond_f || ((i1_ref_frame0 == 0) && (u1_col_zero_flag == 1)))
459 {
460 pi2_final_mv0 = &i2_def_mv[0];
461 ui2_mask_fwd |= (u2_mask << u1_sub_mb_num);
462 }
463 else
464 pi2_final_mv0 = &i2_spat_pred_mv[0];
465
466 if(u1_zero_pred_cond_b || ((i1_ref_frame1 == 0) && (u1_col_zero_flag == 1)))
467 {
468 pi2_final_mv1 = &i2_def_mv[0];
469 ui2_mask_bwd |= (u2_mask << u1_sub_mb_num);
470 }
471 else
472 pi2_final_mv1 = &i2_spat_pred_mv[2];
473
474 if(ps_cur_mb_info->u1_Mux != 1)
475 {
476 /*u1_sub_mb_x = u1_sub_mb_num & 0x03;
477 uc_sub_mb_y = (u1_sub_mb_num >> 2);*/
478 if(i1_ref_frame0 >= 0)
479 {
480
481 {
482 pred_info_pkd_t *ps_pred_pkd;
483 WORD8 i1_ref_idx= 0;
484
485 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
486 ih264d_fill_pred_info(pi2_final_mv0,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,i1_pred,
487 ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
488 ps_pic_buff0->u1_pic_type);
489 ps_dec->u4_pred_info_pkd_idx++;
490 ps_cur_mb_info->u1_num_pred_parts++;
491
492
493 }
494
495 }
496
497 if(i1_ref_frame1 >= 0)
498 {
499 {
500 pred_info_pkd_t *ps_pred_pkd;
501 WORD8 i1_ref_idx= 0;
502
503 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
504 ih264d_fill_pred_info(pi2_final_mv1,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,i1_pred,
505 ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
506 ps_pic_buff1->u1_pic_type);
507 ps_dec->u4_pred_info_pkd_idx++;
508 ps_cur_mb_info->u1_num_pred_parts++;
509
510
511 }
512 }
513 }
514
515 /* Replication optimisation */
516 s_temp_mv_pred.i2_mv[0] = pi2_final_mv0[0];
517 s_temp_mv_pred.i2_mv[1] = pi2_final_mv0[1];
518 s_temp_mv_pred.i2_mv[2] = pi2_final_mv1[0];
519 s_temp_mv_pred.i2_mv[3] = pi2_final_mv1[1];
520
521 /* Calculating colocated zero information */
522 {
523 WORD16 i2_mv_x = 0, i2_mv_y = 0;
524 /*************************************/
525 /* If(bit2 and bit3 set) */
526 /* then */
527 /* (bit0 and bit1) => submmbmode */
528 /* (bit2 and bit3) => mbmode */
529 /* else */
530 /* (bit0 and bit1) => mbmode */
531 /*************************************/
532 UWORD8 u1_packed_mb_sub_mb_mode =
533 sub_partition ? (s_mvdirect.i1_partitionsize[i]) : ((s_mvdirect.i1_partitionsize[i])
534 << 2);
535
536 if(i1_ref_frame0 >= 0)
537 {
538 i2_mv_x = pi2_final_mv0[0];
539 i2_mv_y = pi2_final_mv0[1];
540 }
541 else
542 {
543 i2_mv_x = pi2_final_mv1[0];
544 i2_mv_y = pi2_final_mv1[1];
545 }
546
547 u1_colz = (ps_cur_mb_info->u1_mb_field_decodingflag << 1)
548 | ((u1_final_ref_idx == 0) && (ABS(i2_mv_x) <= 1)
549 && (ABS(i2_mv_y) <= 1));
550 u1_colz |= (u1_packed_mb_sub_mb_mode << 4);
551 }
552 ps_mv = ps_mv_nmb_start + u1_sub_mb_num;
553 ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz,
554 u1_mb_parth, u1_mb_partw);
555 }
556 i = 0;
557 if(i1_ref_frame0 >= 0)
558 ps_cur_mb_info->u2_mask[i++] = ui2_mask_fwd;
559 if(i1_ref_frame1 >= 0)
560 ps_cur_mb_info->u2_mask[i] = ui2_mask_bwd;
561
562 /*if(u1_init)
563 H264_DEC_DEBUG_PRINT("hit\n");
564 else
565 H264_DEC_DEBUG_PRINT("miss\n");*/
566
567 return OK;
568 }
569
570 /*!
571 **************************************************************************
572 * \if Function name : ih264d_decode_temporal_direct \endif
573 *
574 * \brief
575 * Decodes temporal direct mode.
576 *
577 * \return
578 * None.
579 *
580 **************************************************************************
581 */
ih264d_decode_temporal_direct(dec_struct_t * ps_dec,UWORD8 u1_wd_x,dec_mb_info_t * ps_cur_mb_info,UWORD8 u1_mb_num)582 WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
583 UWORD8 u1_wd_x,
584 dec_mb_info_t * ps_cur_mb_info,
585 UWORD8 u1_mb_num)
586 {
587 struct pic_buffer_t *ps_pic_buff0, *ps_pic_buff1, *ps_col_pic;
588 mv_pred_t *ps_mv, s_temp_mv_pred;
589 UWORD8 u1_sub_mb_num;
590 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
591 WORD16 i2_mv_x0, i2_mv_y0, i2_mv_x1, i2_mv_y1;
592 UWORD8 u1_mb_partw, u1_mb_parth;
593 UWORD8 i, partition_size, sub_partition;
594 UWORD32 *pui32_weight_ofsts = NULL;
595 directmv_t s_mvdirect;
596 const UWORD8 *pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
597 const UWORD8 *pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw;
598 WORD8 c_refFrm0, c_refFrm1;
599 UWORD8 u1_ref_idx0, u1_is_cur_mb_fld;
600 WORD32 pic0_poc, pic1_poc, cur_poc;
601 WORD32 ret = 0;
602
603 u1_is_cur_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag;
604 ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][0];
605
606 /**********************************************************************/
607 /* Call the function which gets the number of partitions and */
608 /* partition info of colocated Mb */
609 /**********************************************************************/
610 ps_dec->pf_parse_mvdirect(ps_dec, ps_dec->ps_col_pic, &s_mvdirect, u1_wd_x,
611 ps_dec->i4_submb_ofst, ps_cur_mb_info);
612 ps_col_pic = ps_dec->ps_col_pic;
613
614 for(i = 0; i < s_mvdirect.i1_num_partitions; i++)
615 {
616 UWORD8 u1_colz;
617 partition_size = s_mvdirect.i1_partitionsize[i];
618 u1_sub_mb_num = s_mvdirect.i1_submb_num[i];
619 ps_mv = ps_col_pic->ps_mv + s_mvdirect.i4_mv_indices[i];
620
621 /* This should be removed to catch unitialized memory read */
622 u1_ref_idx0 = 0;
623
624 sub_partition = partition_size >> 2;
625 partition_size &= 0x3;
626 u1_mb_partw = pu1_mb_partw[partition_size];
627 u1_mb_parth = pu1_mb_parth[partition_size];
628 if(sub_partition != 0)
629 {
630 u1_mb_partw >>= 1;
631 u1_mb_parth >>= 1;
632 }
633 c_refFrm0 = ps_mv->i1_ref_frame[0];
634 c_refFrm1 = ps_mv->i1_ref_frame[1];
635
636 if((c_refFrm0 == -1) && (c_refFrm1 == -1))
637 {
638 u1_ref_idx0 = 0;
639 ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][0];
640 if(u1_mbaff && u1_is_cur_mb_fld)
641 {
642 if(ps_cur_mb_info->u1_topmb)
643 {
644 pic0_poc = ps_pic_buff0->i4_top_field_order_cnt;
645 pic1_poc = ps_pic_buff1->i4_top_field_order_cnt;
646 cur_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
647 }
648 else
649 {
650 pic1_poc = ps_pic_buff1->i4_bottom_field_order_cnt;
651 cur_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
652 ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][MAX_REF_BUFS];
653 pic0_poc = ps_pic_buff0->i4_bottom_field_order_cnt;
654 ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][MAX_REF_BUFS];
655 }
656 }
657 else
658 {
659 pic0_poc = ps_pic_buff0->i4_avg_poc;
660 pic1_poc = ps_pic_buff1->i4_avg_poc;
661 cur_poc = ps_dec->ps_cur_pic->i4_poc;
662 }
663 }
664 else
665 {
666 UWORD8 uc_i, u1_num_frw_ref_pics;
667 UWORD8 buf_id, u1_pic_type;
668 buf_id = ps_mv->u1_col_ref_pic_idx;
669 u1_pic_type = ps_mv->u1_pic_type;
670 if(ps_dec->ps_cur_slice->u1_field_pic_flag)
671 {
672 if(s_mvdirect.u1_vert_mv_scale == FRM_TO_FLD)
673 {
674 u1_pic_type = TOP_FLD;
675 if(ps_dec->ps_cur_slice->u1_bottom_field_flag)
676 u1_pic_type = BOT_FLD;
677 }
678 }
679 u1_num_frw_ref_pics =
680 ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0];
681
682 for(uc_i = 0; uc_i < u1_num_frw_ref_pics; uc_i++)
683 {
684 if(ps_dec->ps_cur_slice->u1_field_pic_flag)
685 {
686 if(ps_dec->ps_ref_pic_buf_lx[0][uc_i]->u1_mv_buf_id == buf_id)
687 {
688 if(ps_dec->ps_ref_pic_buf_lx[0][uc_i]->u1_pic_type
689 == u1_pic_type)
690 {
691 u1_ref_idx0 = uc_i;
692 break;
693 }
694 }
695 }
696 else
697 {
698 if(ps_dec->ps_ref_pic_buf_lx[0][uc_i]->u1_mv_buf_id == buf_id)
699 {
700 u1_ref_idx0 = uc_i;
701 break;
702 }
703 }
704 }
705
706 ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][u1_ref_idx0];
707 ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][0];
708
709 if(u1_mbaff && u1_is_cur_mb_fld)
710 {
711 pic0_poc = ps_pic_buff0->i4_top_field_order_cnt;
712 u1_ref_idx0 <<= 1;
713 if(s_mvdirect.u1_vert_mv_scale == ONE_TO_ONE)
714 {
715 if(u1_pic_type == BOT_FLD)
716 {
717 pic0_poc = ps_pic_buff0->i4_bottom_field_order_cnt;
718 ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][(u1_ref_idx0
719 >> 1) + MAX_REF_BUFS];
720 if(ps_cur_mb_info->u1_topmb)
721 u1_ref_idx0++;
722 }
723 else
724 {
725 if(1 - ps_cur_mb_info->u1_topmb)
726 u1_ref_idx0++;
727 }
728 }
729 if(s_mvdirect.u1_vert_mv_scale == FRM_TO_FLD)
730 {
731 if(1 - ps_cur_mb_info->u1_topmb)
732 {
733 pic0_poc = ps_pic_buff0->i4_bottom_field_order_cnt;
734 ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][(u1_ref_idx0
735 >> 1) + MAX_REF_BUFS];
736 }
737 }
738 if(ps_cur_mb_info->u1_topmb)
739 {
740 pic1_poc = ps_pic_buff1->i4_top_field_order_cnt;
741 cur_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
742 }
743 else
744 {
745 pic1_poc = ps_pic_buff1->i4_bottom_field_order_cnt;
746 cur_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
747 ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][MAX_REF_BUFS];
748 }
749 }
750 else
751 {
752 pic0_poc = ps_pic_buff0->i4_avg_poc;
753 pic1_poc = ps_pic_buff1->i4_avg_poc;
754 cur_poc = ps_dec->ps_cur_pic->i4_poc;
755 }
756 }
757 {
758 WORD16 i16_td;
759 WORD64 diff;
760 if(c_refFrm0 >= 0)
761 {
762 i2_mv_x0 = ps_mv->i2_mv[0];
763 i2_mv_y0 = ps_mv->i2_mv[1];
764 }
765 else if(c_refFrm1 >= 0)
766 {
767 i2_mv_x0 = ps_mv->i2_mv[2];
768 i2_mv_y0 = ps_mv->i2_mv[3];
769 }
770 else
771 {
772 i2_mv_x0 = 0;
773 i2_mv_y0 = 0;
774 }
775 /* If FRM_TO_FLD or FLD_TO_FRM scale the "y" component of the colocated Mv*/
776 if(s_mvdirect.u1_vert_mv_scale == FRM_TO_FLD)
777 {
778 i2_mv_y0 /= 2;
779 }
780 else if(s_mvdirect.u1_vert_mv_scale == FLD_TO_FRM)
781 {
782 i2_mv_y0 *= 2;
783 }
784
785 diff = (WORD64)pic1_poc - pic0_poc;
786 i16_td = CLIP_S8(diff);
787 if((ps_pic_buff0->u1_is_short == 0) || (i16_td == 0))
788 {
789 i2_mv_x1 = 0;
790 i2_mv_y1 = 0;
791 }
792 else
793 {
794 WORD16 i2_tb, i2_tx, i2_dist_scale_factor, i2_temp;
795
796 diff = (WORD64)cur_poc - pic0_poc;
797 i2_tb = CLIP_S8(diff);
798
799 i2_tx = (16384 + ABS(SIGN_POW2_DIV(i16_td, 1))) / i16_td;
800 i2_dist_scale_factor = CLIP_S11(
801 (((i2_tb * i2_tx) + 32) >> 6));
802 i2_temp = (i2_mv_x0 * i2_dist_scale_factor + 128) >> 8;
803 i2_mv_x1 = i2_temp - i2_mv_x0;
804 i2_mv_x0 = i2_temp;
805
806 i2_temp = (i2_mv_y0 * i2_dist_scale_factor + 128) >> 8;
807 i2_mv_y1 = i2_temp - i2_mv_y0;
808 i2_mv_y0 = i2_temp;
809 }
810 {
811 mv_pred_t *ps_mv;
812
813 /*u1_sub_mb_x = u1_sub_mb_num & 0x03;
814 uc_sub_mb_y = u1_sub_mb_num >> 2;*/
815 if(ps_dec->ps_cur_pps->u1_wted_bipred_idc)
816 {
817 UWORD8 u1_idx =
818 u1_ref_idx0
819 * ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1];
820 UWORD8 u1_scale_ref = u1_mbaff && u1_is_cur_mb_fld;
821 if(u1_scale_ref)
822 u1_idx >>= 1;
823 pui32_weight_ofsts = (UWORD32*)&ps_dec->pu4_wt_ofsts[2
824 * X3(u1_idx)];
825 if(u1_scale_ref
826 && (ps_dec->ps_cur_pps->u1_wted_bipred_idc
827 == 2))
828 {
829 WORD16 i2_ref_idx;
830 i2_ref_idx = u1_ref_idx0;
831 i2_ref_idx *=
832 (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1]
833 << 1);
834 if(!ps_cur_mb_info->u1_topmb)
835 i2_ref_idx +=
836 (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0]
837 << 1)
838 * (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1]
839 << 1);
840 pui32_weight_ofsts =
841 (UWORD32*)&ps_dec->pu4_mbaff_wt_mat[2
842 * X3(i2_ref_idx)];
843 }
844 }
845 {
846 pred_info_pkd_t *ps_pred_pkd;
847 WORD16 i2_mv[2];
848 WORD8 i1_ref_idx= 0;
849
850 i2_mv[0] = i2_mv_x0;
851 i2_mv[1] = i2_mv_y0;
852
853 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
854 ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,PRED_L0 | PRED_L1,
855 ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
856 ps_pic_buff0->u1_pic_type);
857 ps_dec->u4_pred_info_pkd_idx++;
858 ps_cur_mb_info->u1_num_pred_parts++;
859
860
861 }
862 {
863 pred_info_pkd_t *ps_pred_pkd;
864 WORD16 i2_mv[2];
865 WORD8 i1_ref_idx= 0;
866
867 i2_mv[0] = i2_mv_x1;
868 i2_mv[1] = i2_mv_y1;
869
870 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
871 ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,PRED_L0 | PRED_L1,
872 ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
873 ps_pic_buff1->u1_pic_type);
874 ps_dec->u4_pred_info_pkd_idx++;
875 ps_cur_mb_info->u1_num_pred_parts++;
876
877
878 }
879
880 /* Replication optimisation */
881 s_temp_mv_pred.i2_mv[0] = i2_mv_x0;
882 s_temp_mv_pred.i2_mv[1] = i2_mv_y0;
883 s_temp_mv_pred.i2_mv[2] = i2_mv_x1;
884 s_temp_mv_pred.i2_mv[3] = i2_mv_y1;
885 s_temp_mv_pred.i1_ref_frame[0] = u1_ref_idx0;
886 s_temp_mv_pred.i1_ref_frame[1] = 0;
887 s_temp_mv_pred.u1_col_ref_pic_idx = ps_pic_buff0->u1_mv_buf_id;
888 s_temp_mv_pred.u1_pic_type = ps_pic_buff0->u1_pic_type;
889 ps_mv = ps_dec->ps_mv_cur + (u1_mb_num << 4) + u1_sub_mb_num;
890
891 {
892 WORD16 i2_mv_x = 0, i2_mv_y = 0;
893 UWORD8 u1_packed_mb_sub_mb_mode =
894 sub_partition ? (s_mvdirect.i1_partitionsize[i]) : ((s_mvdirect.i1_partitionsize[i])
895 << 2);
896
897 if(c_refFrm0 >= 0)
898 {
899 i2_mv_x = i2_mv_x0;
900 i2_mv_y = i2_mv_y0;
901 }
902 else
903 {
904 i2_mv_x = i2_mv_x1;
905 i2_mv_y = i2_mv_y1;
906 }
907
908 u1_colz =
909 (ps_cur_mb_info->u1_mb_field_decodingflag << 1)
910 | ((u1_ref_idx0 == 0)
911 && (ABS(i2_mv_x)
912 <= 1)
913 && (ABS(i2_mv_y)
914 <= 1));
915 u1_colz |= (u1_packed_mb_sub_mb_mode << 4);
916 }
917 ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num,
918 u1_colz, u1_mb_parth, u1_mb_partw);
919 }
920 }
921 }
922 /* return value set to UWORD8 to make it homogeneous */
923 /* with decodespatialdirect */
924 return OK;
925 }
926
ih264d_convert_frm_to_fld_list(struct pic_buffer_t * ps_ref_pic_buf_lx,UWORD8 * pu1_L0,dec_struct_t * ps_dec,UWORD8 u1_num_short_term_bufs)927 void ih264d_convert_frm_to_fld_list(struct pic_buffer_t *ps_ref_pic_buf_lx,
928 UWORD8 *pu1_L0,
929 dec_struct_t *ps_dec,
930 UWORD8 u1_num_short_term_bufs)
931 {
932 UWORD8 uc_count = *pu1_L0, i, uc_l1, uc_lx, j;
933 struct pic_buffer_t *ps_ref_lx[2], *ps_ref_pic_lx;
934 UWORD8 u1_bottom_field_flag;
935 dec_slice_params_t *ps_cur_slice;
936 UWORD8 u1_ref[2], u1_fld[2], u1_same_fld, u1_op_fld;
937 UWORD32 ui_half_num_of_sub_mbs;
938
939 uc_l1 = 0;
940 uc_lx = 0;
941 ps_cur_slice = ps_dec->ps_cur_slice;
942 ps_ref_pic_lx = ps_ref_pic_buf_lx - MAX_REF_BUFS;
943 ps_ref_lx[0] = ps_ref_pic_buf_lx;
944 ps_ref_lx[1] = ps_ref_pic_buf_lx;
945 u1_bottom_field_flag = ps_cur_slice->u1_bottom_field_flag;
946 ui_half_num_of_sub_mbs = ((ps_dec->u2_pic_ht * ps_dec->u2_pic_wd) >> 5);
947 if(u1_bottom_field_flag)
948 {
949 u1_ref[0] = BOT_REF;
950 u1_ref[1] = TOP_REF;
951 u1_fld[0] = BOT_FLD;
952 u1_fld[1] = TOP_FLD;
953 u1_same_fld = BOT_FLD;
954 u1_op_fld = TOP_FLD;
955 }
956 else
957 {
958 u1_ref[0] = TOP_REF;
959 u1_ref[1] = BOT_REF;
960 u1_fld[0] = TOP_FLD;
961 u1_fld[1] = BOT_FLD;
962 u1_same_fld = TOP_FLD;
963 u1_op_fld = BOT_FLD;
964 }
965
966 /* Create the field list starting with all the short term */
967 /* frames followed by all the long term frames. No long term */
968 /* reference field should have a list idx less than a short */
969 /* term reference field during initiailization. */
970
971 for(j = 0; j < 2; j++)
972 {
973 i = ((j == 0) ? 0 : u1_num_short_term_bufs);
974 uc_count = ((j == 0) ? u1_num_short_term_bufs : *pu1_L0);
975 for(; i < uc_count; i++, ps_ref_lx[0]++)
976 {
977 /* Search field of same parity in Frame list */
978 if((ps_ref_lx[0]->u1_pic_type & u1_ref[0])) // || ((ps_ref_lx[0]->u1_picturetype & 0x3) == 0))
979 {
980 /* Insert PIC of same parity in RefPicList */
981 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_lx, ps_ref_lx[0]);
982 ps_ref_pic_lx->i4_pic_num = (ps_ref_pic_lx->i4_pic_num * 2 + 1);
983 ps_ref_pic_lx->u1_long_term_pic_num =
984 (ps_ref_pic_lx->u1_long_term_frm_idx * 2 + 1);
985 ps_ref_pic_lx->u1_pic_type = u1_same_fld;
986 if(u1_fld[0] & BOT_FLD)
987 {
988 ps_ref_pic_lx->u1_pic_type = BOT_FLD;
989 ps_ref_pic_lx->pu1_buf1 += ps_ref_pic_lx->u2_frm_wd_y;
990 ps_ref_pic_lx->pu1_buf2 += ps_ref_pic_lx->u2_frm_wd_uv;
991 ps_ref_pic_lx->pu1_buf3 += ps_ref_pic_lx->u2_frm_wd_uv;
992 if(ps_ref_pic_lx->u1_picturetype & 0x3)
993 {
994 ps_ref_pic_lx->pu1_col_zero_flag += ui_half_num_of_sub_mbs;
995 ps_ref_pic_lx->ps_mv += ui_half_num_of_sub_mbs;
996 }
997 ps_ref_pic_lx->i4_poc =
998 ps_ref_pic_lx->i4_bottom_field_order_cnt;
999 ps_ref_pic_lx->i4_avg_poc =
1000 ps_ref_pic_lx->i4_bottom_field_order_cnt;
1001 }
1002 else
1003 {
1004 ps_ref_pic_lx->u1_pic_type = TOP_FLD;
1005 ps_ref_pic_lx->i4_poc = ps_ref_pic_lx->i4_top_field_order_cnt;
1006 ps_ref_pic_lx->i4_avg_poc =
1007 ps_ref_pic_lx->i4_top_field_order_cnt;
1008 }
1009
1010 ps_ref_pic_lx++;
1011 uc_lx++;
1012 /* Find field of opposite parity */
1013 if(uc_l1 < uc_count && ps_ref_lx[1])
1014 {
1015 while(!(ps_ref_lx[1]->u1_pic_type & u1_ref[1]))
1016 {
1017 ps_ref_lx[1]++;
1018 uc_l1++;
1019 if(uc_l1 >= uc_count)
1020 ps_ref_lx[1] = 0;
1021 if(!ps_ref_lx[1])
1022 break;
1023 }
1024
1025 if(ps_ref_lx[1])
1026 {
1027 uc_l1++;
1028 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_lx,
1029 ps_ref_lx[1]);
1030 ps_ref_pic_lx->u1_pic_type = u1_op_fld;
1031 ps_ref_pic_lx->i4_pic_num = (ps_ref_pic_lx->i4_pic_num * 2);
1032 ps_ref_pic_lx->u1_long_term_pic_num =
1033 (ps_ref_pic_lx->u1_long_term_frm_idx * 2);
1034 if(u1_fld[1] & BOT_FLD)
1035 {
1036 ps_ref_pic_lx->u1_pic_type = BOT_FLD;
1037 ps_ref_pic_lx->pu1_buf1 += ps_ref_pic_lx->u2_frm_wd_y;
1038 ps_ref_pic_lx->pu1_buf2 += ps_ref_pic_lx->u2_frm_wd_uv;
1039 ps_ref_pic_lx->pu1_buf3 += ps_ref_pic_lx->u2_frm_wd_uv;
1040 if(ps_ref_pic_lx->u1_picturetype & 0x3)
1041 {
1042 ps_ref_pic_lx->pu1_col_zero_flag +=
1043 ui_half_num_of_sub_mbs;
1044 ps_ref_pic_lx->ps_mv += ui_half_num_of_sub_mbs;
1045 }
1046 ps_ref_pic_lx->i4_poc =
1047 ps_ref_pic_lx->i4_bottom_field_order_cnt;
1048 ps_ref_pic_lx->i4_avg_poc =
1049 ps_ref_pic_lx->i4_bottom_field_order_cnt;
1050 }
1051 else
1052 {
1053 ps_ref_pic_lx->u1_pic_type = TOP_FLD;
1054 ps_ref_pic_lx->i4_poc =
1055 ps_ref_pic_lx->i4_top_field_order_cnt;
1056 ps_ref_pic_lx->i4_avg_poc =
1057 ps_ref_pic_lx->i4_top_field_order_cnt;
1058 }
1059 ps_ref_pic_lx++;
1060 uc_lx++;
1061 ps_ref_lx[1]++;
1062 }
1063 }
1064 }
1065 }
1066
1067 /* Same parity fields are over, now insert left over opposite parity fields */
1068 /** Added if(ps_ref_lx[1]) for error checks */
1069 if(ps_ref_lx[1])
1070 {
1071 for(; uc_l1 < uc_count; uc_l1++)
1072 {
1073 if(ps_ref_lx[1]->u1_pic_type & u1_ref[1])
1074 {
1075 /* Insert PIC of opposite parity in RefPicList */
1076 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_lx,
1077 ps_ref_lx[1]);
1078 ps_ref_pic_lx->u1_pic_type = u1_op_fld;
1079 ps_ref_pic_lx->i4_pic_num = (ps_ref_pic_lx->i4_pic_num * 2);
1080 ps_ref_pic_lx->u1_long_term_pic_num =
1081 (ps_ref_pic_lx->u1_long_term_frm_idx * 2);
1082 if(u1_op_fld == BOT_FLD)
1083 {
1084 ps_ref_pic_lx->u1_pic_type = BOT_FLD;
1085 ps_ref_pic_lx->pu1_buf1 += ps_ref_pic_lx->u2_frm_wd_y;
1086 ps_ref_pic_lx->pu1_buf2 += ps_ref_pic_lx->u2_frm_wd_uv;
1087 ps_ref_pic_lx->pu1_buf3 += ps_ref_pic_lx->u2_frm_wd_uv;
1088 if(ps_ref_pic_lx->u1_picturetype & 0x3)
1089 {
1090 ps_ref_pic_lx->pu1_col_zero_flag +=
1091 ui_half_num_of_sub_mbs;
1092 ps_ref_pic_lx->ps_mv += ui_half_num_of_sub_mbs;
1093 }
1094 ps_ref_pic_lx->i4_poc =
1095 ps_ref_pic_lx->i4_bottom_field_order_cnt;
1096 ps_ref_pic_lx->i4_avg_poc =
1097 ps_ref_pic_lx->i4_bottom_field_order_cnt;
1098 }
1099 else
1100 {
1101 ps_ref_pic_lx->i4_poc =
1102 ps_ref_pic_lx->i4_top_field_order_cnt;
1103 ps_ref_pic_lx->i4_avg_poc =
1104 ps_ref_pic_lx->i4_top_field_order_cnt;
1105 }
1106 ps_ref_pic_lx++;
1107 uc_lx++;
1108 ps_ref_lx[1]++;
1109 }
1110 }
1111 }
1112 }
1113 *pu1_L0 = uc_lx;
1114 }
1115
ih264d_convert_frm_mbaff_list(dec_struct_t * ps_dec)1116 void ih264d_convert_frm_mbaff_list(dec_struct_t *ps_dec)
1117 {
1118 struct pic_buffer_t **ps_ref_pic_lx;
1119 UWORD8 u1_max_ref_idx, idx;
1120 UWORD16 u2_frm_wd_y, u2_frm_wd_uv;
1121 struct pic_buffer_t **ps_ref_pic_buf_lx;
1122 UWORD32 u4_half_num_of_sub_mbs = ((ps_dec->u2_pic_ht * ps_dec->u2_pic_wd) >> 5);
1123
1124 ps_ref_pic_buf_lx = ps_dec->ps_ref_pic_buf_lx[0];
1125 ps_ref_pic_lx = ps_dec->ps_ref_pic_buf_lx[0];
1126 u1_max_ref_idx = ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0];
1127 for(idx = 0; idx < u1_max_ref_idx; idx++)
1128 {
1129 ps_ref_pic_lx[idx]->u1_pic_type = TOP_FLD;
1130 ps_ref_pic_lx[idx]->i4_poc = ps_ref_pic_lx[idx]->i4_top_field_order_cnt;
1131
1132 }
1133 u2_frm_wd_y = ps_dec->u2_frm_wd_y;
1134 u2_frm_wd_uv = ps_dec->u2_frm_wd_uv;
1135
1136 for(idx = 0; idx < u1_max_ref_idx; idx++)
1137 {
1138 *ps_ref_pic_lx[idx + MAX_REF_BUFS] = *ps_ref_pic_buf_lx[idx];
1139 ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf1 =
1140 ps_ref_pic_buf_lx[idx]->pu1_buf1 + u2_frm_wd_y;
1141 ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf2 =
1142 ps_ref_pic_buf_lx[idx]->pu1_buf2 + u2_frm_wd_uv;
1143 ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf3 =
1144 ps_ref_pic_buf_lx[idx]->pu1_buf3 + u2_frm_wd_uv;
1145
1146 ps_ref_pic_lx[idx + MAX_REF_BUFS]->u1_pic_type = BOT_FLD;
1147 ps_ref_pic_lx[idx + MAX_REF_BUFS]->i4_poc =
1148 ps_ref_pic_buf_lx[idx]->i4_bottom_field_order_cnt;
1149 if(ps_ref_pic_buf_lx[idx]->u1_picturetype & 0x3)
1150 {
1151 ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_col_zero_flag =
1152 ps_ref_pic_buf_lx[idx]->pu1_col_zero_flag
1153 + u4_half_num_of_sub_mbs;
1154 ps_ref_pic_lx[idx + MAX_REF_BUFS]->ps_mv =
1155 ps_ref_pic_buf_lx[idx]->ps_mv + u4_half_num_of_sub_mbs;
1156 }
1157 }
1158
1159 if(ps_dec->u1_B)
1160 {
1161 ps_ref_pic_buf_lx = ps_dec->ps_ref_pic_buf_lx[1];
1162 ps_ref_pic_lx = ps_dec->ps_ref_pic_buf_lx[1];
1163 u1_max_ref_idx = ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1];
1164 for(idx = 0; idx < u1_max_ref_idx; idx++)
1165 {
1166 ps_ref_pic_lx[idx]->u1_pic_type = TOP_FLD;
1167 ps_ref_pic_lx[idx]->i4_poc = ps_ref_pic_lx[idx]->i4_top_field_order_cnt;
1168
1169 }
1170
1171 for(idx = 0; idx < u1_max_ref_idx; idx++)
1172 {
1173 *ps_ref_pic_lx[idx + MAX_REF_BUFS] = *ps_ref_pic_buf_lx[idx];
1174 ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf1 =
1175 ps_ref_pic_buf_lx[idx]->pu1_buf1 + u2_frm_wd_y;
1176 ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf2 =
1177 ps_ref_pic_buf_lx[idx]->pu1_buf2 + u2_frm_wd_uv;
1178 ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_buf3 =
1179 ps_ref_pic_buf_lx[idx]->pu1_buf3 + u2_frm_wd_uv;
1180 ps_ref_pic_lx[idx + MAX_REF_BUFS]->u1_pic_type = BOT_FLD;
1181 ps_ref_pic_lx[idx + MAX_REF_BUFS]->i4_poc =
1182 ps_ref_pic_buf_lx[idx]->i4_bottom_field_order_cnt;
1183
1184 if(ps_ref_pic_buf_lx[idx]->u1_picturetype & 0x3)
1185 {
1186 ps_ref_pic_lx[idx + MAX_REF_BUFS]->pu1_col_zero_flag =
1187 ps_ref_pic_buf_lx[idx]->pu1_col_zero_flag
1188 + u4_half_num_of_sub_mbs;
1189 ps_ref_pic_lx[idx + MAX_REF_BUFS]->ps_mv =
1190 ps_ref_pic_buf_lx[idx]->ps_mv
1191 + u4_half_num_of_sub_mbs;
1192 }
1193 }
1194 }
1195 }
poc_compare(const void * pv_pic1,const void * pv_pic2)1196 static int poc_compare(const void *pv_pic1, const void *pv_pic2)
1197 {
1198 struct pic_buffer_t *ps_pic1 = *(struct pic_buffer_t **) pv_pic1;
1199 struct pic_buffer_t *ps_pic2 = *(struct pic_buffer_t **) pv_pic2;
1200 if (ps_pic1->i4_poc < ps_pic2->i4_poc)
1201 {
1202 return -1;
1203 }
1204 else if (ps_pic1->i4_poc > ps_pic2->i4_poc)
1205 {
1206 return 1;
1207 }
1208 else
1209 {
1210 return 0;
1211 }
1212 }
1213 /*!
1214 **************************************************************************
1215 * \if Function name : ih264d_init_ref_idx_lx_b \endif
1216 *
1217 * \brief
1218 * Initializes forward and backward refernce lists for B slice decoding.
1219 *
1220 *
1221 * \return
1222 * 0 on Success and Error code otherwise
1223 **************************************************************************
1224 */
ih264d_init_ref_idx_lx_b(dec_struct_t * ps_dec)1225 void ih264d_init_ref_idx_lx_b(dec_struct_t *ps_dec)
1226 {
1227 struct pic_buffer_t *ps_ref_pic_buf_lx;
1228 dpb_manager_t *ps_dpb_mgr;
1229 struct dpb_info_t *ps_next_dpb;
1230 WORD32 i_cur_poc, i_max_st_poc, i_min_st_poc, i_ref_poc, i_temp_poc;
1231 WORD8 i, j;
1232 UWORD8 u1_max_lt_index, u1_min_lt_index;
1233 UWORD32 u4_lt_index;
1234 WORD32 i_cur_idx;
1235 UWORD8 u1_field_pic_flag;
1236 dec_slice_params_t *ps_cur_slice;
1237 UWORD8 u1_L0, u1_L1;
1238 UWORD8 u1_num_short_term_bufs;
1239 UWORD8 u1_max_ref_idx_l0, u1_max_ref_idx_l1;
1240 struct pic_buffer_t *aps_st_pic_bufs[2 * MAX_REF_BUFS] = {NULL};
1241 ps_cur_slice = ps_dec->ps_cur_slice;
1242 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
1243 u1_max_ref_idx_l0 = ps_cur_slice->u1_num_ref_idx_lx_active[0]
1244 << u1_field_pic_flag;
1245 u1_max_ref_idx_l1 = ps_cur_slice->u1_num_ref_idx_lx_active[1]
1246 << u1_field_pic_flag;
1247
1248 ps_dpb_mgr = ps_dec->ps_dpb_mgr;
1249 /* Get the current POC */
1250 i_cur_poc = ps_dec->ps_cur_pic->i4_poc;
1251
1252 /* Get MaxStPOC,MinStPOC,MaxLt,MinLt */
1253 i_max_st_poc = i_cur_poc;
1254 i_min_st_poc = i_cur_poc;
1255 u1_max_lt_index = MAX_REF_BUFS + 1;
1256 u1_min_lt_index = MAX_REF_BUFS + 1;
1257 /* Start from ST head */
1258 ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head;
1259 for(i = 0; i < ps_dpb_mgr->u1_num_st_ref_bufs; i++)
1260 {
1261 i_ref_poc = ps_next_dpb->ps_pic_buf->i4_poc;
1262 if(i_ref_poc < i_cur_poc)
1263 {
1264 /* RefPic Buf POC is before Current POC in display order */
1265 i_min_st_poc = MIN(i_min_st_poc, i_ref_poc);
1266 }
1267 else
1268 {
1269 /* RefPic Buf POC is after Current POC in display order */
1270 i_max_st_poc = MAX(i_max_st_poc, i_ref_poc);
1271 }
1272
1273 /* Chase the next link */
1274 ps_next_dpb = ps_next_dpb->ps_prev_short;
1275 }
1276
1277 /* Sort ST ref pocs in ascending order */
1278 ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head;
1279 for (j = 0; j < ps_dpb_mgr->u1_num_st_ref_bufs; j++)
1280 {
1281 aps_st_pic_bufs[j] = ps_next_dpb->ps_pic_buf;
1282 ps_next_dpb = ps_next_dpb->ps_prev_short;
1283 }
1284 qsort(aps_st_pic_bufs, ps_dpb_mgr->u1_num_st_ref_bufs,
1285 sizeof(aps_st_pic_bufs[0]), poc_compare);
1286
1287 /* Start from LT head */
1288 ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head;
1289 if(ps_next_dpb)
1290 {
1291 u1_max_lt_index = ps_next_dpb->u1_lt_idx;
1292 u1_min_lt_index = ps_next_dpb->u1_lt_idx;
1293 }
1294 for(i = 0; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++)
1295 {
1296 u4_lt_index = ps_next_dpb->u1_lt_idx;
1297 u1_max_lt_index = (UWORD8)(MAX(u1_max_lt_index, u4_lt_index));
1298 u1_min_lt_index = (UWORD8)(MIN(u1_min_lt_index, u4_lt_index));
1299
1300 /* Chase the next link */
1301 ps_next_dpb = ps_next_dpb->ps_prev_long;
1302 }
1303
1304 /* 1. Initialize refIdxL0 */
1305 u1_L0 = 0;
1306 i_temp_poc = i_cur_poc;
1307 if(u1_field_pic_flag)
1308 {
1309 ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0];
1310 ps_ref_pic_buf_lx += MAX_REF_BUFS;
1311 }
1312 else
1313 {
1314 ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0];
1315 /* Avoid integer overflow while decrementing by one */
1316 if (i_temp_poc > INT32_MIN)
1317 i_temp_poc--;
1318 }
1319
1320 i_cur_idx = -1;
1321 for(j = 0; j < ps_dpb_mgr->u1_num_st_ref_bufs; j++)
1322 {
1323 if (NULL == aps_st_pic_bufs[j])
1324 {
1325 break;
1326 }
1327 if (aps_st_pic_bufs[j]->i4_poc <= i_temp_poc)
1328 {
1329 i_cur_idx = j;
1330 }
1331 }
1332 /* Arrange all short term buffers in output order as given by POC */
1333 /* 1.1 Arrange POC's less than CurrPOC in the descending POC order starting
1334 from (CurrPOC - 1)*/
1335 for(j = i_cur_idx; j >= 0; j--)
1336 {
1337 if(aps_st_pic_bufs[j])
1338 {
1339 /* Copy info in pic buffer */
1340 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1341 aps_st_pic_bufs[j]);
1342 ps_ref_pic_buf_lx++;
1343 u1_L0++;
1344 }
1345 }
1346
1347 /* 1.2. Arrange POC's more than CurrPOC in the ascending POC order starting
1348 from (CurrPOC + 1)*/
1349 for(j = i_cur_idx + 1; j < ps_dpb_mgr->u1_num_st_ref_bufs; j++)
1350 {
1351 if(aps_st_pic_bufs[j])
1352 {
1353 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1354 aps_st_pic_bufs[j]);
1355 ps_ref_pic_buf_lx++;
1356 u1_L0++;
1357 }
1358 }
1359
1360 /* 1.3 Arrange all Long term buffers in ascending order, in LongtermIndex */
1361 /* Start from ST head */
1362
1363 u1_num_short_term_bufs = u1_L0;
1364 for(u4_lt_index = u1_min_lt_index; u4_lt_index <= u1_max_lt_index; u4_lt_index++)
1365 {
1366 ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head;
1367 for(i = 0; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++)
1368 {
1369 if(ps_next_dpb->u1_lt_idx == u4_lt_index)
1370 {
1371 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1372 ps_next_dpb->ps_pic_buf);
1373 ps_ref_pic_buf_lx->u1_long_term_pic_num =
1374 ps_ref_pic_buf_lx->u1_long_term_frm_idx;
1375
1376 ps_ref_pic_buf_lx++;
1377 u1_L0++;
1378 break;
1379 }
1380 ps_next_dpb = ps_next_dpb->ps_prev_long;
1381 }
1382 }
1383
1384 if(u1_field_pic_flag)
1385 {
1386 /* Initialize the rest of the entries in the */
1387 /* reference list to handle of errors */
1388 {
1389 UWORD8 u1_i;
1390 pic_buffer_t ref_pic;
1391
1392 ref_pic = *(ps_dpb_mgr->ps_init_dpb[0][0] + MAX_REF_BUFS);
1393
1394 if(NULL == ref_pic.pu1_buf1)
1395 {
1396 ref_pic = *ps_dec->ps_cur_pic;
1397 }
1398 for(u1_i = u1_L0; u1_i < u1_max_ref_idx_l0; u1_i++)
1399 {
1400 *ps_ref_pic_buf_lx = ref_pic;
1401 ps_ref_pic_buf_lx++;
1402 }
1403 }
1404 ih264d_convert_frm_to_fld_list(
1405 ps_dpb_mgr->ps_init_dpb[0][0] + MAX_REF_BUFS, &u1_L0,
1406 ps_dec, u1_num_short_term_bufs);
1407
1408 ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0] + u1_L0;
1409 }
1410
1411 ps_dec->ps_cur_slice->u1_initial_list_size[0] = u1_L0;
1412
1413 /* Initialize the rest of the entries in the */
1414 /* reference list to handle of errors */
1415 {
1416 UWORD8 u1_i;
1417 pic_buffer_t ref_pic;
1418
1419 ref_pic = *(ps_dpb_mgr->ps_init_dpb[0][0]);
1420
1421 if(NULL == ref_pic.pu1_buf1)
1422 {
1423 ref_pic = *ps_dec->ps_cur_pic;
1424 }
1425 for(u1_i = u1_L0; u1_i < u1_max_ref_idx_l0; u1_i++)
1426 {
1427 *ps_ref_pic_buf_lx = ref_pic;
1428 ps_ref_pic_buf_lx++;
1429 }
1430 }
1431 {
1432 /* 2. Initialize refIdxL1 */
1433 u1_L1 = 0;
1434 if(u1_field_pic_flag)
1435 {
1436 ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[1][0] + MAX_REF_BUFS;
1437 }
1438 else
1439 {
1440 ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[1][0];
1441 }
1442
1443 /* 2.1. Arrange POC's more than CurrPOC in the ascending POC order starting
1444 from (CurrPOC + 1)*/
1445 for(j = i_cur_idx + 1; j < ps_dpb_mgr->u1_num_st_ref_bufs; j++)
1446 {
1447 if(aps_st_pic_bufs[j])
1448 {
1449 /* Start from ST head */
1450 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1451 aps_st_pic_bufs[j]);
1452 ps_ref_pic_buf_lx++;
1453 u1_L1++;
1454 }
1455 }
1456
1457 /* Arrange all short term buffers in output order as given by POC */
1458 /* 2.2 Arrange POC's less than CurrPOC in the descending POC order starting
1459 from (CurrPOC - 1)*/
1460 for(j = i_cur_idx; j >= 0; j--)
1461 {
1462 if(aps_st_pic_bufs[j])
1463 {
1464 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1465 aps_st_pic_bufs[j]);
1466 ps_ref_pic_buf_lx++;
1467 u1_L1++;
1468 }
1469 }
1470
1471 /* 2.3 Arrange all Long term buffers in ascending order, in LongtermIndex */
1472 /* Start from ST head */
1473 u1_num_short_term_bufs = u1_L1;
1474
1475 for(u4_lt_index = u1_min_lt_index; u4_lt_index <= u1_max_lt_index;
1476 u4_lt_index++)
1477 {
1478 ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head;
1479 for(i = 0; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++)
1480 {
1481 if(ps_next_dpb->u1_lt_idx == u4_lt_index)
1482 {
1483 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1484 ps_next_dpb->ps_pic_buf);
1485 ps_ref_pic_buf_lx->u1_long_term_pic_num =
1486 ps_ref_pic_buf_lx->u1_long_term_frm_idx;
1487 ps_ref_pic_buf_lx++;
1488 u1_L1++;
1489 break;
1490 }
1491 ps_next_dpb = ps_next_dpb->ps_prev_long;
1492 }
1493 }
1494
1495 if(u1_field_pic_flag)
1496 {
1497 /* Initialize the rest of the entries in the */
1498 /* reference list to handle of errors */
1499 {
1500 UWORD8 u1_i;
1501 pic_buffer_t ref_pic;
1502
1503 ref_pic = *(ps_dpb_mgr->ps_init_dpb[0][0] + MAX_REF_BUFS);
1504
1505 if(NULL == ref_pic.pu1_buf1)
1506 {
1507 ref_pic = *ps_dec->ps_cur_pic;
1508 }
1509 for(u1_i = u1_L1; u1_i < u1_max_ref_idx_l1; u1_i++)
1510 {
1511 *ps_ref_pic_buf_lx = ref_pic;
1512 ps_ref_pic_buf_lx++;
1513 }
1514 }
1515
1516 ih264d_convert_frm_to_fld_list(
1517 ps_dpb_mgr->ps_init_dpb[1][0] + MAX_REF_BUFS,
1518 &u1_L1, ps_dec, u1_num_short_term_bufs);
1519 ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[1][0] + u1_L1;
1520 }
1521
1522 ps_dec->ps_cur_slice->u1_initial_list_size[1] = u1_L1;
1523
1524 /* Initialize the rest of the entries in the */
1525 /* reference list to handle of errors */
1526 {
1527 UWORD8 u1_i;
1528 pic_buffer_t ref_pic;
1529
1530 ref_pic = *(ps_dpb_mgr->ps_init_dpb[0][0]);
1531
1532 if(NULL == ref_pic.pu1_buf1)
1533 {
1534 ref_pic = *ps_dec->ps_cur_pic;
1535 }
1536 for(u1_i = u1_L1; u1_i < u1_max_ref_idx_l1; u1_i++)
1537 {
1538 *ps_ref_pic_buf_lx = ref_pic;
1539 ps_ref_pic_buf_lx++;
1540 }
1541 }
1542
1543 /* If list0 and list 1 ebtries are same then swap the 0th and 1st entry */
1544 /* of list 1 */
1545 {
1546 struct pic_buffer_t *ps_ref_pic1_buf_l0, *ps_ref_pic1_buf_l1;
1547 struct pic_buffer_t s_ref_pic1_buf_temp;
1548
1549 ps_ref_pic1_buf_l0 = ps_dpb_mgr->ps_init_dpb[0][0];
1550 ps_ref_pic1_buf_l1 = ps_dpb_mgr->ps_init_dpb[1][0];
1551
1552 if((u1_L0 == u1_L1) && (u1_L0 > 1))
1553 {
1554 WORD32 i_index, i_swap;
1555
1556 i_swap = 1;
1557
1558 for(i_index = 0; i_index < u1_L0; i_index++)
1559 {
1560 if((ps_ref_pic1_buf_l0[i_index]).pu1_buf1
1561 != (ps_ref_pic1_buf_l1[i_index]).pu1_buf1)
1562 {
1563 i_swap = 0;
1564 break;
1565 }
1566 }
1567 if(1 == i_swap)
1568 {
1569 memcpy(&s_ref_pic1_buf_temp, &ps_ref_pic1_buf_l1[1],
1570 sizeof(struct pic_buffer_t));
1571 memcpy(&ps_ref_pic1_buf_l1[1], &ps_ref_pic1_buf_l1[0],
1572 sizeof(struct pic_buffer_t));
1573 memcpy(&ps_ref_pic1_buf_l1[0], &s_ref_pic1_buf_temp,
1574 sizeof(struct pic_buffer_t));
1575 }
1576 }
1577 }
1578 }
1579 }
1580
1581
1582
1583 void ih264d_get_implicit_weights(dec_struct_t *ps_dec);
1584
1585 /*!
1586 **************************************************************************
1587 * \if Function name : ih264d_one_to_one \endif
1588 *
1589 * \brief
1590 * Initializes forward and backward refernce lists for B slice decoding.
1591 *
1592 *
1593 * \return
1594 * 0 on Success and Error code otherwise
1595 **************************************************************************
1596 */
ih264d_one_to_one(dec_struct_t * ps_dec,struct pic_buffer_t * ps_col_pic,directmv_t * ps_direct,UWORD8 u1_wd_x,WORD32 u2_sub_mb_ofst,dec_mb_info_t * ps_cur_mb_info)1597 void ih264d_one_to_one(dec_struct_t *ps_dec,
1598 struct pic_buffer_t *ps_col_pic,
1599 directmv_t *ps_direct,
1600 UWORD8 u1_wd_x,
1601 WORD32 u2_sub_mb_ofst,
1602 dec_mb_info_t * ps_cur_mb_info)
1603 {
1604 UWORD8 *pu1_col_zero_flag_start, u1_col_mb_pred_mode, u1_num_blks, u1_sub_mb_num;
1605 UWORD8 u1_init_colzero_flag;
1606 UNUSED(ps_cur_mb_info);
1607 pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;
1608 u1_col_mb_pred_mode = pu1_col_zero_flag_start[ps_dec->u1_sub_mb_num];
1609 u1_init_colzero_flag = u1_col_mb_pred_mode & 1;
1610 u1_col_mb_pred_mode >>= 6;
1611 ps_direct->u1_vert_mv_scale = ONE_TO_ONE;
1612 ps_direct->u1_col_zeroflag_change = 0;
1613
1614 if(u1_wd_x == MB_SIZE)
1615 {
1616 ps_dec->u1_currB_type = (!!u1_col_mb_pred_mode);
1617 if(u1_col_mb_pred_mode == PRED_16x16)
1618 {
1619 ps_direct->i1_num_partitions = 1;
1620 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
1621 ps_direct->i1_submb_num[0] = 0;
1622 ps_direct->i1_partitionsize[0] = PRED_16x16;
1623
1624 return;
1625 }
1626 else if(u1_col_mb_pred_mode < PRED_8x8)
1627 {
1628 ps_direct->i1_num_partitions = 2;
1629 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
1630 ps_direct->i1_submb_num[0] = 0;
1631 ps_direct->i1_partitionsize[0] = u1_col_mb_pred_mode;
1632 u1_sub_mb_num = (u1_col_mb_pred_mode == PRED_16x8) ? 8 : 2;
1633 ps_direct->i1_submb_num[1] = u1_sub_mb_num;
1634 ps_direct->i4_mv_indices[1] = u2_sub_mb_ofst
1635 + ps_direct->i1_submb_num[1];
1636 ps_direct->i1_partitionsize[1] = u1_col_mb_pred_mode;
1637 if((pu1_col_zero_flag_start[u1_sub_mb_num] & 1) != u1_init_colzero_flag)
1638 ps_direct->u1_col_zeroflag_change = 1;
1639 return;
1640 }
1641 else
1642 {
1643 u1_num_blks = 4;
1644 }
1645 }
1646 else
1647 {
1648 u1_num_blks = 1;
1649 }
1650
1651 {
1652 const UWORD8 *pu1_top_lt_mb_part_idx;
1653 UWORD8 u1_col_sub_mb_pred_mode, uc_blk, u1_sub_blk, u1_submb_col = 0;
1654 UWORD8 u1_num_sub_blks, uc_direct8x8inf, *pu1_col_zero_flag, u1_sub_mb_num;
1655 const UWORD8 *pu1_num_sub_mb_part =
1656 (const UWORD8 *)gau1_ih264d_num_submb_part;
1657 UWORD8 i1_num_partitions = 0, partition_size;
1658 WORD32 mv_index;
1659 const UWORD8 *pu1_top_lt_sub_mb_idx = gau1_ih264d_submb_indx_mod_sp_drct;
1660
1661 u1_sub_mb_num = ps_dec->u1_sub_mb_num;
1662 uc_direct8x8inf = ps_dec->ps_cur_slice->u1_direct_8x8_inference_flag;
1663 pu1_top_lt_mb_part_idx = gau1_ih264d_top_left_mb_part_indx_mod
1664 + (PRED_8x8 << 1) + 1;
1665
1666 for(uc_blk = 0; uc_blk < u1_num_blks; uc_blk++)
1667 {
1668 partition_size = PRED_8x8;
1669 pu1_top_lt_sub_mb_idx = gau1_ih264d_submb_indx_mod_sp_drct;
1670 if(uc_direct8x8inf == 1)
1671 {
1672 u1_submb_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
1673 mv_index = u2_sub_mb_ofst + u1_submb_col;
1674 u1_num_sub_blks = 1;
1675 }
1676 else
1677 {
1678 /* colMbPart is either 8x8, 8x4, 4x8, 4x4 */
1679 pu1_col_zero_flag = pu1_col_zero_flag_start + u1_sub_mb_num;
1680 u1_col_sub_mb_pred_mode = *pu1_col_zero_flag;
1681 u1_col_sub_mb_pred_mode = (u1_col_sub_mb_pred_mode & 0x30) >> 4;
1682 partition_size = (UWORD8)((u1_col_sub_mb_pred_mode)
1683 | (PRED_8x8 << 2));
1684 mv_index = u2_sub_mb_ofst + u1_sub_mb_num;
1685 pu1_top_lt_sub_mb_idx += (u1_col_sub_mb_pred_mode << 1);
1686 u1_num_sub_blks = pu1_num_sub_mb_part[u1_col_sub_mb_pred_mode];
1687
1688 }
1689
1690 for(u1_sub_blk = 0; u1_sub_blk < u1_num_sub_blks;
1691 u1_sub_blk++, pu1_top_lt_sub_mb_idx++)
1692 {
1693 u1_sub_mb_num += *pu1_top_lt_sub_mb_idx;
1694 mv_index += *pu1_top_lt_sub_mb_idx;
1695 ps_direct->i4_mv_indices[i1_num_partitions] = mv_index;
1696 ps_direct->i1_submb_num[i1_num_partitions] = u1_sub_mb_num;
1697 ps_direct->i1_partitionsize[i1_num_partitions] = partition_size;
1698 i1_num_partitions++;
1699 if(!uc_direct8x8inf)
1700 u1_submb_col = u1_sub_mb_num;
1701 if((pu1_col_zero_flag_start[u1_submb_col] & 1)
1702 != u1_init_colzero_flag)
1703 ps_direct->u1_col_zeroflag_change = 1;
1704 }
1705 u1_sub_mb_num = *pu1_top_lt_mb_part_idx++;
1706 }
1707 ps_direct->i1_num_partitions = i1_num_partitions;
1708 }
1709 }
1710 /*!
1711 **************************************************************************
1712 * \if Function name : ih264d_mbaff_cross_pmbair \endif
1713 *
1714 * \brief
1715 * Initializes forward and backward refernce lists for B slice decoding.
1716 *
1717 *
1718 * \return
1719 * 0 on Success and Error code otherwise
1720 **************************************************************************
1721 */
ih264d_mbaff_cross_pmbair(dec_struct_t * ps_dec,struct pic_buffer_t * ps_col_pic,directmv_t * ps_direct,UWORD8 u1_wd_x,WORD32 u2_sub_mb_ofst,dec_mb_info_t * ps_cur_mb_info)1722 void ih264d_mbaff_cross_pmbair(dec_struct_t *ps_dec,
1723 struct pic_buffer_t *ps_col_pic,
1724 directmv_t *ps_direct,
1725 UWORD8 u1_wd_x,
1726 WORD32 u2_sub_mb_ofst,
1727 dec_mb_info_t * ps_cur_mb_info)
1728 {
1729 UWORD8 *pu1_col_zero_flag_start, *pu1_col_zero_flag, u1_sub_mb_num,
1730 uc_sub_mb_num_col;
1731 UWORD8 *pu1_col_zero_flag_right_half;
1732 WORD32 i4_force_8X8;
1733 UWORD8 u1_num_blks, u1_col_mb_pred_mode, uc_blk, u1_col_sub_mb_pred_mode,
1734 u1_col_sub_mb_pred_mode_rt;
1735 UWORD8 i1_num_partitions = 0, partition_size;
1736
1737 WORD32 mv_index;
1738
1739 UWORD8 u1_num_sub_blks;
1740 UWORD8 u1_is_cur_mb_fld, i;
1741 UWORD8 u1_init_colzero_flag;
1742
1743 u1_is_cur_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag;
1744 u1_sub_mb_num = ps_dec->u1_sub_mb_num;
1745 ps_direct->u1_col_zeroflag_change = 0;
1746 /*pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;
1747 u1_col_mb_pred_mode = pu1_col_zero_flag_start[u1_sub_mb_num];
1748 u1_init_colzero_flag = u1_col_mb_pred_mode & 1;
1749 u1_col_mb_pred_mode >>= 6; */
1750 if(0 == u1_is_cur_mb_fld)
1751 {
1752 ps_direct->u1_vert_mv_scale = FLD_TO_FRM;
1753 if(u1_wd_x == MB_SIZE)
1754 {
1755 pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag
1756 + u2_sub_mb_ofst;
1757 u1_col_mb_pred_mode = pu1_col_zero_flag_start[0];
1758 u1_init_colzero_flag = u1_col_mb_pred_mode & 1;
1759 u1_col_mb_pred_mode >>= 6;
1760
1761
1762 if(u1_col_mb_pred_mode & 0x2)
1763 {
1764 ps_dec->u1_currB_type = 1;
1765 if(u1_col_mb_pred_mode == PRED_8x16)
1766 {
1767 ps_direct->i1_num_partitions = 2;
1768 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
1769 ps_direct->i1_submb_num[0] = 0;
1770 ps_direct->i1_partitionsize[0] = PRED_8x16;
1771 ps_direct->i4_mv_indices[1] = u2_sub_mb_ofst + 2;
1772 ps_direct->i1_submb_num[1] = 2;
1773 ps_direct->i1_partitionsize[1] = PRED_8x16;
1774 if((pu1_col_zero_flag_start[2] & 1) != u1_init_colzero_flag)
1775 ps_direct->u1_col_zeroflag_change = 1;
1776 }
1777 else
1778 {
1779 pu1_col_zero_flag = pu1_col_zero_flag_start + u1_sub_mb_num;
1780 u1_col_sub_mb_pred_mode = (*pu1_col_zero_flag & 0x10);/* 8x4 or 4x4 mode */
1781
1782 pu1_col_zero_flag_right_half = pu1_col_zero_flag_start
1783 + u1_sub_mb_num + 2;
1784 u1_col_sub_mb_pred_mode_rt =
1785 (*pu1_col_zero_flag_right_half & 0x10);/* 8x4 or 4x4 mode */
1786
1787 i4_force_8X8 = (u1_col_sub_mb_pred_mode)
1788 || (u1_col_sub_mb_pred_mode_rt);
1789 if(i4_force_8X8)
1790 {
1791 u1_num_sub_blks = 2;
1792 partition_size = PRED_8x8;
1793 }
1794 else
1795 {
1796 partition_size = PRED_8x16;
1797 u1_num_sub_blks = 1;
1798 }
1799
1800 for(i = 0; i < 2; i++)
1801 {
1802 for(uc_blk = 0; uc_blk < u1_num_sub_blks; uc_blk++)
1803 {
1804 uc_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
1805 uc_sub_mb_num_col &= 0x7;
1806 mv_index = u2_sub_mb_ofst + uc_sub_mb_num_col;
1807
1808 ps_direct->i4_mv_indices[i1_num_partitions] =
1809 mv_index;
1810 ps_direct->i1_submb_num[i1_num_partitions] =
1811 u1_sub_mb_num;
1812 ps_direct->i1_partitionsize[i1_num_partitions] =
1813 partition_size;
1814 i1_num_partitions++;
1815 if((pu1_col_zero_flag_start[uc_sub_mb_num_col] & 1)
1816 != u1_init_colzero_flag)
1817 ps_direct->u1_col_zeroflag_change = 1;
1818 u1_sub_mb_num += 8;
1819 }
1820 u1_sub_mb_num = 2; /* move to second half of Cur MB */
1821 }
1822 ps_direct->i1_num_partitions = i1_num_partitions;
1823 return;
1824 }
1825 }
1826 else
1827 {
1828 ps_direct->i1_num_partitions = 1;
1829 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
1830 ps_direct->i1_submb_num[0] = 0;
1831 ps_direct->i1_partitionsize[0] = PRED_16x16;
1832 ps_dec->u1_currB_type = 0;
1833 return;
1834 }
1835 }
1836 else
1837 {
1838 uc_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
1839 uc_sub_mb_num_col &= 0x7;
1840
1841 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst + uc_sub_mb_num_col;
1842 ps_direct->i1_submb_num[0] = u1_sub_mb_num;
1843 ps_direct->i1_partitionsize[0] = PRED_8x8;
1844 ps_direct->i1_num_partitions = 1;
1845 }
1846 }
1847 else
1848 {
1849 ps_direct->u1_vert_mv_scale = FRM_TO_FLD;
1850 pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;
1851 u1_init_colzero_flag = pu1_col_zero_flag_start[0] & 1;
1852
1853 if(u1_wd_x == MB_SIZE)
1854 {
1855 UWORD8 u1_submb_col;
1856 UWORD8 *puc_colZeroFlagStart_bot_mb, uc_colMbPredMode_bot_mb;
1857
1858 pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag
1859 + u2_sub_mb_ofst;
1860 u1_col_mb_pred_mode = pu1_col_zero_flag_start[u1_sub_mb_num] >> 6;
1861
1862 puc_colZeroFlagStart_bot_mb = ps_col_pic->pu1_col_zero_flag
1863 + u2_sub_mb_ofst + 16;
1864 uc_colMbPredMode_bot_mb = puc_colZeroFlagStart_bot_mb[8] >> 6;
1865
1866 i4_force_8X8 = (u1_col_mb_pred_mode & 0x2)
1867 || (uc_colMbPredMode_bot_mb & 0x2);
1868 if(i4_force_8X8)
1869 {
1870 u1_num_blks = 2;
1871 partition_size = PRED_8x8;
1872 }
1873 else
1874 {
1875 u1_num_blks = 1;
1876 partition_size = PRED_16x8;
1877 }
1878
1879 ps_dec->u1_currB_type = 1;
1880 /*As this mb is derived from 2 Mbs min no of partitions = 2*/
1881 for(i = 0; i < 2; i++)
1882 {
1883
1884 pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag
1885 + u2_sub_mb_ofst;
1886 u1_col_mb_pred_mode = pu1_col_zero_flag_start[u1_sub_mb_num] >> 6;
1887
1888 for(uc_blk = 0; uc_blk < u1_num_blks; uc_blk++)
1889 {
1890 u1_submb_col = (u1_sub_mb_num & 0x7) ? 1 : 0;
1891 u1_submb_col += u1_sub_mb_num;
1892 mv_index = u2_sub_mb_ofst + u1_submb_col;
1893
1894
1895 ps_direct->i4_mv_indices[i1_num_partitions] = mv_index;
1896 ps_direct->i1_submb_num[i1_num_partitions] = u1_sub_mb_num;
1897 ps_direct->i1_partitionsize[i1_num_partitions] =
1898 partition_size;
1899 i1_num_partitions++;
1900 if((pu1_col_zero_flag_start[u1_submb_col] & 1)
1901 != u1_init_colzero_flag)
1902 ps_direct->u1_col_zeroflag_change = 1;
1903 u1_sub_mb_num += 2;
1904 }
1905 u1_sub_mb_num = 8; /* move to second half of Cur MB */
1906 u2_sub_mb_ofst += 16;/* move to next Colocated MB */
1907 }
1908 ps_direct->i1_num_partitions = i1_num_partitions;
1909 return;
1910 }
1911 else
1912 {
1913 uc_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
1914 uc_sub_mb_num_col &= 0xb;
1915 u2_sub_mb_ofst += (u1_sub_mb_num >> 3) ? 16 : 0;
1916
1917 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst + uc_sub_mb_num_col;
1918 ps_direct->i1_submb_num[0] = u1_sub_mb_num;
1919 ps_direct->i1_partitionsize[0] = PRED_8x8;
1920 ps_direct->i1_num_partitions = 1;
1921 return;
1922 }
1923 }
1924 }
1925 /*!
1926 **************************************************************************
1927 * \if Function name : ih264d_cal_col_pic \endif
1928 *
1929 * \brief
1930 * Finds the colocated picture.
1931 *
1932 *
1933 * \return
1934 * 0 on Success and Error code otherwise
1935 **************************************************************************
1936 */
ih264d_cal_col_pic(dec_struct_t * ps_dec)1937 WORD32 ih264d_cal_col_pic(dec_struct_t *ps_dec)
1938 {
1939 struct pic_buffer_t* ps_col_pic = ps_dec->ps_col_pic;
1940 UWORD8 uc_curpictype, uc_colpictype;
1941 ps_col_pic = ps_dec->ps_ref_pic_buf_lx[1][0];
1942 uc_curpictype = (ps_dec->ps_cur_pic->u1_picturetype & 0x7);
1943 uc_colpictype = (ps_col_pic->u1_picturetype & 0x7);
1944 if(uc_curpictype == FRM_PIC)
1945 {
1946 if(uc_colpictype == FRM_PIC)
1947 ps_dec->pf_parse_mvdirect = ih264d_one_to_one;
1948 else if(uc_colpictype == COMP_FLD_PAIR)
1949 {
1950 ps_dec->pf_parse_mvdirect = ih264d_fld_to_frm;
1951 if(ps_col_pic->i4_top_field_order_cnt
1952 >= ps_col_pic->i4_bottom_field_order_cnt)
1953 {
1954 struct pic_buffer_t* ps_tempPic = ps_col_pic;
1955 UWORD32 ui_half_num_of_sub_mbs = ((ps_dec->u2_pic_ht
1956 * ps_dec->u2_pic_wd) >> 5);
1957 ps_col_pic = ps_dec->ps_ref_pic_buf_lx[1][MAX_REF_BUFS];
1958 /* memcpy ps_tempPic to ps_col_pic */
1959 *ps_col_pic = *ps_tempPic;
1960 ps_col_pic->pu1_buf1 = ps_tempPic->pu1_buf1
1961 + ps_tempPic->u2_frm_wd_y;
1962 ps_col_pic->pu1_buf2 = ps_tempPic->pu1_buf2
1963 + ps_tempPic->u2_frm_wd_uv;
1964 ps_col_pic->pu1_buf3 = ps_tempPic->pu1_buf3
1965 + ps_tempPic->u2_frm_wd_uv;
1966 ps_col_pic->pu1_col_zero_flag = ps_tempPic->pu1_col_zero_flag
1967 + ui_half_num_of_sub_mbs;
1968 ps_col_pic->ps_mv = ps_tempPic->ps_mv + ui_half_num_of_sub_mbs;
1969
1970
1971 ps_col_pic->u1_pic_type = 0;/*complementary reference field pair-refering as frame */
1972
1973
1974
1975 }
1976 }
1977 else
1978 {
1979 UWORD32 i4_error_code;
1980 i4_error_code = ERROR_DBP_MANAGER_T;
1981 // i4_error_code |= 1<<IVD_CORRUPTEDDATA;
1982 return i4_error_code;
1983 }
1984 }
1985 else if(uc_curpictype == AFRM_PIC)
1986 {
1987 ps_dec->pf_parse_mvdirect = ih264d_fld_to_mbaff;
1988 }
1989 else /* must be a field*/
1990 {
1991 if(uc_colpictype == FRM_PIC)
1992 ps_dec->pf_parse_mvdirect = ih264d_frm_to_fld;
1993 else if(uc_colpictype == AFRM_PIC)
1994 ps_dec->pf_parse_mvdirect = ih264d_mbaff_to_fld;
1995 else
1996 ps_dec->pf_parse_mvdirect = ih264d_one_to_one;
1997 }
1998 ps_dec->ps_col_pic = ps_col_pic;
1999 return OK;
2000 }
2001
2002 /*!
2003 **************************************************************************
2004 * \if Function name : ih264d_frm_to_fld \endif
2005 *
2006 * \brief
2007 * Initializes forward and backward refernce lists for B slice decoding.
2008 *
2009 *
2010 * \return
2011 * 0 on Success and Error code otherwise
2012 **************************************************************************
2013 */
ih264d_frm_to_fld(dec_struct_t * ps_dec,struct pic_buffer_t * ps_col_pic,directmv_t * ps_direct,UWORD8 u1_wd_x,WORD32 u2_sub_mb_ofst,dec_mb_info_t * ps_cur_mb_info)2014 void ih264d_frm_to_fld(dec_struct_t *ps_dec,
2015 struct pic_buffer_t *ps_col_pic,
2016 directmv_t *ps_direct,
2017 UWORD8 u1_wd_x,
2018 WORD32 u2_sub_mb_ofst,
2019 dec_mb_info_t * ps_cur_mb_info)
2020 {
2021 UWORD8 *pu1_col_zero_flag_start, u1_sub_mb_num;
2022 UWORD8 u1_num_blks, u1_col_mb_pred_mode, uc_blk;
2023 UWORD8 i1_num_partitions = 0, partition_size, i;
2024 WORD32 mv_index;
2025 UWORD32 increment;
2026 WORD32 i4_force_8X8;
2027 UNUSED(ps_cur_mb_info);
2028 ps_direct->u1_col_zeroflag_change = 1;
2029 ps_direct->u1_vert_mv_scale = FRM_TO_FLD;
2030 u1_sub_mb_num = ps_dec->u1_sub_mb_num;
2031
2032 /* new calculation specific to this function */
2033 if((ps_col_pic->u1_picturetype & 0x7) == FRM_PIC)
2034 {
2035 UWORD16 u2_frm_wd_in_mbs = ps_dec->u2_frm_wd_in_mbs;
2036 increment = (u2_frm_wd_in_mbs << 4);
2037 /*mbAddrCol = mbAddrCol1 */
2038 u2_sub_mb_ofst = (ps_dec->u2_mbx
2039 + (2 * ps_dec->u2_mby * u2_frm_wd_in_mbs)) << 4;
2040 }
2041 else
2042 increment = 16;
2043
2044 if(u1_wd_x == MB_SIZE)
2045 {
2046 ps_dec->u1_currB_type = 1;
2047
2048 {
2049 UWORD8 *puc_colZeroFlagStart_bot_mb, uc_colMbPredMode_bot_mb;
2050
2051 pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag
2052 + u2_sub_mb_ofst;
2053 u1_col_mb_pred_mode = (*pu1_col_zero_flag_start >> 6);
2054
2055 puc_colZeroFlagStart_bot_mb = ps_col_pic->pu1_col_zero_flag
2056 + u2_sub_mb_ofst + increment;
2057 uc_colMbPredMode_bot_mb = (*puc_colZeroFlagStart_bot_mb >> 6);
2058
2059 i4_force_8X8 = (u1_col_mb_pred_mode & 0x2)
2060 || (uc_colMbPredMode_bot_mb & 0x2);
2061
2062 if(i4_force_8X8)
2063 {
2064 u1_num_blks = 2;
2065 partition_size = PRED_8x8;
2066 }
2067 else
2068 {
2069 partition_size = PRED_16x8;
2070 u1_num_blks = 1;
2071 }
2072 }
2073
2074 /*As this mb is derived from 2 Mbs, min no of partitions = 2*/
2075 for(i = 0; i < 2; i++)
2076 {
2077 for(uc_blk = 0; uc_blk < u1_num_blks; uc_blk++)
2078 {
2079 mv_index = u2_sub_mb_ofst + u1_sub_mb_num;
2080 mv_index += (u1_sub_mb_num & 0x7) ? 1 : 0;
2081
2082 ps_direct->i4_mv_indices[i1_num_partitions] = mv_index;
2083 ps_direct->i1_submb_num[i1_num_partitions] = u1_sub_mb_num;
2084 ps_direct->i1_partitionsize[i1_num_partitions] = partition_size;
2085 i1_num_partitions++;
2086
2087 u1_sub_mb_num += 2;
2088 }
2089 u1_sub_mb_num = 8; /* move to second half of Cur MB */
2090 u2_sub_mb_ofst += increment;/* move to next Colocated MB */
2091 }
2092 ps_direct->i1_num_partitions = i1_num_partitions;
2093 return;
2094 }
2095 else
2096 {
2097 UWORD8 u1_sub_mb_num_col;
2098 u1_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
2099 u1_sub_mb_num_col &= 0xb;
2100 u2_sub_mb_ofst += (u1_sub_mb_num >> 3) ? increment : 0;
2101
2102 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst + u1_sub_mb_num_col;
2103 ps_direct->i1_submb_num[0] = u1_sub_mb_num;
2104 ps_direct->i1_partitionsize[0] = PRED_8x8;
2105 ps_direct->i1_num_partitions = 1;
2106 return;
2107 }
2108 }
2109 /*!
2110 **************************************************************************
2111 * \if Function name : ih264d_fld_to_frm \endif
2112 *
2113 * \brief
2114 * Initializes forward and backward refernce lists for B slice decoding.
2115 *
2116 *
2117 * \return
2118 * 0 on Success and Error code otherwise
2119 **************************************************************************
2120 */
ih264d_fld_to_frm(dec_struct_t * ps_dec,struct pic_buffer_t * ps_col_pic,directmv_t * ps_direct,UWORD8 u1_wd_x,WORD32 u2_sub_mb_ofst,dec_mb_info_t * ps_cur_mb_info)2121 void ih264d_fld_to_frm(dec_struct_t *ps_dec,
2122 struct pic_buffer_t *ps_col_pic,
2123 directmv_t *ps_direct,
2124 UWORD8 u1_wd_x,
2125 WORD32 u2_sub_mb_ofst,
2126 dec_mb_info_t * ps_cur_mb_info)
2127 {
2128 UWORD8 *pu1_col_zero_flag_start, *pu1_col_zero_flag,
2129 *pu1_col_zero_flag_right_half, u1_sub_mb_num, uc_sub_mb_num_col;
2130 UWORD8 u1_col_mb_pred_mode, uc_blk;
2131 WORD32 i4_force_8X8;
2132
2133 UNUSED(ps_cur_mb_info);
2134 ps_direct->u1_vert_mv_scale = FLD_TO_FRM;
2135 ps_direct->u1_col_zeroflag_change = 1;
2136 /* new calculation specific to this function for u2_sub_mb_ofst*/
2137 u2_sub_mb_ofst = (ps_dec->u2_mbx
2138 + ((ps_dec->u2_mby >> 1) * ps_dec->u2_frm_wd_in_mbs)) << 4;
2139 u2_sub_mb_ofst += ((ps_dec->u2_mby & 1) << 3);
2140
2141 if(u1_wd_x == MB_SIZE)
2142 {
2143 pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;
2144 u1_col_mb_pred_mode = (*pu1_col_zero_flag_start >> 6);
2145 ps_dec->u1_currB_type = (!!u1_col_mb_pred_mode);
2146
2147 if(u1_col_mb_pred_mode & 0x2)
2148 {
2149 if(u1_col_mb_pred_mode == PRED_8x16)
2150 {
2151 ps_direct->i1_num_partitions = 2;
2152 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
2153 ps_direct->i1_submb_num[0] = 0;
2154 ps_direct->i1_partitionsize[0] = PRED_8x16;
2155 ps_direct->i4_mv_indices[1] = u2_sub_mb_ofst + 2;
2156 ps_direct->i1_submb_num[1] = 2;
2157 ps_direct->i1_partitionsize[1] = PRED_8x16;
2158 }
2159 else
2160 {
2161 UWORD8 i1_num_partitions = 0, partition_size;
2162 UWORD32 mv_index;
2163 UWORD8 u1_num_sub_blks, i, u1_col_sub_mb_pred_mode,
2164 u1_col_sub_mb_pred_mode_rt;
2165
2166 u1_sub_mb_num = ps_dec->u1_sub_mb_num;
2167
2168 pu1_col_zero_flag = pu1_col_zero_flag_start + u1_sub_mb_num;
2169 u1_col_sub_mb_pred_mode = (*pu1_col_zero_flag & 0x10);/* 8x4 or 4x4 mode */
2170
2171 pu1_col_zero_flag_right_half = pu1_col_zero_flag_start + u1_sub_mb_num
2172 + 2;
2173 u1_col_sub_mb_pred_mode_rt = (*pu1_col_zero_flag_right_half
2174 & 0x10);/* 8x4 or 4x4 mode */
2175
2176 i4_force_8X8 = (u1_col_sub_mb_pred_mode)
2177 || (u1_col_sub_mb_pred_mode_rt);
2178 if(i4_force_8X8)
2179 {
2180 u1_num_sub_blks = 2;
2181 partition_size = PRED_8x8;
2182 }
2183 else
2184 {
2185 partition_size = PRED_8x16;
2186 u1_num_sub_blks = 1;
2187 }
2188
2189 for(i = 0; i < 2; i++)
2190 {
2191 for(uc_blk = 0; uc_blk < u1_num_sub_blks; uc_blk++)
2192 {
2193 uc_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
2194 uc_sub_mb_num_col &= 0x7;
2195 mv_index = u2_sub_mb_ofst + uc_sub_mb_num_col;
2196
2197 ps_direct->i4_mv_indices[i1_num_partitions] = mv_index;
2198 ps_direct->i1_submb_num[i1_num_partitions] =
2199 u1_sub_mb_num;
2200 ps_direct->i1_partitionsize[i1_num_partitions] =
2201 partition_size;
2202 i1_num_partitions++;
2203 u1_sub_mb_num += 8;
2204 }
2205
2206 u1_sub_mb_num = 2; /* move to second half of Cur MB */
2207
2208 }
2209 ps_direct->i1_num_partitions = i1_num_partitions;
2210 return;
2211 }
2212 }
2213 else
2214 {
2215 ps_direct->i1_num_partitions = 1;
2216 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
2217 ps_direct->i1_submb_num[0] = 0;
2218 ps_direct->i1_partitionsize[0] = PRED_16x16;
2219 return;
2220 }
2221 }
2222 else
2223 {
2224 u1_sub_mb_num = ps_dec->u1_sub_mb_num;
2225 uc_sub_mb_num_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
2226 uc_sub_mb_num_col &= 0x7;
2227
2228 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst + uc_sub_mb_num_col;
2229 ps_direct->i1_submb_num[0] = u1_sub_mb_num;
2230 ps_direct->i1_partitionsize[0] = PRED_8x8;
2231 ps_direct->i1_num_partitions = 1;
2232 }
2233 }
2234 /*!
2235 **************************************************************************
2236 * \if Function name : ih264d_one_to_one \endif
2237 *
2238 * \brief
2239 * Initializes forward and backward refernce lists for B slice decoding.
2240 *
2241 *
2242 * \return
2243 * 0 on Success and Error code otherwise
2244 **************************************************************************
2245 */
ih264d_mbaff_to_fld(dec_struct_t * ps_dec,struct pic_buffer_t * ps_col_pic,directmv_t * ps_direct,UWORD8 u1_wd_x,WORD32 u2_sub_mb_ofst,dec_mb_info_t * ps_cur_mb_info)2246 void ih264d_mbaff_to_fld(dec_struct_t *ps_dec,
2247 struct pic_buffer_t *ps_col_pic,
2248 directmv_t *ps_direct,
2249 UWORD8 u1_wd_x,
2250 WORD32 u2_sub_mb_ofst,
2251 dec_mb_info_t * ps_cur_mb_info)
2252 {
2253 UWORD8* pu1_col_zero_flag, u1_iscol_mb_fld;
2254 u2_sub_mb_ofst <<= 1;
2255 pu1_col_zero_flag = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;
2256 u1_iscol_mb_fld = (*pu1_col_zero_flag & 0x2) >> 1;
2257 if(u1_iscol_mb_fld)
2258 {
2259 u2_sub_mb_ofst += (ps_dec->ps_cur_slice->u1_bottom_field_flag << 4);
2260 ih264d_one_to_one(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2261 u2_sub_mb_ofst, ps_cur_mb_info);
2262 }
2263 else
2264 ih264d_frm_to_fld(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2265 u2_sub_mb_ofst, ps_cur_mb_info);
2266 }
2267 /*!
2268 **************************************************************************
2269 * \if Function name : ih264d_one_to_one \endif
2270 *
2271 * \brief
2272 * Initializes forward and backward refernce lists for B slice decoding.
2273 *
2274 *
2275 * \return
2276 * 0 on Success and Error code otherwise
2277 **************************************************************************
2278 */
ih264d_fld_to_mbaff(dec_struct_t * ps_dec,struct pic_buffer_t * ps_col_pic,directmv_t * ps_direct,UWORD8 u1_wd_x,WORD32 u2_sub_mb_ofst,dec_mb_info_t * ps_cur_mb_info)2279 void ih264d_fld_to_mbaff(dec_struct_t *ps_dec,
2280 struct pic_buffer_t *ps_col_pic,
2281 directmv_t *ps_direct,
2282 UWORD8 u1_wd_x,
2283 WORD32 u2_sub_mb_ofst,
2284 dec_mb_info_t * ps_cur_mb_info)
2285 {
2286 if((ps_col_pic->u1_picturetype & 0x7) == COMP_FLD_PAIR)
2287 {
2288 /* first calculate the colocated picture which varies with Mb */
2289 UWORD8 u1_is_cur_mb_fld;
2290 u1_is_cur_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag;
2291 u2_sub_mb_ofst = (u2_sub_mb_ofst & 0xffe0); /* mbaddrCol5 = curmbaddr/2;*/
2292 u2_sub_mb_ofst >>= 1;
2293
2294 ps_col_pic = ps_dec->ps_ref_pic_buf_lx[1][0];
2295 if(u1_is_cur_mb_fld)
2296 {
2297 if(1 - ps_cur_mb_info->u1_topmb)
2298 ps_col_pic = ps_dec->ps_ref_pic_buf_lx[1][MAX_REF_BUFS];
2299
2300 ih264d_one_to_one(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2301 u2_sub_mb_ofst, ps_cur_mb_info);
2302 }
2303 else
2304 {
2305
2306 if(ABS(ps_col_pic->i4_top_field_order_cnt
2307 - (WORD64)ps_dec->ps_cur_pic->i4_poc) >=
2308 ABS((WORD64)ps_dec->ps_cur_pic->i4_poc
2309 - ps_col_pic->i4_bottom_field_order_cnt))
2310 {
2311 ps_col_pic = ps_dec->ps_ref_pic_buf_lx[1][MAX_REF_BUFS];
2312 }
2313
2314 if(ps_cur_mb_info->u1_topmb == 0)
2315 u2_sub_mb_ofst += 8;
2316 ih264d_mbaff_cross_pmbair(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2317 u2_sub_mb_ofst, ps_cur_mb_info);
2318 }
2319 ps_dec->ps_col_pic = ps_col_pic;
2320 }
2321 else
2322 {
2323 UWORD8* pu1_col_zero_flag = ps_col_pic->pu1_col_zero_flag
2324 + u2_sub_mb_ofst;
2325 UWORD8 temp, u1_is_cur_mb_fld, u1_iscol_mb_fld;
2326
2327 u1_iscol_mb_fld = (*pu1_col_zero_flag & 0x2) >> 1;
2328 u1_is_cur_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag;
2329 temp = (u1_iscol_mb_fld ^ u1_is_cur_mb_fld);
2330
2331 if(temp == 0)
2332 ih264d_one_to_one(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2333 u2_sub_mb_ofst, ps_cur_mb_info);
2334 else
2335 {
2336 u2_sub_mb_ofst &= 0xffef;
2337 if(u1_is_cur_mb_fld == 0)
2338 {
2339 if(ABS(ps_col_pic->i4_top_field_order_cnt
2340 - (WORD64)ps_dec->ps_cur_pic->i4_poc) >=
2341 ABS((WORD64)ps_dec->ps_cur_pic->i4_poc
2342 - ps_col_pic->i4_bottom_field_order_cnt))
2343 {
2344 u2_sub_mb_ofst += 0x10;
2345 }
2346 if(ps_cur_mb_info->u1_topmb == 0)
2347 u2_sub_mb_ofst += 8;
2348 }
2349 ih264d_mbaff_cross_pmbair(ps_dec, ps_col_pic, ps_direct, u1_wd_x,
2350 u2_sub_mb_ofst, ps_cur_mb_info);
2351 }
2352 }
2353 }
2354
2355