1 /******************************************************************************
2 *
3 * Copyright (C) 2022 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
23 * isvcd_process_bslice.c
24 *
25 * @brief
26 * Contains routines that decode B slice type
27 *
28 * @author
29 * Kishore
30 *
31 * @remarks
32 * None
33 *
34 *******************************************************************************
35 */
36
37 #include <string.h>
38 #include "ih264_typedefs.h"
39 #include "ih264_macros.h"
40 #include "ih264_platform_macros.h"
41 #include "isvcd_structs.h"
42 #include "ih264d_bitstrm.h"
43 #include "ih264d_parse_cavlc.h"
44 #include "ih264d_mb_utils.h"
45 #include "ih264d_mvpred.h"
46 #include "ih264d_inter_pred.h"
47 #include "ih264d_process_pslice.h"
48 #include "ih264d_error_handler.h"
49 #include "ih264d_tables.h"
50 #include "ih264d_parse_slice.h"
51 #include "ih264d_process_pslice.h"
52 #include "ih264d_process_bslice.h"
53 #include "ih264d_tables.h"
54 #include "ih264d_parse_islice.h"
55 #include "ih264d_mvpred.h"
56
57 /*!
58 **************************************************************************
59 * \if Function name : isvcd_one_to_one \endif
60 *
61 * \brief
62 * Initializes forward and backward refernce lists for B slice decoding.
63 *
64 *
65 * \return
66 * 0 on Success and Error code otherwise
67 **************************************************************************
68 */
isvcd_one_to_one(svc_dec_lyr_struct_t * ps_svc_lyr_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)69 void isvcd_one_to_one(svc_dec_lyr_struct_t *ps_svc_lyr_dec, struct pic_buffer_t *ps_col_pic,
70 directmv_t *ps_direct, UWORD8 u1_wd_x, WORD32 u2_sub_mb_ofst,
71 dec_mb_info_t *ps_cur_mb_info)
72 {
73 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
74 UWORD8 *pu1_col_zero_flag_start, u1_col_mb_pred_mode, u1_num_blks, u1_sub_mb_num;
75 UWORD8 u1_init_colzero_flag;
76 UNUSED(ps_cur_mb_info);
77 pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;
78 u1_col_mb_pred_mode = pu1_col_zero_flag_start[ps_dec->u1_sub_mb_num];
79 u1_init_colzero_flag = u1_col_mb_pred_mode & 1;
80 u1_col_mb_pred_mode >>= 6;
81 ps_direct->u1_vert_mv_scale = ONE_TO_ONE;
82 ps_direct->u1_col_zeroflag_change = (ps_svc_lyr_dec->u1_base_res_flag) ? 0 : 1;
83
84 if(u1_wd_x == MB_SIZE)
85 {
86 ps_dec->u1_currB_type = (!!u1_col_mb_pred_mode);
87 if(u1_col_mb_pred_mode == PRED_16x16)
88 {
89 ps_direct->i1_num_partitions = 1;
90 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
91 ps_direct->i1_submb_num[0] = 0;
92 ps_direct->i1_partitionsize[0] = PRED_16x16;
93
94 return;
95 }
96 else if(u1_col_mb_pred_mode < PRED_8x8)
97 {
98 ps_direct->i1_num_partitions = 2;
99 ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;
100 ps_direct->i1_submb_num[0] = 0;
101 ps_direct->i1_partitionsize[0] = u1_col_mb_pred_mode;
102 u1_sub_mb_num = (u1_col_mb_pred_mode == PRED_16x8) ? 8 : 2;
103 ps_direct->i1_submb_num[1] = u1_sub_mb_num;
104 ps_direct->i4_mv_indices[1] = u2_sub_mb_ofst + ps_direct->i1_submb_num[1];
105 ps_direct->i1_partitionsize[1] = u1_col_mb_pred_mode;
106 if((pu1_col_zero_flag_start[u1_sub_mb_num] & 1) != u1_init_colzero_flag)
107 ps_direct->u1_col_zeroflag_change = 1;
108 return;
109 }
110 else
111 {
112 u1_num_blks = 4;
113 }
114 }
115 else
116 {
117 u1_num_blks = 1;
118 }
119
120 {
121 const UWORD8 *pu1_top_lt_mb_part_idx;
122 UWORD8 u1_col_sub_mb_pred_mode, uc_blk, u1_sub_blk, u1_submb_col = 0;
123 UWORD8 u1_num_sub_blks, uc_direct8x8inf, *pu1_col_zero_flag, u1_sub_mb_num;
124 const UWORD8 *pu1_num_sub_mb_part = (const UWORD8 *) gau1_ih264d_num_submb_part;
125 UWORD8 i1_num_partitions = 0, partition_size;
126 WORD32 mv_index;
127 const UWORD8 *pu1_top_lt_sub_mb_idx = gau1_ih264d_submb_indx_mod_sp_drct;
128
129 u1_sub_mb_num = ps_dec->u1_sub_mb_num;
130 uc_direct8x8inf = ps_dec->ps_cur_slice->u1_direct_8x8_inference_flag;
131 pu1_top_lt_mb_part_idx = gau1_ih264d_top_left_mb_part_indx_mod + (PRED_8x8 << 1) + 1;
132
133 for(uc_blk = 0; uc_blk < u1_num_blks; uc_blk++)
134 {
135 partition_size = PRED_8x8;
136 pu1_top_lt_sub_mb_idx = gau1_ih264d_submb_indx_mod_sp_drct;
137 if(uc_direct8x8inf == 1)
138 {
139 u1_submb_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);
140 mv_index = u2_sub_mb_ofst + u1_submb_col;
141 u1_num_sub_blks = 1;
142 }
143 else
144 {
145 /* colMbPart is either 8x8, 8x4, 4x8, 4x4 */
146 pu1_col_zero_flag = pu1_col_zero_flag_start + u1_sub_mb_num;
147 u1_col_sub_mb_pred_mode = *pu1_col_zero_flag;
148 u1_col_sub_mb_pred_mode = (u1_col_sub_mb_pred_mode & 0x30) >> 4;
149 partition_size = (UWORD8) ((u1_col_sub_mb_pred_mode) | (PRED_8x8 << 2));
150 mv_index = u2_sub_mb_ofst + u1_sub_mb_num;
151 pu1_top_lt_sub_mb_idx += (u1_col_sub_mb_pred_mode << 1);
152 u1_num_sub_blks = pu1_num_sub_mb_part[u1_col_sub_mb_pred_mode];
153 }
154
155 for(u1_sub_blk = 0; u1_sub_blk < u1_num_sub_blks; u1_sub_blk++, pu1_top_lt_sub_mb_idx++)
156 {
157 u1_sub_mb_num += *pu1_top_lt_sub_mb_idx;
158 mv_index += *pu1_top_lt_sub_mb_idx;
159 ps_direct->i4_mv_indices[i1_num_partitions] = mv_index;
160 ps_direct->i1_submb_num[i1_num_partitions] = u1_sub_mb_num;
161 ps_direct->i1_partitionsize[i1_num_partitions] = partition_size;
162 i1_num_partitions++;
163 if(!uc_direct8x8inf) u1_submb_col = u1_sub_mb_num;
164 if((pu1_col_zero_flag_start[u1_submb_col] & 1) != u1_init_colzero_flag)
165 ps_direct->u1_col_zeroflag_change = 1;
166 }
167 u1_sub_mb_num = *pu1_top_lt_mb_part_idx++;
168 }
169 ps_direct->i1_num_partitions = i1_num_partitions;
170 }
171 }
172
173 /*!
174 **************************************************************************
175 * \if Function name : isvcd_decode_spatial_direct \endif
176 *
177 * \brief
178 * Decodes spatial direct mode.
179 *
180 * \return
181 * None.
182 * Vijay
183 **************************************************************************
184 */
isvcd_decode_spatial_direct(dec_struct_t * ps_dec,UWORD8 u1_wd_x,dec_mb_info_t * ps_cur_mb_info,UWORD8 u1_mb_num)185 WORD32 isvcd_decode_spatial_direct(dec_struct_t *ps_dec, UWORD8 u1_wd_x,
186 dec_mb_info_t *ps_cur_mb_info, UWORD8 u1_mb_num)
187 {
188 svc_dec_lyr_struct_t *ps_svc_lyr_dec = (svc_dec_lyr_struct_t *) ps_dec;
189 mv_pred_t s_mv_pred = {0};
190 mv_pred_t *ps_mv;
191 UWORD8 u1_col_zero_flag, u1_sub_mb_num, u1_direct_zero_pred_flag = 0;
192 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
193 mv_pred_t *ps_mv_ntop_start;
194 mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
195 UWORD8 partition_size, sub_partition, u1_mb_partw, u1_mb_parth;
196 UWORD8 i;
197 WORD8 i1_pred, i1_ref_frame0, i1_ref_frame1;
198 struct pic_buffer_t *ps_ref_frame = NULL, *ps_col_pic, *ps_pic_buff0 = NULL,
199 *ps_pic_buff1 = NULL;
200
201 UWORD8 u1_zero_pred_cond_f, u1_zero_pred_cond_b;
202 WORD16 i2_spat_pred_mv[4] = {0};
203 WORD16 *pi2_final_mv0, *pi2_final_mv1;
204 UWORD16 ui2_mask_fwd = 0, ui2_mask_bwd = 0;
205 UWORD32 *pui32_weight_ofsts = NULL;
206 directmv_t s_mvdirect = {0};
207 UWORD8 u1_colz;
208 UWORD8 u1_final_ref_idx = 0;
209 const UWORD8 *pu1_mb_parth = (const UWORD8 *) gau1_ih264d_mb_parth;
210 const UWORD8 *pu1_mb_partw = (const UWORD8 *) gau1_ih264d_mb_partw;
211
212 mv_pred_t s_temp_mv_pred = {0};
213 ps_mv_ntop_start =
214 ps_dec->ps_mv_cur + (u1_mb_num << 4) - (ps_dec->u2_frm_wd_in_mbs << (4 + u1_mbaff)) + 12;
215
216 u1_direct_zero_pred_flag =
217 ps_dec->pf_mvpred(ps_dec, ps_cur_mb_info, (ps_mv_nmb_start + ps_dec->u1_sub_mb_num),
218 ps_mv_ntop_start + (ps_dec->u1_sub_mb_num & 0x03), &s_mv_pred,
219 ps_dec->u1_sub_mb_num, (u1_wd_x >> 2), 0, 1, B_DIRECT_SPATIAL);
220
221 i2_spat_pred_mv[0] = s_mv_pred.i2_mv[0];
222 i2_spat_pred_mv[1] = s_mv_pred.i2_mv[1];
223 i2_spat_pred_mv[2] = s_mv_pred.i2_mv[2];
224 i2_spat_pred_mv[3] = s_mv_pred.i2_mv[3];
225
226 i1_ref_frame0 = s_mv_pred.i1_ref_frame[0];
227 i1_ref_frame1 = s_mv_pred.i1_ref_frame[1];
228
229 i1_ref_frame0 = (i1_ref_frame0 < 0) ? -1 : i1_ref_frame0;
230 i1_ref_frame1 = (i1_ref_frame1 < 0) ? -1 : i1_ref_frame1;
231
232 i1_pred = 0;
233
234 {
235 WORD8 u1_ref_idx, u1_ref_idx1;
236 UWORD32 uc_Idx, uc_Idx1;
237 UWORD8 u1_scale_ref =
238 (ps_dec->ps_cur_slice->u1_mbaff_frame_flag && ps_cur_mb_info->u1_mb_field_decodingflag);
239 u1_final_ref_idx = i1_ref_frame0;
240 if(i1_ref_frame0 >= 0)
241 {
242 /* convert RefIdx if it is MbAff */
243 u1_ref_idx = i1_ref_frame0;
244 u1_ref_idx1 = i1_ref_frame0;
245 if(u1_scale_ref)
246 {
247 u1_ref_idx1 = u1_ref_idx >> 1;
248 if((u1_ref_idx & 0x01) != (1 - ps_cur_mb_info->u1_topmb))
249 u1_ref_idx1 += MAX_REF_BUFS;
250 }
251 /* If i1_ref_frame0 < 0 then refIdxCol is obtained from ps_pic_buff1 */
252 ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][u1_ref_idx1];
253 ps_ref_frame = ps_pic_buff0;
254 i1_pred = PRED_L0;
255 }
256
257 if(i1_ref_frame1 >= 0)
258 {
259 /* convert RefIdx if it is MbAff */
260 u1_ref_idx = i1_ref_frame1;
261 u1_ref_idx1 = i1_ref_frame1;
262 if(u1_scale_ref)
263 {
264 u1_ref_idx1 = u1_ref_idx >> 1;
265 if((u1_ref_idx & 0x01) != (1 - ps_cur_mb_info->u1_topmb))
266 u1_ref_idx1 += MAX_REF_BUFS;
267 }
268 ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][u1_ref_idx1];
269 i1_pred = i1_pred | PRED_L1;
270 }
271 if(i1_ref_frame0 < 0)
272 {
273 ps_ref_frame = ps_pic_buff1;
274 u1_final_ref_idx = i1_ref_frame1;
275 }
276
277 u1_zero_pred_cond_f = (u1_direct_zero_pred_flag) || (i1_ref_frame0 < 0);
278 u1_zero_pred_cond_b = (u1_direct_zero_pred_flag) || (i1_ref_frame1 < 0);
279
280 if(ps_dec->ps_cur_pps->u1_wted_bipred_idc)
281 {
282 uc_Idx = ((i1_ref_frame0 < 1) ? 0 : i1_ref_frame0) *
283 ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1];
284 if(u1_scale_ref) uc_Idx >>= 1;
285 uc_Idx1 = (i1_ref_frame1 < 0) ? 0 : i1_ref_frame1;
286 uc_Idx += (u1_scale_ref) ? (uc_Idx1 >> 1) : uc_Idx1;
287 pui32_weight_ofsts = (UWORD32 *) &ps_dec->pu4_wt_ofsts[2 * X3(uc_Idx)];
288
289 if(i1_ref_frame0 < 0) pui32_weight_ofsts += 1;
290
291 if(u1_scale_ref && (ps_dec->ps_cur_pps->u1_wted_bipred_idc == 2))
292 {
293 WORD16 i2_ref_idx;
294 i2_ref_idx = MAX(i1_ref_frame0, 0);
295 i2_ref_idx *= (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1] << 1);
296 i2_ref_idx += MAX(i1_ref_frame1, 0);
297 if(!ps_cur_mb_info->u1_topmb)
298 i2_ref_idx += (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0] << 1) *
299 (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1] << 1);
300 pui32_weight_ofsts = (UWORD32 *) &ps_dec->pu4_mbaff_wt_mat[2 * X3(i2_ref_idx)];
301 }
302 }
303 }
304
305 s_temp_mv_pred.i1_ref_frame[0] = i1_ref_frame0;
306 s_temp_mv_pred.i1_ref_frame[1] = i1_ref_frame1;
307 s_temp_mv_pred.u1_col_ref_pic_idx = ps_ref_frame->u1_mv_buf_id;
308 s_temp_mv_pred.u1_pic_type = ps_ref_frame->u1_pic_type;
309
310 /**********************************************************************/
311 /* Call the function which gets the number of partitions and */
312 /* partition info of colocated Mb */
313 /**********************************************************************/
314
315 isvcd_one_to_one(ps_svc_lyr_dec, ps_dec->ps_col_pic, &s_mvdirect, u1_wd_x,
316 ps_dec->i4_submb_ofst, ps_cur_mb_info);
317
318 ps_col_pic = ps_dec->ps_col_pic;
319 if((s_mvdirect.u1_col_zeroflag_change == 0) || u1_direct_zero_pred_flag)
320 {
321 WORD16 i2_mv_x, i2_mv_y, i2_mvX1, i2_mvY1;
322 /* Most probable case */
323 u1_col_zero_flag = *(ps_col_pic->pu1_col_zero_flag + s_mvdirect.i4_mv_indices[0]);
324 u1_col_zero_flag = u1_col_zero_flag & 0x01;
325
326 if(u1_zero_pred_cond_f || ((i1_ref_frame0 == 0) && (u1_col_zero_flag == 1)))
327 {
328 i2_mv_x = 0;
329 i2_mv_y = 0;
330 }
331 else
332 {
333 i2_mv_x = i2_spat_pred_mv[0];
334 i2_mv_y = i2_spat_pred_mv[1];
335 }
336
337 if(u1_zero_pred_cond_b || ((i1_ref_frame1 == 0) && (u1_col_zero_flag == 1)))
338 {
339 i2_mvX1 = 0;
340 i2_mvY1 = 0;
341 }
342 else
343 {
344 i2_mvX1 = i2_spat_pred_mv[2];
345 i2_mvY1 = i2_spat_pred_mv[3];
346 }
347
348 u1_sub_mb_num = ps_dec->u1_sub_mb_num;
349 u1_mb_partw = (u1_wd_x >> 2);
350
351 if(i1_ref_frame0 >= 0)
352 {
353 {
354 pred_info_pkd_t *ps_pred_pkd;
355 WORD16 i2_mv[2];
356 WORD8 i1_ref_idx = 0;
357
358 i2_mv[0] = i2_mv_x;
359 i2_mv[1] = i2_mv_y;
360
361 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
362 ih264d_fill_pred_info(i2_mv, u1_mb_partw, u1_mb_partw, u1_sub_mb_num, i1_pred,
363 ps_pred_pkd, ps_pic_buff0->u1_pic_buf_id, i1_ref_idx,
364 pui32_weight_ofsts, ps_pic_buff0->u1_pic_type);
365 ps_dec->u4_pred_info_pkd_idx++;
366 ps_cur_mb_info->u1_num_pred_parts++;
367 }
368 }
369
370 if(i1_ref_frame1 >= 0)
371 {
372 {
373 pred_info_pkd_t *ps_pred_pkd;
374 WORD16 i2_mv[2];
375 WORD8 i1_ref_idx = 0;
376
377 i2_mv[0] = i2_mvX1;
378 i2_mv[1] = i2_mvY1;
379
380 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
381 ih264d_fill_pred_info(i2_mv, u1_mb_partw, u1_mb_partw, u1_sub_mb_num, i1_pred,
382 ps_pred_pkd, ps_pic_buff1->u1_pic_buf_id, i1_ref_idx,
383 pui32_weight_ofsts, ps_pic_buff1->u1_pic_type);
384 ps_dec->u4_pred_info_pkd_idx++;
385 ps_cur_mb_info->u1_num_pred_parts++;
386 }
387 }
388
389 /* Replication optimisation */
390 s_temp_mv_pred.i2_mv[0] = i2_mv_x;
391 s_temp_mv_pred.i2_mv[1] = i2_mv_y;
392 s_temp_mv_pred.i2_mv[2] = i2_mvX1;
393 s_temp_mv_pred.i2_mv[3] = i2_mvY1;
394
395 /* Calculating colocated zero information */
396 {
397 /*************************************/
398 /* If(bit2 and bit3 set) */
399 /* then */
400 /* (bit0 and bit1) => submmbmode */
401 /* (bit2 and bit3) => mbmode */
402 /* else */
403 /* (bit0 and bit1) => mbmode */
404 /*************************************/
405 /*UWORD8 u1_packed_mb_sub_mb_mode = sub_partition ?
406 (s_mvdirect.i1_partitionsize[0]) : ((s_mvdirect.i1_partitionsize[0]) <<
407 2);*/
408 UWORD8 u1_packed_mb_sub_mb_mode = (u1_mb_partw == 2) ? 0x03 : 0;
409
410 if(i1_ref_frame0 < 0)
411 {
412 i2_mv_x = i2_mvX1;
413 i2_mv_y = i2_mvY1;
414 }
415
416 /* Change from left shift 4 to 6 - Varun */
417 u1_colz = (ps_cur_mb_info->u1_mb_field_decodingflag << 1) |
418 ((u1_final_ref_idx == 0) && (ABS(i2_mv_x) <= 1) && (ABS(i2_mv_y) <= 1));
419 u1_colz |= (u1_packed_mb_sub_mb_mode << 6);
420 }
421 ps_mv = ps_mv_nmb_start + u1_sub_mb_num;
422 if(ps_mv)
423 {
424 ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz, u1_mb_partw,
425 u1_mb_partw);
426 }
427 else
428 {
429 return NOT_OK;
430 }
431
432 if(u1_wd_x == MB_SIZE) ps_dec->u1_currB_type = 0;
433
434 return OK;
435 }
436
437 /***************************************************************************/
438 /* If present MB is 16x16 and the partition of colocated Mb is >= PRED_8x8 */
439 /* i.e 8x8 or less than 8x8 partitions then set up DMA for (0,0) and */
440 /* spatially predicted motion vector and do the multiplexing after */
441 /* motion compensation */
442 /***************************************************************************/
443
444 if((u1_wd_x == MB_SIZE) && (s_mvdirect.i1_num_partitions > 2))
445 {
446 ps_cur_mb_info->u1_Mux = 1;
447 if(i1_ref_frame0 >= 0)
448 {
449 {
450 pred_info_pkd_t *ps_pred_pkd;
451 WORD8 i1_ref_idx = 0;
452
453 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
454 ih264d_fill_pred_info(&(i2_spat_pred_mv[0]), 4, 4, 0, i1_pred, ps_pred_pkd,
455 ps_pic_buff0->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts,
456 ps_pic_buff0->u1_pic_type);
457 ps_dec->u4_pred_info_pkd_idx++;
458 ps_cur_mb_info->u1_num_pred_parts++;
459 }
460
461 /****** (0,0) Motion vectors DMA *****/
462 {
463 pred_info_pkd_t *ps_pred_pkd;
464 WORD16 i2_mv[2];
465 WORD8 i1_ref_idx = 0;
466
467 i2_mv[0] = 0;
468 i2_mv[1] = 0;
469
470 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
471 ih264d_fill_pred_info(i2_mv, 4, 4, 0, i1_pred, ps_pred_pkd,
472 ps_pic_buff0->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts,
473 ps_pic_buff0->u1_pic_type);
474 ps_dec->u4_pred_info_pkd_idx++;
475 ps_cur_mb_info->u1_num_pred_parts++;
476 }
477 }
478 if(i1_ref_frame1 >= 0)
479 {
480 {
481 pred_info_pkd_t *ps_pred_pkd;
482 WORD8 i1_ref_idx = 0;
483
484 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
485 ih264d_fill_pred_info(&(i2_spat_pred_mv[2]), 4, 4, 0, i1_pred, ps_pred_pkd,
486 ps_pic_buff1->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts,
487 ps_pic_buff1->u1_pic_type);
488 ps_dec->u4_pred_info_pkd_idx++;
489 ps_cur_mb_info->u1_num_pred_parts++;
490 }
491
492 /****** (0,0) Motion vectors DMA *****/
493 {
494 pred_info_pkd_t *ps_pred_pkd;
495 WORD16 i2_mv[2];
496 WORD8 i1_ref_idx = 0;
497
498 i2_mv[0] = 0;
499 i2_mv[1] = 0;
500
501 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
502 ih264d_fill_pred_info(i2_mv, 4, 4, 0, i1_pred, ps_pred_pkd,
503 ps_pic_buff1->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts,
504 ps_pic_buff1->u1_pic_type);
505 ps_dec->u4_pred_info_pkd_idx++;
506 ps_cur_mb_info->u1_num_pred_parts++;
507 }
508 }
509 }
510
511 for(i = 0; i < s_mvdirect.i1_num_partitions; i++)
512 {
513 partition_size = s_mvdirect.i1_partitionsize[i];
514 u1_sub_mb_num = s_mvdirect.i1_submb_num[i];
515
516 sub_partition = partition_size >> 2;
517 partition_size &= 0x3;
518 u1_mb_partw = pu1_mb_partw[partition_size];
519 u1_mb_parth = pu1_mb_parth[partition_size];
520 if(sub_partition != 0)
521 {
522 u1_mb_partw >>= 1;
523 u1_mb_parth >>= 1;
524 }
525
526 u1_col_zero_flag = *(ps_col_pic->pu1_col_zero_flag + s_mvdirect.i4_mv_indices[i]);
527 u1_col_zero_flag = u1_col_zero_flag & 0x01;
528
529 /*if(u1_col != u1_col_zero_flag)
530 u1_init = 1;*/
531
532 pi2_final_mv0 = &i2_spat_pred_mv[0];
533 pi2_final_mv1 = &i2_spat_pred_mv[2];
534
535 if(ps_cur_mb_info->u1_Mux != 1)
536 {
537 if(i1_ref_frame0 >= 0)
538 {
539 {
540 pred_info_pkd_t *ps_pred_pkd;
541 WORD8 i1_ref_idx = 0;
542
543 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
544 ih264d_fill_pred_info(pi2_final_mv0, u1_mb_partw, u1_mb_parth, u1_sub_mb_num,
545 i1_pred, ps_pred_pkd, ps_pic_buff0->u1_pic_buf_id,
546 i1_ref_idx, pui32_weight_ofsts,
547 ps_pic_buff0->u1_pic_type);
548 ps_dec->u4_pred_info_pkd_idx++;
549 ps_cur_mb_info->u1_num_pred_parts++;
550 }
551 }
552
553 if(i1_ref_frame1 >= 0)
554 {
555 pred_info_pkd_t *ps_pred_pkd;
556 WORD8 i1_ref_idx = 0;
557
558 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
559 ih264d_fill_pred_info(pi2_final_mv1, u1_mb_partw, u1_mb_parth, u1_sub_mb_num,
560 i1_pred, ps_pred_pkd, ps_pic_buff1->u1_pic_buf_id, i1_ref_idx,
561 pui32_weight_ofsts, ps_pic_buff1->u1_pic_type);
562 ps_dec->u4_pred_info_pkd_idx++;
563 ps_cur_mb_info->u1_num_pred_parts++;
564 }
565 }
566
567 /* Replication optimisation */
568 s_temp_mv_pred.i2_mv[0] = pi2_final_mv0[0];
569 s_temp_mv_pred.i2_mv[1] = pi2_final_mv0[1];
570 s_temp_mv_pred.i2_mv[2] = pi2_final_mv1[0];
571 s_temp_mv_pred.i2_mv[3] = pi2_final_mv1[1];
572
573 /* Calculating colocated zero information */
574 {
575 WORD16 i2_mv_x = 0, i2_mv_y = 0;
576 /*************************************/
577 /* If(bit2 and bit3 set) */
578 /* then */
579 /* (bit0 and bit1) => submmbmode */
580 /* (bit2 and bit3) => mbmode */
581 /* else */
582 /* (bit0 and bit1) => mbmode */
583 /*************************************/
584 UWORD8 u1_packed_mb_sub_mb_mode = sub_partition
585 ? (s_mvdirect.i1_partitionsize[i])
586 : ((s_mvdirect.i1_partitionsize[i]) << 2);
587
588 if(i1_ref_frame0 >= 0)
589 {
590 i2_mv_x = pi2_final_mv0[0];
591 i2_mv_y = pi2_final_mv0[1];
592 }
593 else
594 {
595 i2_mv_x = pi2_final_mv1[0];
596 i2_mv_y = pi2_final_mv1[1];
597 }
598
599 u1_colz = (ps_cur_mb_info->u1_mb_field_decodingflag << 1) |
600 ((u1_final_ref_idx == 0) && (ABS(i2_mv_x) <= 1) && (ABS(i2_mv_y) <= 1));
601 u1_colz |= (u1_packed_mb_sub_mb_mode << 4);
602 }
603 ps_mv = ps_mv_nmb_start + u1_sub_mb_num;
604 if(ps_mv)
605 {
606 ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz, u1_mb_parth,
607 u1_mb_partw);
608 }
609 else
610 {
611 return NOT_OK;
612 }
613 }
614 i = 0;
615 if(i1_ref_frame0 >= 0) ps_cur_mb_info->u2_mask[i++] = ui2_mask_fwd;
616 if(i1_ref_frame1 >= 0) ps_cur_mb_info->u2_mask[i] = ui2_mask_bwd;
617
618 return OK;
619 }
620