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_pslice.c
23 *
24 * \brief
25 * Contains routines that decode a I 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_bitstrm.h"
41 #include "ih264d_defs.h"
42 #include "ih264d_debug.h"
43 #include "ih264d_structs.h"
44 #include "ih264d_defs.h"
45 #include "ih264d_parse_cavlc.h"
46 #include "ih264d_mb_utils.h"
47 #include "ih264d_deblocking.h"
48 #include "ih264d_dpb_manager.h"
49 #include "ih264d_mvpred.h"
50 #include "ih264d_inter_pred.h"
51 #include "ih264d_process_pslice.h"
52 #include "ih264d_error_handler.h"
53 #include "ih264d_cabac.h"
54 #include "ih264d_debug.h"
55 #include "ih264d_tables.h"
56 #include "ih264d_parse_slice.h"
57 #include "ih264d_utils.h"
58 #include "ih264d_parse_islice.h"
59 #include "ih264d_process_bslice.h"
60 #include "ih264d_process_intra_mb.h"
61
62 void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec);
63
ih264d_insert_pic_in_ref_pic_listx(struct pic_buffer_t * ps_ref_pic_buf_lx,struct pic_buffer_t * ps_pic)64 void ih264d_insert_pic_in_ref_pic_listx(struct pic_buffer_t *ps_ref_pic_buf_lx,
65 struct pic_buffer_t *ps_pic)
66 {
67 *ps_ref_pic_buf_lx = *ps_pic;
68 }
69
ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,UWORD8 u1_mb_idx,UWORD8 u1_num_mbs)70 WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
71 UWORD8 u1_mb_idx,
72 UWORD8 u1_num_mbs)
73 {
74 parse_pmbarams_t * ps_mb_part_info;
75 parse_part_params_t * ps_part;
76 mv_pred_t *ps_mv_nmb, *ps_mv_nmb_start, *ps_mv_ntop, *ps_mv_ntop_start;
77 UWORD32 i, j;
78 const UWORD32 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
79 dec_mb_info_t * ps_cur_mb_info;
80 WORD32 i2_mv_x, i2_mv_y;
81 WORD32 ret;
82
83 ps_dec->i4_submb_ofst -= (u1_num_mbs - u1_mb_idx) << 4;
84 ps_mb_part_info = ps_dec->ps_parse_mb_data; // + u1_mb_idx;
85 ps_part = ps_dec->ps_parse_part_params; // + u1_mb_idx;
86
87 /* N/2 Mb MvPred and Transfer Setup Loop */
88 for(i = u1_mb_idx; i < u1_num_mbs; i++, ps_mb_part_info++)
89 {
90 UWORD32 u1_colz;
91 UWORD32 u1_field;
92 mv_pred_t s_mvPred;
93 mv_pred_t *ps_mv_pred = &s_mvPred;
94
95
96
97 *ps_mv_pred = ps_dec->s_default_mv_pred;
98
99 ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
100
101 /* Restore the slice scratch MbX and MbY context */
102 ps_cur_mb_info = ps_dec->ps_nmb_info + i;
103 u1_field = ps_cur_mb_info->u1_mb_field_decodingflag;
104
105
106
107 ps_mv_nmb_start = ps_dec->ps_mv_cur + (i << 4);
108 ps_dec->u2_mbx = ps_cur_mb_info->u2_mbx;
109 ps_dec->u2_mby = ps_cur_mb_info->u2_mby;
110 ps_dec->u2_mv_2mb[i & 0x1] = 0;
111
112 /* Look for MV Prediction and Reference Transfer in Non-I Mbs */
113 if(!ps_mb_part_info->u1_isI_mb)
114 {
115 UWORD32 u1_blk_no;
116 WORD32 i1_ref_idx, i1_ref_idx1;
117 UWORD32 u1_sub_mb_x, u1_sub_mb_y, u1_sub_mb_num;
118 UWORD32 u1_num_part, u1_num_ref, u1_wd, u1_ht;
119 UWORD32 *pu4_wt_offst, **ppu4_wt_ofst;
120 UWORD32 u1_scale_ref, u4_bot_mb;
121 WORD8 *pi1_ref_idx = ps_mb_part_info->i1_ref_idx[0];
122 pic_buffer_t *ps_ref_frame, **pps_ref_frame;
123 deblk_mb_t * ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + i;
124
125 /* MB Level initialisations */
126 ps_dec->u4_num_pmbair = i >> u1_mbaff;
127 ps_dec->u1_mb_idx_mv = i;
128 ppu4_wt_ofst = ps_mb_part_info->pu4_wt_offst;
129 pps_ref_frame = ps_dec->ps_ref_pic_buf_lx[0];
130 /* CHANGED CODE */
131 ps_mv_ntop_start = ps_mv_nmb_start
132 - (ps_dec->u2_frm_wd_in_mbs << (4 + u1_mbaff)) + 12;
133
134 u1_num_part = ps_mb_part_info->u1_num_part;
135 ps_cur_deblk_mb->u1_mb_type |= (u1_num_part > 1) << 1;
136 ps_cur_mb_info->u4_pred_info_pkd_idx = ps_dec->u4_pred_info_pkd_idx;
137 ps_cur_mb_info->u1_num_pred_parts = 0;
138
139
140 /****************************************************/
141 /* weighted u4_ofst pointer calculations, this loop */
142 /* runs maximum 4 times, even in direct cases */
143 /****************************************************/
144 u1_scale_ref = u1_mbaff & u1_field;
145
146 u4_bot_mb = 1 - ps_cur_mb_info->u1_topmb;
147 if(ps_dec->ps_cur_pps->u1_wted_pred_flag)
148 {
149 u1_num_ref = MIN(u1_num_part, 4);
150 for(u1_blk_no = 0; u1_blk_no < u1_num_ref; u1_blk_no++)
151 {
152 i1_ref_idx = pi1_ref_idx[u1_blk_no];
153 if(u1_scale_ref)
154 i1_ref_idx >>= 1;
155 pu4_wt_offst = (UWORD32*)&ps_dec->pu4_wt_ofsts[2
156 * X3(i1_ref_idx)];
157 ppu4_wt_ofst[u1_blk_no] = pu4_wt_offst;
158 }
159 }
160 else
161 {
162 ppu4_wt_ofst[0] = NULL;
163 ppu4_wt_ofst[1] = NULL;
164 ppu4_wt_ofst[2] = NULL;
165 ppu4_wt_ofst[3] = NULL;
166 }
167
168 /**************************************************/
169 /* Loop on Partitions */
170 /**************************************************/
171 for(j = 0; j < u1_num_part; j++, ps_part++)
172 {
173
174 u1_sub_mb_num = ps_part->u1_sub_mb_num;
175 ps_dec->u1_sub_mb_num = u1_sub_mb_num;
176
177 if(PART_NOT_DIRECT != ps_part->u1_is_direct)
178 {
179 /* Mb Skip Mode */
180 /* Setting the default and other members of MvPred Structure */
181 s_mvPred.i2_mv[2] = -1;
182 s_mvPred.i2_mv[3] = -1;
183 s_mvPred.i1_ref_frame[0] = 0;
184 i1_ref_idx = (u1_scale_ref && u4_bot_mb) ? MAX_REF_BUFS : 0;
185 ps_ref_frame = pps_ref_frame[i1_ref_idx];
186 s_mvPred.u1_col_ref_pic_idx = ps_ref_frame->u1_mv_buf_id;
187 s_mvPred.u1_pic_type = ps_ref_frame->u1_pic_type;
188 pu4_wt_offst = (UWORD32*)&ps_dec->pu4_wt_ofsts[0];
189
190 ps_dec->pf_mvpred(ps_dec, ps_cur_mb_info, ps_mv_nmb_start,
191 ps_mv_ntop_start, &s_mvPred, 0, 4, 0, 1,
192 MB_SKIP);
193
194
195
196
197
198
199 {
200 pred_info_pkd_t *ps_pred_pkd;
201 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
202 ih264d_fill_pred_info (s_mvPred.i2_mv,4,4,0,PRED_L0,ps_pred_pkd,ps_ref_frame->u1_pic_buf_id,
203 (i1_ref_idx >> u1_scale_ref),pu4_wt_offst,
204 ps_ref_frame->u1_pic_type);
205
206
207 ps_dec->u4_pred_info_pkd_idx++;
208 ps_cur_mb_info->u1_num_pred_parts++;
209 }
210
211
212
213 /* Storing colocated zero information */
214 u1_colz = ((ABS(s_mvPred.i2_mv[0]) <= 1)
215 && (ABS(s_mvPred.i2_mv[1]) <= 1))
216 + (u1_field << 1);
217
218 ih264d_rep_mv_colz(ps_dec, &s_mvPred, ps_mv_nmb_start, 0,
219 u1_colz, 4, 4);
220 }
221 else
222 {
223 u1_sub_mb_x = u1_sub_mb_num & 0x03;
224 u1_sub_mb_y = u1_sub_mb_num >> 2;
225 u1_blk_no =
226 (u1_num_part < 4) ?
227 j :
228 (((u1_sub_mb_y >> 1) << 1)
229 + (u1_sub_mb_x
230 >> 1));
231
232 ps_mv_ntop = ps_mv_ntop_start + u1_sub_mb_x;
233 ps_mv_nmb = ps_mv_nmb_start + u1_sub_mb_num;
234
235 u1_wd = ps_part->u1_partwidth;
236 u1_ht = ps_part->u1_partheight;
237
238 /* Populate the colpic info and reference frames */
239 i1_ref_idx = pi1_ref_idx[u1_blk_no];
240 s_mvPred.i1_ref_frame[0] = i1_ref_idx;
241
242 /********************************************************/
243 /* Predict Mv */
244 /* Add Mv Residuals and store back */
245 /********************************************************/
246 ps_dec->pf_mvpred(ps_dec, ps_cur_mb_info, ps_mv_nmb, ps_mv_ntop,
247 &s_mvPred, u1_sub_mb_num, u1_wd, 0, 1,
248 ps_cur_mb_info->u1_mb_mc_mode);
249 i2_mv_x = ps_mv_nmb->i2_mv[0];
250 i2_mv_y = ps_mv_nmb->i2_mv[1];
251 i2_mv_x += s_mvPred.i2_mv[0];
252 i2_mv_y += s_mvPred.i2_mv[1];
253 s_mvPred.i2_mv[0] = i2_mv_x;
254 s_mvPred.i2_mv[1] = i2_mv_y;
255
256 /********************************************************/
257 /* Transfer setup call */
258 /* convert RefIdx if it is MbAff */
259 /* Pass Weight Offset and refFrame */
260 /********************************************************/
261 i1_ref_idx1 = i1_ref_idx >> u1_scale_ref;
262 if(u1_scale_ref && ((i1_ref_idx & 0x01) != u4_bot_mb))
263 i1_ref_idx1 += MAX_REF_BUFS;
264 ps_ref_frame = pps_ref_frame[i1_ref_idx1];
265 pu4_wt_offst = ppu4_wt_ofst[u1_blk_no];
266
267
268
269
270
271
272 {
273 pred_info_pkd_t *ps_pred_pkd;
274 ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
275 ih264d_fill_pred_info (s_mvPred.i2_mv,u1_wd,u1_ht,u1_sub_mb_num,PRED_L0,ps_pred_pkd,
276 ps_ref_frame->u1_pic_buf_id,(i1_ref_idx >> u1_scale_ref),pu4_wt_offst,
277 ps_ref_frame->u1_pic_type);
278
279 ps_dec->u4_pred_info_pkd_idx++;
280 ps_cur_mb_info->u1_num_pred_parts++;
281 }
282
283
284
285 /* Fill colocated info in MvPred structure */
286 s_mvPred.u1_col_ref_pic_idx = ps_ref_frame->u1_mv_buf_id;
287 s_mvPred.u1_pic_type = ps_ref_frame->u1_pic_type;
288
289 /* Calculating colocated zero information */
290 u1_colz =
291 (u1_field << 1)
292 | ((i1_ref_idx == 0)
293 && (ABS(i2_mv_x)
294 <= 1)
295 && (ABS(i2_mv_y)
296 <= 1));
297 u1_colz |= ps_mb_part_info->u1_col_info[u1_blk_no];
298
299 /* Replicate the motion vectors and colzero u4_flag */
300 /* for all sub-partitions */
301
302 ih264d_rep_mv_colz(ps_dec, &s_mvPred, ps_mv_nmb,
303 u1_sub_mb_num, u1_colz, u1_ht,
304 u1_wd);
305 }
306 }
307
308 }
309 else
310 {
311 /* Storing colocated zero information */
312 ih264d_rep_mv_colz(ps_dec, &s_mvPred, ps_mv_nmb_start, 0,
313 (UWORD8)(u1_field << 1), 4, 4);
314
315 }
316 /*if num _cores is set to 3,compute bs will be done in another thread*/
317 if(ps_dec->u4_num_cores < 3)
318 {
319
320 if(ps_dec->u4_app_disable_deblk_frm == 0)
321 ps_dec->pf_compute_bs(ps_dec, ps_cur_mb_info,
322 (UWORD16)(i >> u1_mbaff));
323 }
324 }
325
326
327
328 return OK;
329 }
330
331
ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,UWORD8 u1_mb_idx,UWORD8 u1_num_mbs,UWORD8 u1_num_mbs_next,UWORD8 u1_tfr_n_mb,UWORD8 u1_end_of_row)332 WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
333 UWORD8 u1_mb_idx,
334 UWORD8 u1_num_mbs,
335 UWORD8 u1_num_mbs_next,
336 UWORD8 u1_tfr_n_mb,
337 UWORD8 u1_end_of_row)
338 {
339 WORD32 i,j;
340 UWORD32 u1_end_of_row_next;
341 dec_mb_info_t * ps_cur_mb_info;
342 UWORD32 u4_update_mbaff = 0;
343 WORD32 ret;
344 const UWORD32 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
345 const UWORD32 u1_slice_type = ps_dec->ps_cur_slice->u1_slice_type;
346 const WORD32 u1_skip_th = (
347 (u1_slice_type != I_SLICE) ?
348 (ps_dec->u1_B ? B_8x8 : PRED_8x8R0) : -1);
349 const UWORD32 u1_ipcm_th = (
350 (u1_slice_type != I_SLICE) ? (ps_dec->u1_B ? 23 : 5) : 0);
351
352
353
354
355
356 /* N Mb MC Loop */
357 for(i = u1_mb_idx; i < u1_num_mbs; i++)
358 {
359 ps_cur_mb_info = ps_dec->ps_nmb_info + i;
360 ps_dec->u4_dma_buf_idx = 0;
361 ps_dec->u4_pred_info_idx = 0;
362
363 if(ps_cur_mb_info->u1_mb_type <= u1_skip_th)
364 {
365 {
366 WORD32 pred_cnt = 0;
367 pred_info_pkd_t *ps_pred_pkd;
368 UWORD32 u4_pred_info_pkd_idx;
369 WORD8 i1_pred;
370
371 u4_pred_info_pkd_idx = ps_cur_mb_info->u4_pred_info_pkd_idx;
372
373 while(pred_cnt < ps_cur_mb_info->u1_num_pred_parts)
374 {
375
376 ps_pred_pkd = ps_dec->ps_pred_pkd + u4_pred_info_pkd_idx;
377
378 ps_dec->p_form_mb_part_info(ps_pred_pkd,ps_dec,
379 ps_cur_mb_info->u2_mbx,ps_cur_mb_info->u2_mby,(i >> u1_mbaff),
380 ps_cur_mb_info);
381 u4_pred_info_pkd_idx++;
382 pred_cnt++;
383 }
384 }
385
386 ps_dec->p_motion_compensate(ps_dec, ps_cur_mb_info);
387
388 }
389 else if(ps_cur_mb_info->u1_mb_type == MB_SKIP)
390 {
391 {
392 WORD32 pred_cnt = 0;
393 pred_info_pkd_t *ps_pred_pkd;
394 UWORD32 u4_pred_info_pkd_idx;
395 WORD8 i1_pred;
396
397 u4_pred_info_pkd_idx = ps_cur_mb_info->u4_pred_info_pkd_idx;
398
399 while(pred_cnt < ps_cur_mb_info->u1_num_pred_parts)
400 {
401
402 ps_pred_pkd = ps_dec->ps_pred_pkd + u4_pred_info_pkd_idx;
403
404 ps_dec->p_form_mb_part_info(ps_pred_pkd,ps_dec,
405 ps_cur_mb_info->u2_mbx,ps_cur_mb_info->u2_mby,(i >> u1_mbaff),
406 ps_cur_mb_info);
407
408 u4_pred_info_pkd_idx++;
409 pred_cnt++;
410 }
411 }
412 /* Decode MB skip */
413 ps_dec->p_motion_compensate(ps_dec, ps_cur_mb_info);
414
415 }
416
417 }
418
419
420 /* N Mb IQ IT RECON Loop */
421 for(j = u1_mb_idx; j < i; j++)
422 {
423 ps_cur_mb_info = ps_dec->ps_nmb_info + j;
424
425 if(ps_cur_mb_info->u1_mb_type <= u1_skip_th)
426 {
427 ih264d_process_inter_mb(ps_dec, ps_cur_mb_info, j);
428
429 }
430 else if(ps_cur_mb_info->u1_mb_type != MB_SKIP)
431 {
432 if((u1_ipcm_th + 25) != ps_cur_mb_info->u1_mb_type)
433 {
434 ps_cur_mb_info->u1_mb_type -= (u1_skip_th + 1);
435 ih264d_process_intra_mb(ps_dec, ps_cur_mb_info, j);
436 }
437 }
438
439
440 if(ps_dec->u4_use_intrapred_line_copy)
441 {
442 ih264d_copy_intra_pred_line(ps_dec, ps_cur_mb_info, j);
443 }
444
445 }
446
447 /*N MB deblocking*/
448 if(ps_dec->u4_nmb_deblk == 1)
449 {
450
451 UWORD32 u4_cur_mb, u4_right_mb;
452 UWORD32 u4_mb_x, u4_mb_y;
453 UWORD32 u4_wd_y, u4_wd_uv;
454 tfr_ctxt_t *ps_tfr_cxt = &(ps_dec->s_tran_addrecon);
455 UWORD8 u1_field_pic_flag = ps_dec->ps_cur_slice->u1_field_pic_flag;
456 const WORD32 i4_cb_qp_idx_ofst =
457 ps_dec->ps_cur_pps->i1_chroma_qp_index_offset;
458 const WORD32 i4_cr_qp_idx_ofst =
459 ps_dec->ps_cur_pps->i1_second_chroma_qp_index_offset;
460
461 u4_wd_y = ps_dec->u2_frm_wd_y << u1_field_pic_flag;
462 u4_wd_uv = ps_dec->u2_frm_wd_uv << u1_field_pic_flag;
463
464
465 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_mb_idx;
466
467 ps_dec->u4_deblk_mb_x = ps_cur_mb_info->u2_mbx;
468 ps_dec->u4_deblk_mb_y = ps_cur_mb_info->u2_mby;
469
470 for(j = u1_mb_idx; j < i; j++)
471 {
472
473 ih264d_deblock_mb_nonmbaff(ps_dec, ps_tfr_cxt,
474 i4_cb_qp_idx_ofst, i4_cr_qp_idx_ofst,
475 u4_wd_y, u4_wd_uv);
476
477
478 }
479
480
481
482 }
483
484
485
486 if(u1_tfr_n_mb)
487 {
488 /****************************************************************/
489 /* Check for End Of Row in Next iteration */
490 /****************************************************************/
491 u1_end_of_row_next =
492 u1_num_mbs_next
493 && (u1_num_mbs_next
494 <= (ps_dec->u1_recon_mb_grp
495 >> u1_mbaff));
496
497 /****************************************************************/
498 /* Transfer the Following things */
499 /* N-Mb DeblkParams Data ( To Ext DeblkParams Buffer ) */
500 /* N-Mb Recon Data ( To Ext Frame Buffer ) */
501 /* N-Mb Intrapredline Data ( Updated Internally) */
502 /* N-Mb MV Data ( To Ext MV Buffer ) */
503 /* N-Mb MVTop/TopRight Data ( To Int MV Top Scratch Buffers) */
504 /****************************************************************/
505 ih264d_transfer_mb_group_data(ps_dec, u1_num_mbs, u1_end_of_row,
506 u1_end_of_row_next);
507 ps_dec->u4_num_mbs_prev_nmb = u1_num_mbs;
508
509 ps_dec->u4_pred_info_idx = 0;
510 ps_dec->u4_dma_buf_idx = 0;
511
512
513 }
514 return OK;
515 }
516
517 /*!
518 **************************************************************************
519 * \if Function name : ih264d_process_inter_mb \endif
520 *
521 * \brief
522 * This function decodes an Inter MB.
523 *
524 *
525 * \return
526 * 0 on Success and Error code otherwise
527 **************************************************************************
528 */
ih264d_process_inter_mb(dec_struct_t * ps_dec,dec_mb_info_t * ps_cur_mb_info,UWORD8 u1_mb_num)529 WORD32 ih264d_process_inter_mb(dec_struct_t * ps_dec,
530 dec_mb_info_t * ps_cur_mb_info,
531 UWORD8 u1_mb_num)
532 {
533 /* CHANGED CODE */
534 UWORD8 *pu1_rec_y, *pu1_rec_u, *pu1_rec_v;
535
536 /*CHANGED CODE */
537 UWORD32 ui_rec_width, u4_recwidth_cr;
538 WORD16 *pi2_y_coeff;
539 UWORD32 u1_mb_field_decoding_flag;
540 const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
541 UWORD32 uc_botMb;
542 UWORD32 u4_num_pmbair;
543 /* CHANGED CODE */
544 tfr_ctxt_t *ps_frame_buf = ps_dec->ps_frame_buf_ip_recon;
545 UWORD32 u4_luma_dc_only_csbp = 0;
546 UWORD32 u4_luma_dc_only_cbp = 0;
547 /* CHANGED CODE */
548
549 uc_botMb = 1 - ps_cur_mb_info->u1_topmb;
550 u4_num_pmbair = (u1_mb_num >> u1_mbaff);
551 u1_mb_field_decoding_flag = ps_cur_mb_info->u1_mb_field_decodingflag;
552
553
554 /* CHANGED CODE */
555 pu1_rec_y = ps_frame_buf->pu1_dest_y + (u4_num_pmbair << 4);
556 pu1_rec_u =
557 ps_frame_buf->pu1_dest_u
558 + (u4_num_pmbair << 3) * YUV420SP_FACTOR;
559 pu1_rec_v = ps_frame_buf->pu1_dest_v + (u4_num_pmbair << 3);
560 ui_rec_width = ps_dec->u2_frm_wd_y << u1_mb_field_decoding_flag;
561 u4_recwidth_cr = ps_dec->u2_frm_wd_uv << u1_mb_field_decoding_flag;
562
563 /* CHANGED CODE */
564
565 if(u1_mbaff)
566 {
567 if(uc_botMb)
568 {
569 pu1_rec_y += (u1_mb_field_decoding_flag ?
570 (ui_rec_width >> 1) : (ui_rec_width << 4));
571 pu1_rec_u += (u1_mb_field_decoding_flag ?
572 (u4_recwidth_cr >> 1) : (u4_recwidth_cr << 3));
573 pu1_rec_v += (u1_mb_field_decoding_flag ?
574 (u4_recwidth_cr >> 1) : (u4_recwidth_cr << 3));
575 }
576 }
577
578 if(!ps_cur_mb_info->u1_tran_form8x8)
579 {
580 u4_luma_dc_only_csbp = ih264d_unpack_luma_coeff4x4_mb(ps_dec,
581 ps_cur_mb_info,
582 0);
583 }
584 else
585 {
586 if(!ps_dec->ps_cur_pps->u1_entropy_coding_mode)
587 {
588 u4_luma_dc_only_cbp = ih264d_unpack_luma_coeff4x4_mb(ps_dec,
589 ps_cur_mb_info,
590 0);
591 }
592 else
593 {
594 u4_luma_dc_only_cbp = ih264d_unpack_luma_coeff8x8_mb(ps_dec,
595 ps_cur_mb_info);
596 }
597 }
598
599 pi2_y_coeff = ps_dec->pi2_coeff_data;
600 /* Inverse Transform and Reconstruction */
601 if(ps_cur_mb_info->u1_cbp & 0x0f)
602 {
603 /* CHANGED CODE */
604 if(!ps_cur_mb_info->u1_tran_form8x8)
605 {
606 UWORD32 i;
607 WORD16 ai2_tmp[16];
608 for(i = 0; i < 16; i++)
609 {
610 if(CHECKBIT(ps_cur_mb_info->u2_luma_csbp, i))
611 {
612 WORD16 *pi2_level = pi2_y_coeff + (i << 4);
613 UWORD8 *pu1_pred_sblk = pu1_rec_y + ((i & 0x3) * BLK_SIZE)
614 + (i >> 2) * (ui_rec_width << 2);
615 PROFILE_DISABLE_IQ_IT_RECON()
616 {
617 if(CHECKBIT(u4_luma_dc_only_csbp, i))
618 {
619 ps_dec->pf_iquant_itrans_recon_luma_4x4_dc(
620 pi2_level,
621 pu1_pred_sblk,
622 pu1_pred_sblk,
623 ui_rec_width,
624 ui_rec_width,
625 gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qp_rem6],
626 (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[3],
627 ps_cur_mb_info->u1_qp_div6, ai2_tmp, 0,
628 NULL);
629 }
630 else
631 {
632 ps_dec->pf_iquant_itrans_recon_luma_4x4(
633 pi2_level,
634 pu1_pred_sblk,
635 pu1_pred_sblk,
636 ui_rec_width,
637 ui_rec_width,
638 gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qp_rem6],
639 (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[3],
640 ps_cur_mb_info->u1_qp_div6, ai2_tmp, 0,
641 NULL);
642 }
643 }
644 }
645 }
646 }
647 else
648 {
649 WORD16 *pi2_scale_matrix_ptr;
650 WORD32 i;
651
652 pi2_scale_matrix_ptr =
653 ps_dec->s_high_profile.i2_scalinglist8x8[1];
654
655 for(i = 0; i < 4; i++)
656 {
657 WORD16 ai2_tmp[64];
658 WORD16 *pi16_levelBlock = pi2_y_coeff + (i << 6); /* move to the next 8x8 adding 64 */
659
660 UWORD8 *pu1_pred_sblk = pu1_rec_y + ((i & 0x1) * BLK8x8SIZE)
661 + (i >> 1) * (ui_rec_width << 3);
662 if(CHECKBIT(ps_cur_mb_info->u1_cbp, i))
663 {
664 PROFILE_DISABLE_IQ_IT_RECON()
665 {
666 if(CHECKBIT(u4_luma_dc_only_cbp, i))
667 {
668 ps_dec->pf_iquant_itrans_recon_luma_8x8_dc(
669 pi16_levelBlock,
670 pu1_pred_sblk,
671 pu1_pred_sblk,
672 ui_rec_width,
673 ui_rec_width,
674 gau1_ih264d_dequant8x8_cavlc[ps_cur_mb_info->u1_qp_rem6],
675 (UWORD16 *)pi2_scale_matrix_ptr,
676 ps_cur_mb_info->u1_qp_div6, ai2_tmp, 0,
677 NULL);
678 }
679 else
680 {
681 ps_dec->pf_iquant_itrans_recon_luma_8x8(
682 pi16_levelBlock,
683 pu1_pred_sblk,
684 pu1_pred_sblk,
685 ui_rec_width,
686 ui_rec_width,
687 gau1_ih264d_dequant8x8_cavlc[ps_cur_mb_info->u1_qp_rem6],
688 (UWORD16 *)pi2_scale_matrix_ptr,
689 ps_cur_mb_info->u1_qp_div6, ai2_tmp, 0,
690 NULL);
691 }
692 }
693 }
694 }
695
696 }
697 }
698
699 /* Decode Chroma Block */
700 ih264d_unpack_chroma_coeff4x4_mb(ps_dec,
701 ps_cur_mb_info);
702 /*--------------------------------------------------------------------*/
703 /* Chroma Blocks decoding */
704 /*--------------------------------------------------------------------*/
705 {
706 UWORD8 u1_chroma_cbp = (UWORD8)(ps_cur_mb_info->u1_cbp >> 4);
707
708 if(u1_chroma_cbp != CBPC_ALLZERO)
709 {
710 UWORD32 u4_scale_u = ps_cur_mb_info->u1_qpc_div6;
711 UWORD32 u4_scale_v = ps_cur_mb_info->u1_qpcr_div6;
712 UWORD16 u2_chroma_csbp = ps_cur_mb_info->u2_chroma_csbp;
713
714 pi2_y_coeff = ps_dec->pi2_coeff_data;
715
716 {
717 UWORD32 i;
718 WORD16 ai2_tmp[16];
719 for(i = 0; i < 4; i++)
720 {
721 WORD16 *pi2_level = pi2_y_coeff + (i << 4);
722 UWORD8 *pu1_pred_sblk = pu1_rec_u
723 + ((i & 0x1) * BLK_SIZE * YUV420SP_FACTOR)
724 + (i >> 1) * (u4_recwidth_cr << 2);
725 PROFILE_DISABLE_IQ_IT_RECON()
726 {
727 if(CHECKBIT(u2_chroma_csbp, i))
728 {
729 ps_dec->pf_iquant_itrans_recon_chroma_4x4(
730 pi2_level,
731 pu1_pred_sblk,
732 pu1_pred_sblk,
733 u4_recwidth_cr,
734 u4_recwidth_cr,
735 gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qpc_rem6],
736 (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[4],
737 u4_scale_u, ai2_tmp, pi2_level);
738 }
739 else if(pi2_level[0] != 0)
740 {
741 ps_dec->pf_iquant_itrans_recon_chroma_4x4_dc(
742 pi2_level,
743 pu1_pred_sblk,
744 pu1_pred_sblk,
745 u4_recwidth_cr,
746 u4_recwidth_cr,
747 gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qpc_rem6],
748 (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[4],
749 u4_scale_u, ai2_tmp, pi2_level);
750 }
751 }
752 }
753 }
754
755 pi2_y_coeff += MB_CHROM_SIZE;
756 u2_chroma_csbp >>= 4;
757
758 {
759 UWORD32 i;
760 WORD16 ai2_tmp[16];
761 for(i = 0; i < 4; i++)
762 {
763 WORD16 *pi2_level = pi2_y_coeff + (i << 4);
764 UWORD8 *pu1_pred_sblk = pu1_rec_u + 1
765 + ((i & 0x1) * BLK_SIZE * YUV420SP_FACTOR)
766 + (i >> 1) * (u4_recwidth_cr << 2);
767 PROFILE_DISABLE_IQ_IT_RECON()
768 {
769 if(CHECKBIT(u2_chroma_csbp, i))
770 {
771 ps_dec->pf_iquant_itrans_recon_chroma_4x4(
772 pi2_level,
773 pu1_pred_sblk,
774 pu1_pred_sblk,
775 u4_recwidth_cr,
776 u4_recwidth_cr,
777 gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qpcr_rem6],
778 (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[5],
779 u4_scale_v, ai2_tmp, pi2_level);
780 }
781 else if(pi2_level[0] != 0)
782 {
783 ps_dec->pf_iquant_itrans_recon_chroma_4x4_dc(
784 pi2_level,
785 pu1_pred_sblk,
786 pu1_pred_sblk,
787 u4_recwidth_cr,
788 u4_recwidth_cr,
789 gau2_ih264_iquant_scale_4x4[ps_cur_mb_info->u1_qpcr_rem6],
790 (UWORD16 *)ps_dec->s_high_profile.i2_scalinglist4x4[5],
791 u4_scale_v, ai2_tmp, pi2_level);
792 }
793 }
794 }
795 }
796 }
797 }
798 return (0);
799 }
800
801 /*!
802 **************************************************************************
803 * \if Function name : ih264d_parse_pred_weight_table \endif
804 *
805 * \brief
806 * Implements pred_weight_table() of 7.3.3.2.
807 *
808 * \return
809 * None
810 *
811 **************************************************************************
812 */
ih264d_parse_pred_weight_table(dec_slice_params_t * ps_cur_slice,dec_bit_stream_t * ps_bitstrm)813 WORD32 ih264d_parse_pred_weight_table(dec_slice_params_t * ps_cur_slice,
814 dec_bit_stream_t * ps_bitstrm)
815 {
816 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
817 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
818 WORD8 i, cont, lx;
819 UWORD8 uc_weight_flag;
820 UWORD32 *pui32_weight_offset_lx;
821 WORD16 c_weight, c_offset;
822 UWORD32 ui32_y_def_weight_ofst, ui32_cr_def_weight_ofst;
823 UWORD32 ui32_temp;
824 UWORD8 uc_luma_log2_weight_denom;
825 UWORD8 uc_chroma_log2_weight_denom;
826
827 /* Variables for error resilience checks */
828 UWORD32 u4_temp;
829 WORD32 i_temp;
830
831 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
832 if(u4_temp & MASK_LOG2_WEIGHT_DENOM)
833 {
834 return ERROR_PRED_WEIGHT_TABLE_T;
835 }
836 uc_luma_log2_weight_denom = u4_temp;
837 COPYTHECONTEXT("SH: luma_log2_weight_denom",uc_luma_log2_weight_denom);
838 ui32_y_def_weight_ofst = (1 << uc_luma_log2_weight_denom);
839
840 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
841 if(u4_temp & MASK_LOG2_WEIGHT_DENOM)
842 {
843 return ERROR_PRED_WEIGHT_TABLE_T;
844 }
845 uc_chroma_log2_weight_denom = u4_temp;
846 COPYTHECONTEXT("SH: chroma_log2_weight_denom",uc_chroma_log2_weight_denom);
847 ui32_cr_def_weight_ofst = (1 << uc_chroma_log2_weight_denom);
848
849 ps_cur_slice->u2_log2Y_crwd = uc_luma_log2_weight_denom
850 | (uc_chroma_log2_weight_denom << 8);
851
852 cont = (ps_cur_slice->u1_slice_type == B_SLICE);
853 lx = 0;
854 do
855 {
856 for(i = 0; i < ps_cur_slice->u1_num_ref_idx_lx_active[lx]; i++)
857 {
858 pui32_weight_offset_lx = ps_cur_slice->u4_wt_ofst_lx[lx][i];
859
860 uc_weight_flag = ih264d_get_bit_h264(ps_bitstrm);
861 pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
862 COPYTHECONTEXT("SH: luma_weight_l0_flag",uc_weight_flag);
863 if(uc_weight_flag)
864 {
865 i_temp = ih264d_sev(pu4_bitstrm_ofst,
866 pu4_bitstrm_buf);
867 if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
868 return ERROR_PRED_WEIGHT_TABLE_T;
869 c_weight = i_temp;
870 COPYTHECONTEXT("SH: luma_weight_l0",c_weight);
871
872 i_temp = ih264d_sev(pu4_bitstrm_ofst,
873 pu4_bitstrm_buf);
874 if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
875 return ERROR_PRED_WEIGHT_TABLE_T;
876 c_offset = i_temp;
877 COPYTHECONTEXT("SH: luma_offset_l0",c_offset);
878
879 ui32_temp = (c_offset << 16) | (c_weight & 0xFFFF);
880 pui32_weight_offset_lx[0] = ui32_temp;
881 }
882 else
883 {
884
885 pui32_weight_offset_lx[0] = ui32_y_def_weight_ofst;
886 }
887
888 {
889 WORD8 c_weightCb, c_weightCr, c_offsetCb, c_offsetCr;
890 uc_weight_flag = ih264d_get_bit_h264(ps_bitstrm);
891 pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
892 COPYTHECONTEXT("SH: chroma_weight_l0_flag",uc_weight_flag);
893 if(uc_weight_flag)
894 {
895 i_temp = ih264d_sev(pu4_bitstrm_ofst,
896 pu4_bitstrm_buf);
897 if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
898 return ERROR_PRED_WEIGHT_TABLE_T;
899 c_weightCb = i_temp;
900 COPYTHECONTEXT("SH: chroma_weight_l0",c_weightCb);
901
902 i_temp = ih264d_sev(pu4_bitstrm_ofst,
903 pu4_bitstrm_buf);
904 if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
905 return ERROR_PRED_WEIGHT_TABLE_T;
906 c_offsetCb = i_temp;
907 COPYTHECONTEXT("SH: chroma_weight_l0",c_offsetCb);
908
909 ui32_temp = (c_offsetCb << 16) | (c_weightCb & 0xFFFF);
910 pui32_weight_offset_lx[1] = ui32_temp;
911
912 i_temp = ih264d_sev(pu4_bitstrm_ofst,
913 pu4_bitstrm_buf);
914 if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
915 return ERROR_PRED_WEIGHT_TABLE_T;
916 c_weightCr = i_temp;
917 COPYTHECONTEXT("SH: chroma_weight_l0",c_weightCr);
918
919 i_temp = ih264d_sev(pu4_bitstrm_ofst,
920 pu4_bitstrm_buf);
921 if((i_temp + 128) & MASK_PRED_WEIGHT_OFFSET)
922 return ERROR_PRED_WEIGHT_TABLE_T;
923 c_offsetCr = i_temp;
924 COPYTHECONTEXT("SH: chroma_weight_l0",c_offsetCr);
925
926 ui32_temp = (c_offsetCr << 16) | (c_weightCr & 0xFFFF);
927 pui32_weight_offset_lx[2] = ui32_temp;
928 }
929 else
930 {
931 pui32_weight_offset_lx[1] = ui32_cr_def_weight_ofst;
932 pui32_weight_offset_lx[2] = ui32_cr_def_weight_ofst;
933 }
934 }
935 }
936 lx++;
937 }
938 while(cont--);
939
940 return OK;
941 }
942
943
944 /*****************************************************************************/
945 /* */
946 /* Function Name : ih264d_init_ref_idx_lx_p */
947 /* */
948 /* Description : This function initializes the reference picture L0 list */
949 /* for P slices as per section 8.2.4.2.1 and 8.2.4.2.2. */
950 /* */
951 /* Inputs : pointer to ps_dec struture */
952 /* Globals : NO */
953 /* Processing : arranges all the short term pictures according to */
954 /* pic_num in descending order starting from curr pic_num. */
955 /* and inserts it in L0 list followed by all Long term */
956 /* pictures in ascending order. */
957 /* */
958 /* Returns : void */
959 /* */
960 /* Issues : <List any issues or problems with this function> */
961 /* */
962 /* Revision History: */
963 /* */
964 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
965 /* 13 07 2002 Jay Draft */
966 /* */
967 /*****************************************************************************/
ih264d_init_ref_idx_lx_p(dec_struct_t * ps_dec)968 void ih264d_init_ref_idx_lx_p(dec_struct_t *ps_dec)
969 {
970 struct pic_buffer_t *ps_ref_pic_buf_lx;
971 dpb_manager_t *ps_dpb_mgr;
972 struct dpb_info_t *ps_next_dpb;
973 WORD8 i;
974 UWORD8 u1_max_lt_index, u1_min_lt_index, u1_lt_index;
975 UWORD8 u1_field_pic_flag;
976 dec_slice_params_t *ps_cur_slice;
977 UWORD8 u1_L0;
978 WORD32 i4_cur_pic_num, i4_min_st_pic_num;
979 WORD32 i4_temp_pic_num, i4_ref_pic_num;
980 UWORD8 u1_num_short_term_bufs;
981 UWORD8 u1_max_ref_idx_l0;
982
983 ps_cur_slice = ps_dec->ps_cur_slice;
984 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
985 u1_max_ref_idx_l0 = ps_cur_slice->u1_num_ref_idx_lx_active[0]
986 << u1_field_pic_flag;
987
988 ps_dpb_mgr = ps_dec->ps_dpb_mgr;
989 /* Get the current frame number */
990 i4_cur_pic_num = ps_dec->ps_cur_pic->i4_pic_num;
991
992 /* Get Min pic_num,MinLt */
993 i4_min_st_pic_num = i4_cur_pic_num;
994 u1_max_lt_index = MAX_REF_BUFS + 1;
995 u1_min_lt_index = MAX_REF_BUFS + 1;
996
997 /* Start from ST head */
998 ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head;
999 for(i = 0; i < ps_dpb_mgr->u1_num_st_ref_bufs; i++)
1000 {
1001 i4_ref_pic_num = ps_next_dpb->ps_pic_buf->i4_pic_num;
1002 if(i4_ref_pic_num < i4_cur_pic_num)
1003 {
1004 /* RefPic Buf pic_num is before Current pic_num in decode order */
1005 i4_min_st_pic_num = MIN(i4_min_st_pic_num, i4_ref_pic_num);
1006 }
1007
1008 /* Chase the next link */
1009 ps_next_dpb = ps_next_dpb->ps_prev_short;
1010 }
1011
1012 /* Start from LT head */
1013 ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head;
1014 if(ps_next_dpb)
1015 {
1016 u1_max_lt_index = ps_next_dpb->u1_lt_idx;
1017 u1_min_lt_index = ps_next_dpb->u1_lt_idx;
1018
1019 for(i = 0; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++)
1020 {
1021 u1_lt_index = ps_next_dpb->u1_lt_idx;
1022 u1_max_lt_index = (UWORD8)(MAX(u1_max_lt_index, u1_lt_index));
1023 u1_min_lt_index = (UWORD8)(MIN(u1_min_lt_index, u1_lt_index));
1024
1025 /* Chase the next link */
1026 ps_next_dpb = ps_next_dpb->ps_prev_long;
1027 }
1028 }
1029 /* 1. Initialize refIdxL0 */
1030 u1_L0 = 0;
1031 if(u1_field_pic_flag)
1032 {
1033 ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0];
1034 ps_ref_pic_buf_lx += MAX_REF_BUFS;
1035 i4_temp_pic_num = i4_cur_pic_num;
1036 }
1037 else
1038 {
1039 ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0];
1040 i4_temp_pic_num = i4_cur_pic_num;
1041 }
1042
1043 /* Arrange all short term buffers in output order as given by pic_num */
1044 /* Arrange pic_num's less than Curr pic_num in the descending pic_num */
1045 /* order starting from (Curr pic_num - 1) */
1046 for(; i4_temp_pic_num >= i4_min_st_pic_num; i4_temp_pic_num--)
1047 {
1048 /* Start from ST head */
1049 ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head;
1050 for(i = 0; i < ps_dpb_mgr->u1_num_st_ref_bufs; i++)
1051 {
1052 if((WORD32)ps_next_dpb->ps_pic_buf->i4_pic_num == i4_temp_pic_num)
1053 {
1054 /* Copy info in pic buffer */
1055 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1056 ps_next_dpb->ps_pic_buf);
1057 ps_ref_pic_buf_lx++;
1058 u1_L0++;
1059 break;
1060 }
1061 ps_next_dpb = ps_next_dpb->ps_prev_short;
1062 }
1063 }
1064
1065 /* Arrange all Long term buffers in ascending order, in LongtermIndex */
1066 /* Start from LT head */
1067 u1_num_short_term_bufs = u1_L0;
1068 for(u1_lt_index = u1_min_lt_index; u1_lt_index <= u1_max_lt_index;
1069 u1_lt_index++)
1070 {
1071 ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head;
1072 for(i = 0; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++)
1073 {
1074 if(ps_next_dpb->u1_lt_idx == u1_lt_index)
1075 {
1076 ih264d_insert_pic_in_ref_pic_listx(ps_ref_pic_buf_lx,
1077 ps_next_dpb->ps_pic_buf);
1078
1079 ps_ref_pic_buf_lx->u1_long_term_pic_num =
1080 ps_ref_pic_buf_lx->u1_long_term_frm_idx;
1081 ps_ref_pic_buf_lx++;
1082 u1_L0++;
1083 break;
1084 }
1085 ps_next_dpb = ps_next_dpb->ps_prev_long;
1086 }
1087 }
1088
1089 if(u1_field_pic_flag)
1090 {
1091 /* Initialize the rest of the entries in the */
1092 /* reference list to handle of errors */
1093 {
1094 UWORD8 u1_i;
1095 pic_buffer_t *ps_ref_pic;
1096
1097 ps_ref_pic = ps_dpb_mgr->ps_init_dpb[0][0] + MAX_REF_BUFS;
1098
1099 if(NULL == ps_ref_pic->pu1_buf1)
1100 {
1101 ps_ref_pic = ps_dec->ps_cur_pic;
1102 }
1103 for(u1_i = u1_L0; u1_i < u1_max_ref_idx_l0; u1_i++)
1104 {
1105 *ps_ref_pic_buf_lx = *ps_ref_pic;
1106 ps_ref_pic_buf_lx++;
1107 }
1108 }
1109
1110 ih264d_convert_frm_to_fld_list(
1111 ps_dpb_mgr->ps_init_dpb[0][0] + MAX_REF_BUFS, &u1_L0,
1112 ps_dec, u1_num_short_term_bufs);
1113
1114 ps_ref_pic_buf_lx = ps_dpb_mgr->ps_init_dpb[0][0] + u1_L0;
1115 }
1116
1117 /* Initialize the rest of the entries in the */
1118 /* reference list to handle of errors */
1119 {
1120 UWORD8 u1_i;
1121 pic_buffer_t *ps_ref_pic;
1122
1123 ps_ref_pic = ps_dpb_mgr->ps_init_dpb[0][0];
1124
1125 if(NULL == ps_ref_pic->pu1_buf1)
1126 {
1127 ps_ref_pic = ps_dec->ps_cur_pic;
1128 }
1129 for(u1_i = u1_L0; u1_i < u1_max_ref_idx_l0; u1_i++)
1130 {
1131 *ps_ref_pic_buf_lx = *ps_ref_pic;
1132 ps_ref_pic_buf_lx++;
1133 }
1134 }
1135 ps_dec->ps_cur_slice->u1_initial_list_size[0] = u1_L0;
1136 }
1137
1138