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 **************************************************************************
23 * \file ih264d_parse_pslice.c
24 *
25 * \brief
26 * Contains routines that decode a I slice type
27 *
28 * Detailed_description
29 *
30 * \date
31 * 07/07/2003
32 *
33 * \author NS
34 **************************************************************************
35 */
36
37 #include <string.h>
38 #include "ih264_defs.h"
39 #include "ih264d_bitstrm.h"
40 #include "ih264d_defs.h"
41 #include "ih264d_debug.h"
42 #include "ih264d_tables.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_parse_slice.h"
48 #include "ih264d_mvpred.h"
49 #include "ih264d_parse_islice.h"
50 #include "ih264d_process_intra_mb.h"
51 #include "ih264d_inter_pred.h"
52 #include "ih264d_process_pslice.h"
53 #include "ih264d_deblocking.h"
54 #include "ih264d_cabac.h"
55 #include "ih264d_parse_mb_header.h"
56 #include "ih264d_error_handler.h"
57 #include "ih264d_defs.h"
58 #include "ih264d_format_conv.h"
59 #include "ih264d_quant_scaling.h"
60 #include "ih264d_thread_parse_decode.h"
61 #include "ih264d_thread_compute_bs.h"
62 #include "ih264d_process_bslice.h"
63 #include "ithread.h"
64 #include "ih264d_utils.h"
65 #include "ih264d_format_conv.h"
66
67 void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec);
68 void ih264d_deblock_mb_level(dec_struct_t *ps_dec,
69 dec_mb_info_t *ps_cur_mb_info,
70 UWORD32 nmb_index);
71
72 /*!
73 **************************************************************************
74 * \if Function name : ih264d_parse_pmb_cavlc \endif
75 *
76 * \brief
77 * This function parses CAVLC syntax of a P MB.
78 *
79 * \return
80 * 0 on Success and Error code otherwise
81 **************************************************************************
82 */
ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,dec_mb_info_t * ps_cur_mb_info,UWORD8 u1_mb_num,UWORD8 u1_num_mbsNby2)83 WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
84 dec_mb_info_t * ps_cur_mb_info,
85 UWORD8 u1_mb_num,
86 UWORD8 u1_num_mbsNby2)
87 {
88 UWORD32 u1_num_mb_part;
89 UWORD32 uc_sub_mb;
90 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
91 UWORD32 * const pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
92 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
93
94 parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
95 + u1_num_mbsNby2;
96 WORD8 * pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0];
97 const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
98 const UWORD8 * pu1_num_mb_part = (const UWORD8 *)gau1_ih264d_num_mb_part;
99 UWORD8 * pu1_col_info = ps_parse_mb_data->u1_col_info;
100
101 UWORD32 u1_mb_type = ps_cur_mb_info->u1_mb_type;
102 UWORD32 u4_sum_mb_mode_pack = 0;
103 WORD32 ret;
104
105 UWORD8 u1_no_submb_part_size_lt8x8_flag = 1;
106 ps_cur_mb_info->u1_tran_form8x8 = 0;
107 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
108
109 ps_cur_mb_info->u1_yuv_dc_block_flag = 0;
110
111 ps_cur_mb_info->u1_mb_mc_mode = u1_mb_type;
112 uc_sub_mb = ((u1_mb_type == PRED_8x8) | (u1_mb_type == PRED_8x8R0));
113
114 /* Reading the subMB type */
115 if(uc_sub_mb)
116 {
117 WORD32 i;
118 UWORD8 u1_colz = (PRED_8x8 << 6);
119
120 for(i = 0; i < 4; i++)
121 {
122 UWORD32 ui_sub_mb_mode;
123
124 //Inlined ih264d_uev
125 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
126 UWORD32 u4_word, u4_ldz;
127
128 /***************************************************************/
129 /* Find leading zeros in next 32 bits */
130 /***************************************************************/
131 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
132 u4_ldz = CLZ(u4_word);
133 /* Flush the ps_bitstrm */
134 u4_bitstream_offset += (u4_ldz + 1);
135 /* Read the suffix from the ps_bitstrm */
136 u4_word = 0;
137 if(u4_ldz)
138 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf,
139 u4_ldz);
140 *pu4_bitstrm_ofst = u4_bitstream_offset;
141 ui_sub_mb_mode = ((1 << u4_ldz) + u4_word - 1);
142 //Inlined ih264d_uev
143
144 if(ui_sub_mb_mode > 3)
145 {
146 return ERROR_SUB_MB_TYPE;
147 }
148 else
149 {
150 u4_sum_mb_mode_pack = (u4_sum_mb_mode_pack << 8) | ui_sub_mb_mode;
151 /* Storing collocated information */
152 *pu1_col_info++ = u1_colz | (UWORD8)(ui_sub_mb_mode << 4);
153
154 COPYTHECONTEXT("sub_mb_type", ui_sub_mb_mode);
155 }
156
157 /* check if Motion compensation is done below 8x8 */
158 if(ui_sub_mb_mode != P_L0_8x8)
159 {
160 u1_no_submb_part_size_lt8x8_flag = 0;
161 }
162 }
163
164 //
165 u1_num_mb_part = 4;
166 }
167 else
168 {
169 *pu1_col_info++ = (u1_mb_type << 6);
170 if(u1_mb_type)
171 *pu1_col_info++ = (u1_mb_type << 6);
172 u1_num_mb_part = pu1_num_mb_part[u1_mb_type];
173
174 }
175
176 /* Decoding reference index 0: For simple profile the following */
177 /* conditions are always true (mb_field_decoding_flag == 0); */
178 /* (MbPartPredMode != PredL1) */
179
180 {
181
182 UWORD8 uc_field = ps_cur_mb_info->u1_mb_field_decodingflag;
183 UWORD8 uc_num_ref_idx_l0_active_minus1 =
184 (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0]
185 << (u1_mbaff & uc_field)) - 1;
186
187 if((uc_num_ref_idx_l0_active_minus1 > 0) & (u1_mb_type != PRED_8x8R0))
188 {
189 if(1 == uc_num_ref_idx_l0_active_minus1)
190 ih264d_parse_pmb_ref_index_cavlc_range1(
191 u1_num_mb_part, ps_bitstrm, pi1_ref_idx,
192 uc_num_ref_idx_l0_active_minus1);
193 else
194 {
195 ret = ih264d_parse_pmb_ref_index_cavlc(
196 u1_num_mb_part, ps_bitstrm, pi1_ref_idx,
197 uc_num_ref_idx_l0_active_minus1);
198 if(ret != OK)
199 return ret;
200 }
201 }
202 else
203 {
204 /* When there exists only a single frame to predict from */
205 UWORD8 uc_i;
206 for(uc_i = 0; uc_i < u1_num_mb_part; uc_i++)
207 /* Storing Reference Idx Information */
208 pi1_ref_idx[uc_i] = 0;
209 }
210 }
211
212 {
213 UWORD8 u1_p_idx, uc_i;
214 parse_part_params_t * ps_part = ps_dec->ps_part;
215 UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height;
216 UWORD8 u1_sub_mb_num;
217 const UWORD8 * pu1_top_left_sub_mb_indx;
218 mv_pred_t * ps_mv, *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
219 /* Loading the table pointers */
220 const UWORD8 * pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw;
221 const UWORD8 * pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
222 const UWORD8 * pu1_sub_mb_indx_mod =
223 (const UWORD8 *)(gau1_ih264d_submb_indx_mod)
224 + (uc_sub_mb * 6);
225 const UWORD8 * pu1_sub_mb_partw = (const UWORD8 *)gau1_ih264d_submb_partw;
226 const UWORD8 * pu1_sub_mb_parth = (const UWORD8 *)gau1_ih264d_submb_parth;
227 const UWORD8 * pu1_num_sub_mb_part =
228 (const UWORD8 *)gau1_ih264d_num_submb_part;
229
230 UWORD16 u2_sub_mb_num = 0x028A;
231
232 /*********************************************************/
233 /* default initialisations for condition (uc_sub_mb == 0) */
234 /* i.e. all are subpartitions of 8x8 */
235 /*********************************************************/
236 u1_sub_mb_mode = 0;
237 u1_num_subpart = 1;
238 u1_mb_part_width = pu1_mb_partw[u1_mb_type];
239 u1_mb_part_height = pu1_mb_parth[u1_mb_type];
240 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1);
241 u1_sub_mb_num = 0;
242
243 /* Loop on number of partitions */
244 for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++)
245 {
246 UWORD8 uc_j;
247 if(uc_sub_mb)
248 {
249 u1_sub_mb_mode = u4_sum_mb_mode_pack >> 24;
250 u1_num_subpart = pu1_num_sub_mb_part[u1_sub_mb_mode];
251 u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode];
252 u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode];
253 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1);
254 u1_sub_mb_num = u2_sub_mb_num >> 12;
255 u4_sum_mb_mode_pack <<= 8;
256 u2_sub_mb_num <<= 4;
257 }
258
259 /* Loop on Number of sub-partitions */
260 for(uc_j = 0; uc_j < u1_num_subpart; uc_j++, pu1_top_left_sub_mb_indx++)
261 {
262 WORD16 i2_mvx, i2_mvy;
263 u1_sub_mb_num += *pu1_top_left_sub_mb_indx;
264 ps_mv = ps_mv_start + u1_sub_mb_num;
265
266 /* Reading the differential Mv from the bitstream */
267 //i2_mvx = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
268 //inlining ih264d_sev
269 {
270 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
271 UWORD32 u4_word, u4_ldz, u4_abs_val;
272
273 /***************************************************************/
274 /* Find leading zeros in next 32 bits */
275 /***************************************************************/
276 NEXTBITS_32(u4_word, u4_bitstream_offset,
277 pu4_bitstrm_buf);
278 u4_ldz = CLZ(u4_word);
279
280 /* Flush the ps_bitstrm */
281 u4_bitstream_offset += (u4_ldz + 1);
282
283 /* Read the suffix from the ps_bitstrm */
284 u4_word = 0;
285 if(u4_ldz)
286 GETBITS(u4_word, u4_bitstream_offset,
287 pu4_bitstrm_buf, u4_ldz);
288
289 *pu4_bitstrm_ofst = u4_bitstream_offset;
290 u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1;
291
292 if(u4_word & 0x1)
293 i2_mvx = (-(WORD32)u4_abs_val);
294 else
295 i2_mvx = (u4_abs_val);
296 }
297 //inlinined ih264d_sev
298 COPYTHECONTEXT("MVD", i2_mvx);
299 i2_mvy = ih264d_sev(pu4_bitstrm_ofst,
300 pu4_bitstrm_buf);
301 COPYTHECONTEXT("MVD", i2_mvy);
302
303 /* Storing Info for partitions */
304 ps_part->u1_is_direct = PART_NOT_DIRECT;
305 ps_part->u1_sub_mb_num = u1_sub_mb_num;
306 ps_part->u1_partheight = u1_mb_part_height;
307 ps_part->u1_partwidth = u1_mb_part_width;
308
309 /* Storing Mv residuals */
310 ps_mv->i2_mv[0] = i2_mvx;
311 ps_mv->i2_mv[1] = i2_mvy;
312
313 /* Increment partition Index */
314 u1_p_idx++;
315 ps_part++;
316 }
317 }
318 ps_parse_mb_data->u1_num_part = u1_p_idx;
319 ps_dec->ps_part = ps_part;
320 }
321
322 {
323 UWORD32 u4_cbp;
324
325 /* Read the Coded block pattern */
326 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
327 UWORD32 u4_word, u4_ldz;
328
329 /***************************************************************/
330 /* Find leading zeros in next 32 bits */
331 /***************************************************************/
332 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
333 u4_ldz = CLZ(u4_word);
334 /* Flush the ps_bitstrm */
335 u4_bitstream_offset += (u4_ldz + 1);
336 /* Read the suffix from the ps_bitstrm */
337 u4_word = 0;
338 if(u4_ldz)
339 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
340 *pu4_bitstrm_ofst = u4_bitstream_offset;
341 u4_cbp = ((1 << u4_ldz) + u4_word - 1);
342
343 if(u4_cbp > 47)
344 return ERROR_CBP;
345
346 u4_cbp = *((UWORD8*)gau1_ih264d_cbp_inter + u4_cbp);
347 COPYTHECONTEXT("coded_block_pattern", u4_cbp);
348 ps_cur_mb_info->u1_cbp = u4_cbp;
349
350 /* Read the transform8x8 u4_flag if present */
351 if((ps_dec->s_high_profile.u1_transform8x8_present) && (u4_cbp & 0xf)
352 && u1_no_submb_part_size_lt8x8_flag)
353 {
354 ps_cur_mb_info->u1_tran_form8x8 = ih264d_get_bit_h264(ps_bitstrm);
355 COPYTHECONTEXT("transform_size_8x8_flag", ps_cur_mb_info->u1_tran_form8x8);
356 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = ps_cur_mb_info->u1_tran_form8x8;
357 }
358
359 /* Read mb_qp_delta */
360 if(u4_cbp)
361 {
362 WORD32 i_temp;
363
364 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
365 UWORD32 u4_word, u4_ldz, u4_abs_val;
366
367 /***************************************************************/
368 /* Find leading zeros in next 32 bits */
369 /***************************************************************/
370 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
371 u4_ldz = CLZ(u4_word);
372
373 /* Flush the ps_bitstrm */
374 u4_bitstream_offset += (u4_ldz + 1);
375
376 /* Read the suffix from the ps_bitstrm */
377 u4_word = 0;
378 if(u4_ldz)
379 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf,
380 u4_ldz);
381
382 *pu4_bitstrm_ofst = u4_bitstream_offset;
383 u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1;
384
385 if(u4_word & 0x1)
386 i_temp = (-(WORD32)u4_abs_val);
387 else
388 i_temp = (u4_abs_val);
389
390 if((i_temp < -26) || (i_temp > 25))
391 return ERROR_INV_RANGE_QP_T;
392 //inlinined ih264d_sev
393
394 COPYTHECONTEXT("mb_qp_delta", i_temp);
395 if(i_temp)
396 {
397 ret = ih264d_update_qp(ps_dec, (WORD8)i_temp);
398 if(ret != OK)
399 return ret;
400 }
401
402 ret = ih264d_parse_residual4x4_cavlc(ps_dec, ps_cur_mb_info, 0);
403 if(ret != OK)
404 return ret;
405 if(EXCEED_OFFSET(ps_bitstrm))
406 return ERROR_EOB_TERMINATE_T;
407 }
408 else
409 {
410 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
411 }
412
413
414
415 }
416
417 return OK;
418 }
419
420 /*!
421 **************************************************************************
422 * \if Function name : ih264d_parse_pmb_cabac \endif
423 *
424 * \brief
425 * This function parses CABAC syntax of a P MB.
426 *
427 * \return
428 * 0 on Success and Error code otherwise
429 **************************************************************************
430 */
ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,dec_mb_info_t * ps_cur_mb_info,UWORD8 u1_mb_num,UWORD8 u1_num_mbsNby2)431 WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
432 dec_mb_info_t * ps_cur_mb_info,
433 UWORD8 u1_mb_num,
434 UWORD8 u1_num_mbsNby2)
435 {
436 UWORD32 u1_num_mb_part;
437 UWORD32 uc_sub_mb;
438 parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
439 + u1_num_mbsNby2;
440 WORD8 * pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0];
441 const UWORD8 * pu1_num_mb_part = (const UWORD8 *)gau1_ih264d_num_mb_part;
442 const UWORD32 u1_mb_type = ps_cur_mb_info->u1_mb_type;
443 UWORD8 * pu1_col_info = ps_parse_mb_data->u1_col_info;
444 UWORD32 u1_mb_mc_mode = u1_mb_type;
445 ctxt_inc_mb_info_t * p_curr_ctxt = ps_dec->ps_curr_ctxt_mb_info;
446 decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;
447 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
448 UWORD32 u4_sub_mb_pack = 0;
449 WORD32 ret;
450
451 UWORD8 u1_no_submb_part_size_lt8x8_flag = 1;
452 ps_cur_mb_info->u1_tran_form8x8 = 0;
453 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
454
455 ps_cur_mb_info->u1_yuv_dc_block_flag = 0;
456
457 p_curr_ctxt->u1_mb_type = CAB_P;
458 ps_cur_mb_info->u1_mb_mc_mode = u1_mb_type;
459 uc_sub_mb = ((u1_mb_type == PRED_8x8) | (u1_mb_type == PRED_8x8R0));
460
461 /* Reading the subMB type */
462 if(uc_sub_mb)
463 {
464
465 UWORD8 u1_colz = (PRED_8x8 << 6);
466 u1_mb_mc_mode = 0;
467
468 {
469 UWORD8 u1_sub_mb_mode;
470 u1_sub_mb_mode = ih264d_parse_submb_type_cabac(
471 0, ps_cab_env, ps_bitstrm,
472 ps_dec->p_sub_mb_type_t);
473 if(u1_sub_mb_mode > 3)
474 return ERROR_SUB_MB_TYPE;
475
476 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
477 /* Storing collocated information */
478 *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4));
479 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
480 /* check if Motion compensation is done below 8x8 */
481 if(u1_sub_mb_mode != P_L0_8x8)
482 {
483 u1_no_submb_part_size_lt8x8_flag = 0;
484 }
485 }
486 {
487 UWORD8 u1_sub_mb_mode;
488 u1_sub_mb_mode = ih264d_parse_submb_type_cabac(
489 0, ps_cab_env, ps_bitstrm,
490 ps_dec->p_sub_mb_type_t);
491 if(u1_sub_mb_mode > 3)
492 return ERROR_SUB_MB_TYPE;
493
494 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
495 /* Storing collocated information */
496 *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4));
497 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
498 /* check if Motion compensation is done below 8x8 */
499 if(u1_sub_mb_mode != P_L0_8x8)
500 {
501 u1_no_submb_part_size_lt8x8_flag = 0;
502 }
503 }
504 {
505 UWORD8 u1_sub_mb_mode;
506 u1_sub_mb_mode = ih264d_parse_submb_type_cabac(
507 0, ps_cab_env, ps_bitstrm,
508 ps_dec->p_sub_mb_type_t);
509 if(u1_sub_mb_mode > 3)
510 return ERROR_SUB_MB_TYPE;
511
512 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
513 /* Storing collocated information */
514 *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4));
515 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
516 /* check if Motion compensation is done below 8x8 */
517 if(u1_sub_mb_mode != P_L0_8x8)
518 {
519 u1_no_submb_part_size_lt8x8_flag = 0;
520 }
521 }
522 {
523 UWORD8 u1_sub_mb_mode;
524 u1_sub_mb_mode = ih264d_parse_submb_type_cabac(
525 0, ps_cab_env, ps_bitstrm,
526 ps_dec->p_sub_mb_type_t);
527 if(u1_sub_mb_mode > 3)
528 return ERROR_SUB_MB_TYPE;
529
530 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
531 /* Storing collocated information */
532 *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4));
533 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
534 /* check if Motion compensation is done below 8x8 */
535 if(u1_sub_mb_mode != P_L0_8x8)
536 {
537 u1_no_submb_part_size_lt8x8_flag = 0;
538 }
539 }
540 u1_num_mb_part = 4;
541 }
542 else
543 {
544 u1_num_mb_part = pu1_num_mb_part[u1_mb_type];
545 /* Storing collocated Mb and SubMb mode information */
546 *pu1_col_info++ = (u1_mb_type << 6);
547 if(u1_mb_type)
548 *pu1_col_info++ = (u1_mb_type << 6);
549 }
550 /* Decoding reference index 0: For simple profile the following */
551 /* conditions are always true (mb_field_decoding_flag == 0); */
552 /* (MbPartPredMode != PredL1) */
553 {
554 WORD8 * pi1_top_ref_idx_ctx_inc_arr = p_curr_ctxt->i1_ref_idx;
555 WORD8 * pi1_left_ref_idx_ctxt_inc = ps_dec->pi1_left_ref_idx_ctxt_inc;
556 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
557 UWORD8 uc_field = ps_cur_mb_info->u1_mb_field_decodingflag;
558 UWORD8 uc_num_ref_idx_l0_active_minus1 =
559 (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0]
560 << (u1_mbaff & uc_field)) - 1;
561
562 if((uc_num_ref_idx_l0_active_minus1 > 0) & (u1_mb_type != PRED_8x8R0))
563 {
564 /* force the routine to decode ref idx for each partition */
565 *((UWORD32 *)pi1_ref_idx) = 0x01010101;
566 ret = ih264d_parse_ref_idx_cabac(u1_num_mb_part, 0,
567 uc_num_ref_idx_l0_active_minus1,
568 u1_mb_mc_mode, pi1_ref_idx,
569 pi1_left_ref_idx_ctxt_inc,
570 pi1_top_ref_idx_ctx_inc_arr, ps_cab_env,
571 ps_bitstrm, ps_dec->p_ref_idx_t);
572 if(ret != OK)
573 return ret;
574 }
575 else
576 {
577 /* When there exists only a single frame to predict from */
578 pi1_left_ref_idx_ctxt_inc[0] = 0;
579 pi1_left_ref_idx_ctxt_inc[1] = 0;
580 pi1_top_ref_idx_ctx_inc_arr[0] = 0;
581 pi1_top_ref_idx_ctx_inc_arr[1] = 0;
582 *((UWORD32 *)pi1_ref_idx) = 0;
583 }
584 }
585
586 {
587 UWORD8 u1_p_idx, uc_i;
588 parse_part_params_t * ps_part = ps_dec->ps_part;
589 UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height;
590 UWORD8 u1_sub_mb_num;
591 const UWORD8 * pu1_top_left_sub_mb_indx;
592 mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
593 UWORD16 u2_sub_mb_num_pack = 0x028A;
594
595 /* Loading the table pointers */
596 const UWORD8 * pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw;
597 const UWORD8 * pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
598 const UWORD8 * pu1_sub_mb_indx_mod =
599 (const UWORD8 *)(gau1_ih264d_submb_indx_mod)
600 + (uc_sub_mb * 6);
601 const UWORD8 * pu1_sub_mb_partw = (const UWORD8 *)gau1_ih264d_submb_partw;
602 const UWORD8 * pu1_sub_mb_parth = (const UWORD8 *)gau1_ih264d_submb_parth;
603 const UWORD8 * pu1_num_sub_mb_part =
604 (const UWORD8 *)gau1_ih264d_num_submb_part;
605
606 /*********************************************************/
607 /* default initialisations for condition (uc_sub_mb == 0) */
608 /* i.e. all are subpartitions of 8x8 */
609 /*********************************************************/
610 u1_sub_mb_mode = 0;
611 u1_num_subpart = 1;
612 u1_mb_part_width = pu1_mb_partw[u1_mb_type];
613 u1_mb_part_height = pu1_mb_parth[u1_mb_type];
614 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1);
615 u1_sub_mb_num = 0;
616
617 /* Loop on number of partitions */
618 for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++)
619 {
620 UWORD8 uc_j;
621 if(uc_sub_mb)
622 {
623 u1_sub_mb_mode = u4_sub_mb_pack >> 24;
624 u1_num_subpart = pu1_num_sub_mb_part[u1_sub_mb_mode];
625 u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode];
626 u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode];
627 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1);
628 u1_sub_mb_num = u2_sub_mb_num_pack >> 12;
629 u4_sub_mb_pack <<= 8;
630 u2_sub_mb_num_pack <<= 4;
631 }
632 /* Loop on Number of sub-partitions */
633 for(uc_j = 0; uc_j < u1_num_subpart; uc_j++, pu1_top_left_sub_mb_indx++)
634 {
635 mv_pred_t * ps_mv;
636
637 u1_sub_mb_num += *pu1_top_left_sub_mb_indx;
638 ps_mv = ps_mv_start + u1_sub_mb_num;
639
640 /* Storing Info for partitions */
641 ps_part->u1_is_direct = PART_NOT_DIRECT;
642 ps_part->u1_sub_mb_num = u1_sub_mb_num;
643 ps_part->u1_partheight = u1_mb_part_height;
644 ps_part->u1_partwidth = u1_mb_part_width;
645
646 /* Increment partition Index */
647 u1_p_idx++;
648 ps_part++;
649
650 ih264d_get_mvd_cabac(u1_sub_mb_num, 0, u1_mb_part_width,
651 u1_mb_part_height, 1, ps_dec, ps_mv);
652 }
653 }
654 ps_parse_mb_data->u1_num_part = u1_p_idx;
655 ps_dec->ps_part = ps_part;
656 }
657 {
658 UWORD8 u1_cbp;
659
660 /* Read the Coded block pattern */
661 u1_cbp = (WORD8)ih264d_parse_ctx_cbp_cabac(ps_dec);
662 COPYTHECONTEXT("coded_block_pattern", u1_cbp);
663 ps_cur_mb_info->u1_cbp = u1_cbp;
664 p_curr_ctxt->u1_cbp = u1_cbp;
665 p_curr_ctxt->u1_intra_chroma_pred_mode = 0;
666 p_curr_ctxt->u1_yuv_dc_csbp &= 0xFE;
667 ps_dec->pu1_left_yuv_dc_csbp[0] &= 0x6;
668
669 if(u1_cbp > 47)
670 return ERROR_CBP;
671
672 ps_cur_mb_info->u1_tran_form8x8 = 0;
673 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
674
675 /* Read the transform8x8 u4_flag if present */
676 if((ps_dec->s_high_profile.u1_transform8x8_present) && (u1_cbp & 0xf)
677 && u1_no_submb_part_size_lt8x8_flag)
678 {
679 ps_cur_mb_info->u1_tran_form8x8 = ih264d_parse_transform8x8flag_cabac(
680 ps_dec, ps_cur_mb_info);
681 COPYTHECONTEXT("transform_size_8x8_flag", ps_cur_mb_info->u1_tran_form8x8);
682 p_curr_ctxt->u1_transform8x8_ctxt = ps_cur_mb_info->u1_tran_form8x8;
683 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = ps_cur_mb_info->u1_tran_form8x8;
684
685 }
686 else
687 {
688 p_curr_ctxt->u1_transform8x8_ctxt = 0;
689 }
690
691 /* Read mb_qp_delta */
692 if(u1_cbp)
693 {
694 WORD8 c_temp;
695 ret = ih264d_parse_mb_qp_delta_cabac(ps_dec, &c_temp);
696 if(ret != OK)
697 return ret;
698 COPYTHECONTEXT("mb_qp_delta", c_temp);
699 if(c_temp != 0)
700 {
701 ret = ih264d_update_qp(ps_dec, c_temp);
702 if(ret != OK)
703 return ret;
704 }
705 }
706 else
707 ps_dec->i1_prev_mb_qp_delta = 0;
708
709
710
711 ih264d_parse_residual4x4_cabac(ps_dec, ps_cur_mb_info, 0);
712 if(EXCEED_OFFSET(ps_dec->ps_bitstrm))
713 return ERROR_EOB_TERMINATE_T;
714 }
715 return OK;
716 }
717
718 /*!
719 **************************************************************************
720 * \if Function name : parsePSliceData \endif
721 *
722 * \brief
723 * This function parses CAVLC syntax of N MB's of a P slice.
724 * 1. After parsing syntax of N MB's, for those N MB's (less than N, incase
725 * of end of slice or end of row), MB is decoded. This process is carried
726 * for one complete MB row or till end of slice.
727 * 2. Bottom one row of current MB is copied to IntraPredLine buffers.
728 * IntraPredLine buffers are used for Intra prediction of next row.
729 * 3. Current MB row along with previous 4 rows of Luma (and 2 of Chroma) are
730 * deblocked.
731 * 4. 4 rows (2 for Chroma) previous row and 12 rows (6 for Chroma) are
732 * DMA'ed to picture buffers.
733 *
734 * \return
735 * 0 on Success and Error code otherwise
736 **************************************************************************
737 */
738
739 /*!
740 **************************************************************************
741 * \if Function name : ih264d_update_nnz_for_skipmb \endif
742 *
743 * \brief
744 *
745 * \return
746 * None
747 *
748 **************************************************************************
749 */
ih264d_update_nnz_for_skipmb(dec_struct_t * ps_dec,dec_mb_info_t * ps_cur_mb_info,UWORD8 u1_entrpy)750 void ih264d_update_nnz_for_skipmb(dec_struct_t * ps_dec,
751 dec_mb_info_t * ps_cur_mb_info,
752 UWORD8 u1_entrpy)
753 {
754 UWORD32 *pu4_buf;
755 UWORD8 *pu1_buf;
756 UNUSED(u1_entrpy);
757 pu1_buf = ps_dec->pu1_left_nnz_y;
758 pu4_buf = (UWORD32 *)pu1_buf;
759 *pu4_buf = 0;
760 pu1_buf = ps_dec->pu1_left_nnz_uv;
761 pu4_buf = (UWORD32 *)pu1_buf;
762 *pu4_buf = 0;
763 pu1_buf = ps_cur_mb_info->ps_curmb->pu1_nnz_y;
764 pu4_buf = (UWORD32 *)pu1_buf;
765 *pu4_buf = 0;
766 pu1_buf = ps_cur_mb_info->ps_curmb->pu1_nnz_uv;
767 pu4_buf = (UWORD32 *)pu1_buf;
768 *pu4_buf = 0;
769 ps_cur_mb_info->ps_curmb->u2_luma_csbp = 0;
770 ps_cur_mb_info->u2_luma_csbp = 0;
771 ps_cur_mb_info->u2_chroma_csbp = 0;
772 }
773
774
775
776 /*****************************************************************************/
777 /* */
778 /* Function Name : ih264d_parse_inter_slice_data_cabac */
779 /* */
780 /* Description : This function parses cabac syntax of a inter slice on */
781 /* N MB basis. */
782 /* */
783 /* Inputs : ps_dec */
784 /* sliceparams */
785 /* firstMbInSlice */
786 /* */
787 /* Processing : 1. After parsing syntax for N MBs those N MBs are */
788 /* decoded till the end of slice. */
789 /* 2. MV prediction and DMA happens on a N/2 MB basis. */
790 /* */
791 /* Returns : 0 */
792 /* */
793 /* Issues : <List any issues or problems with this function> */
794 /* */
795 /* Revision History: */
796 /* */
797 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
798 /* 13 07 2002 Jay Draft */
799 /* */
800 /*****************************************************************************/
ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,dec_slice_params_t * ps_slice,UWORD16 u2_first_mb_in_slice)801 WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
802 dec_slice_params_t * ps_slice,
803 UWORD16 u2_first_mb_in_slice)
804 {
805 UWORD32 uc_more_data_flag;
806 WORD32 i2_cur_mb_addr;
807 UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx;
808 UWORD32 u1_mbaff;
809 UWORD32 u1_num_mbs_next, u1_end_of_row;
810 const UWORD16 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
811 UWORD32 u1_slice_end = 0;
812 UWORD32 u1_tfr_n_mb = 0;
813 UWORD32 u1_decode_nmb = 0;
814
815
816 deblk_mb_t *ps_cur_deblk_mb;
817 dec_mb_info_t *ps_cur_mb_info;
818
819 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data;
820 UWORD32 u1_inter_mb_skip_type;
821 UWORD32 u1_inter_mb_type;
822 UWORD32 u1_deblk_mb_type;
823 UWORD32 u1_mb_threshold;
824 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
825 WORD32 ret = OK;
826
827 /******************************************************/
828 /* Initialisations specific to B or P slice */
829 /******************************************************/
830 if(ps_slice->u1_slice_type == P_SLICE)
831 {
832 u1_inter_mb_skip_type = CAB_P_SKIP;
833 u1_inter_mb_type = P_MB;
834 u1_deblk_mb_type = D_INTER_MB;
835 u1_mb_threshold = 5;
836 }
837 else // B_SLICE
838 {
839 u1_inter_mb_skip_type = CAB_B_SKIP;
840 u1_inter_mb_type = B_MB;
841 u1_deblk_mb_type = D_B_SLICE;
842 u1_mb_threshold = 23;
843 }
844
845 /******************************************************/
846 /* Slice Level Initialisations */
847 /******************************************************/
848 i2_cur_mb_addr = u2_first_mb_in_slice;
849 ps_dec->u1_qp = ps_slice->u1_slice_qp;
850 ih264d_update_qp(ps_dec, 0);
851 u1_mb_idx = ps_dec->u1_mb_idx;
852 u1_num_mbs = u1_mb_idx;
853 u1_num_mbsNby2 = 0;
854 u1_mbaff = ps_slice->u1_mbaff_frame_flag;
855 i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
856 uc_more_data_flag = 1;
857
858 /* Initialisations specific to cabac */
859 if(ps_bitstrm->u4_ofst & 0x07)
860 {
861 ps_bitstrm->u4_ofst += 8;
862 ps_bitstrm->u4_ofst &= 0xFFFFFFF8;
863 }
864
865 ret = ih264d_init_cabac_dec_envirnoment(&(ps_dec->s_cab_dec_env), ps_bitstrm);
866 if(ret != OK)
867 return ret;
868
869 ps_dec->i1_prev_mb_qp_delta = 0;
870
871 while(!u1_slice_end)
872 {
873 UWORD8 u1_mb_type;
874 UWORD32 u4_mb_skip;
875
876 ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
877
878 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
879 {
880 break;
881 }
882
883 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
884 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
885
886 ps_cur_mb_info->u1_Mux = 0;
887 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
888 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
889
890 ps_cur_mb_info->u1_end_of_slice = 0;
891
892 /* Storing Default partition info */
893 ps_parse_mb_data->u1_num_part = 1;
894 ps_parse_mb_data->u1_isI_mb = 0;
895
896 /***************************************************************/
897 /* Get the required information for decoding of MB */
898 /* mb_x, mb_y , neighbour availablity, */
899 /***************************************************************/
900 u4_mb_skip = ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, 1);
901
902 /*********************************************************************/
903 /* initialize u1_tran_form8x8 to zero to aviod uninitialized accesses */
904 /*********************************************************************/
905 ps_cur_mb_info->u1_tran_form8x8 = 0;
906 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
907
908 /***************************************************************/
909 /* Set the deblocking parameters for this MB */
910 /***************************************************************/
911 if(ps_dec->u4_app_disable_deblk_frm == 0)
912 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
913 ps_dec->u1_mb_ngbr_availablity,
914 ps_dec->u1_cur_mb_fld_dec_flag);
915
916 if(u4_mb_skip)
917 {
918
919 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
920 memset(ps_dec->ps_curr_ctxt_mb_info, 0, sizeof(ctxt_inc_mb_info_t));
921 ps_dec->ps_curr_ctxt_mb_info->u1_mb_type = u1_inter_mb_skip_type;
922
923 MEMSET_16BYTES(&ps_dec->pu1_left_mv_ctxt_inc[0][0], 0);
924
925 *((UWORD32 *)ps_dec->pi1_left_ref_idx_ctxt_inc) = 0;
926 *(ps_dec->pu1_left_yuv_dc_csbp) = 0;
927
928 ps_dec->i1_prev_mb_qp_delta = 0;
929 ps_cur_mb_info->u1_mb_type = MB_SKIP;
930 ps_cur_mb_info->u1_cbp = 0;
931
932 {
933 /* Storing Skip partition info */
934 parse_part_params_t *ps_part_info = ps_dec->ps_part;
935 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
936 ps_part_info->u1_sub_mb_num = 0;
937 ps_dec->ps_part++;
938 }
939
940 /* Update Nnzs */
941 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CABAC);
942
943 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
944 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
945 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
946
947 }
948 else
949 {
950
951 /* Macroblock Layer Begins */
952 /* Decode the u1_mb_type */
953 u1_mb_type = ih264d_parse_mb_type_cabac(ps_dec);
954 ps_cur_mb_info->u1_mb_type = u1_mb_type;
955 if(u1_mb_type > (25 + u1_mb_threshold))
956 return ERROR_MB_TYPE;
957
958 /* Parse Macroblock Data */
959 if(u1_mb_type < u1_mb_threshold)
960 {
961 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
962 *(ps_dec->pu1_left_yuv_dc_csbp) &= 0x6;
963
964 ret = ps_dec->pf_parse_inter_mb(ps_dec, ps_cur_mb_info, u1_num_mbs,
965 u1_num_mbsNby2);
966 if(ret != OK)
967 return ret;
968 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
969 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
970 }
971 else
972 {
973 /* Storing Intra partition info */
974 ps_parse_mb_data->u1_num_part = 0;
975 ps_parse_mb_data->u1_isI_mb = 1;
976
977 if((25 + u1_mb_threshold) == u1_mb_type)
978 {
979 /* I_PCM_MB */
980 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
981 ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
982 if(ret != OK)
983 return ret;
984 ps_cur_deblk_mb->u1_mb_qp = 0;
985 }
986 else
987 {
988 if(u1_mb_type == u1_mb_threshold)
989 ps_cur_mb_info->ps_curmb->u1_mb_type = I_4x4_MB;
990 else
991 ps_cur_mb_info->ps_curmb->u1_mb_type = I_16x16_MB;
992
993 ret = ih264d_parse_imb_cabac(
994 ps_dec, ps_cur_mb_info,
995 (UWORD8)(u1_mb_type - u1_mb_threshold));
996 if(ret != OK)
997 return ret;
998 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
999 }
1000 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
1001
1002 }
1003
1004 }
1005
1006 if(ps_dec->u1_enable_mb_info)
1007 {
1008 ih264d_populate_mb_info_map(ps_dec, ps_cur_mb_info, ps_cur_mb_info->u2_mbx << 1,
1009 ps_cur_mb_info->u2_mby << 1, ps_cur_deblk_mb->u1_mb_qp);
1010 }
1011
1012 if(u1_mbaff)
1013 {
1014 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
1015 }
1016
1017
1018 if(ps_cur_mb_info->u1_topmb && u1_mbaff)
1019 uc_more_data_flag = 1;
1020 else
1021 {
1022 uc_more_data_flag = ih264d_decode_terminate(&ps_dec->s_cab_dec_env,
1023 ps_bitstrm);
1024 uc_more_data_flag = !uc_more_data_flag;
1025 COPYTHECONTEXT("Decode Sliceterm",!uc_more_data_flag);
1026 }
1027
1028 if(u1_mbaff)
1029 {
1030 if(!uc_more_data_flag && (0 == (i2_cur_mb_addr & 1)))
1031 {
1032 return ERROR_EOB_FLUSHBITS_T;
1033 }
1034 }
1035 /* Next macroblock information */
1036 i2_cur_mb_addr++;
1037 u1_num_mbs++;
1038 u1_num_mbsNby2++;
1039 ps_parse_mb_data++;
1040
1041 /****************************************************************/
1042 /* Check for End Of Row and other flags that determine when to */
1043 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1044 /* N-Mb */
1045 /****************************************************************/
1046 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1047 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
1048 u1_slice_end = !uc_more_data_flag;
1049 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
1050 || u1_slice_end;
1051 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
1052 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1053 /*u1_dma_nby2mb = u1_decode_nmb ||
1054 (u1_num_mbsNby2 == ps_dec->u1_recon_mb_grp_pair);*/
1055
1056 //if(u1_dma_nby2mb)
1057 if(u1_decode_nmb)
1058 {
1059
1060 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1061 u1_num_mbsNby2 = 0;
1062
1063 {
1064 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1065 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1066 }
1067 }
1068
1069 /*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d",
1070 ps_slice->i4_poc >> ps_slice->u1_field_pic_flag,
1071 ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb));
1072 H264_DEC_DEBUG_PRINT("u1_decode_nmb: %d, u1_num_mbs: %d", u1_decode_nmb, u1_num_mbs);*/
1073 if(u1_decode_nmb)
1074 {
1075
1076 if(ps_dec->u1_separate_parse)
1077 {
1078 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1079 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1080 ps_dec->ps_nmb_info += u1_num_mbs;
1081 }
1082 else
1083 {
1084 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1085 u1_num_mbs_next, u1_tfr_n_mb,
1086 u1_end_of_row);
1087 }
1088 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1089 if(u1_tfr_n_mb)
1090 u1_num_mbs = 0;
1091 u1_mb_idx = u1_num_mbs;
1092 ps_dec->u1_mb_idx = u1_num_mbs;
1093
1094 }
1095 }
1096
1097
1098 ps_dec->u4_num_mbs_cur_nmb = 0;
1099 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
1100
1101 - (u2_first_mb_in_slice << u1_mbaff);
1102
1103 return ret;
1104 }
1105
1106 /*****************************************************************************/
1107 /* */
1108 /* Function Name : ih264d_parse_inter_slice_data_cavlc */
1109 /* */
1110 /* Description : This function parses cavlc syntax of a inter slice on */
1111 /* N MB basis. */
1112 /* */
1113 /* Inputs : ps_dec */
1114 /* sliceparams */
1115 /* firstMbInSlice */
1116 /* */
1117 /* Processing : 1. After parsing syntax for N MBs those N MBs are */
1118 /* decoded till the end of slice. */
1119 /* 2. MV prediction and DMA happens on a N/2 MB basis. */
1120 /* */
1121 /* Returns : 0 */
1122 /* */
1123 /* Issues : <List any issues or problems with this function> */
1124 /* */
1125 /* Revision History: */
1126 /* */
1127 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1128 /* 13 07 2002 Jay Draft */
1129 /* */
1130 /*****************************************************************************/
1131
ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,dec_slice_params_t * ps_slice,UWORD16 u2_first_mb_in_slice)1132 WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
1133 dec_slice_params_t * ps_slice,
1134 UWORD16 u2_first_mb_in_slice)
1135 {
1136 UWORD32 uc_more_data_flag;
1137 WORD32 i2_cur_mb_addr;
1138 UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx;
1139 UWORD32 i2_mb_skip_run;
1140 UWORD32 u1_read_mb_type;
1141
1142 UWORD32 u1_mbaff;
1143 UWORD32 u1_num_mbs_next, u1_end_of_row;
1144 const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
1145 UWORD32 u1_slice_end = 0;
1146 UWORD32 u1_tfr_n_mb = 0;
1147 UWORD32 u1_decode_nmb = 0;
1148
1149 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
1150 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1151 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1152 deblk_mb_t *ps_cur_deblk_mb;
1153 dec_mb_info_t *ps_cur_mb_info;
1154 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1155 UWORD32 u1_inter_mb_type;
1156 UWORD32 u1_deblk_mb_type;
1157 UWORD32 u1_mb_threshold;
1158 WORD32 ret = OK;
1159
1160 /******************************************************/
1161 /* Initialisations specific to B or P slice */
1162 /******************************************************/
1163
1164 if(ps_slice->u1_slice_type == P_SLICE)
1165 {
1166 u1_inter_mb_type = P_MB;
1167 u1_deblk_mb_type = D_INTER_MB;
1168 u1_mb_threshold = 5;
1169 }
1170 else // B_SLICE
1171 {
1172 u1_inter_mb_type = B_MB;
1173 u1_deblk_mb_type = D_B_SLICE;
1174 u1_mb_threshold = 23;
1175 }
1176 /******************************************************/
1177 /* Slice Level Initialisations */
1178 /******************************************************/
1179 ps_dec->u1_qp = ps_slice->u1_slice_qp;
1180 ih264d_update_qp(ps_dec, 0);
1181 u1_mb_idx = ps_dec->u1_mb_idx;
1182 u1_num_mbs = u1_mb_idx;
1183
1184 u1_num_mbsNby2 = 0;
1185 u1_mbaff = ps_slice->u1_mbaff_frame_flag;
1186 i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
1187 i2_mb_skip_run = 0;
1188 uc_more_data_flag = 1;
1189 u1_read_mb_type = 0;
1190
1191 while(!u1_slice_end)
1192 {
1193 UWORD8 u1_mb_type;
1194
1195 ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1196
1197 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
1198 {
1199 break;
1200 }
1201
1202
1203 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
1204 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
1205
1206 ps_cur_mb_info->u1_Mux = 0;
1207 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
1208 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
1209
1210 ps_cur_mb_info->u1_end_of_slice = 0;
1211
1212 /* Storing Default partition info */
1213 ps_parse_mb_data->u1_num_part = 1;
1214 ps_parse_mb_data->u1_isI_mb = 0;
1215
1216 if((!i2_mb_skip_run) && (!u1_read_mb_type))
1217 {
1218
1219 //Inlined ih264d_uev
1220 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
1221 UWORD32 u4_word, u4_ldz;
1222
1223 /***************************************************************/
1224 /* Find leading zeros in next 32 bits */
1225 /***************************************************************/
1226 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
1227
1228 u4_ldz = CLZ(u4_word);
1229
1230 /* Flush the ps_bitstrm */
1231 u4_bitstream_offset += (u4_ldz + 1);
1232 /* Read the suffix from the ps_bitstrm */
1233 u4_word = 0;
1234 if(u4_ldz)
1235 {
1236 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf,
1237 u4_ldz);
1238 }
1239 *pu4_bitstrm_ofst = u4_bitstream_offset;
1240 i2_mb_skip_run = ((1 << u4_ldz) + u4_word - 1);
1241 //Inlined ih264d_uev
1242 COPYTHECONTEXT("mb_skip_run", i2_mb_skip_run);
1243 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
1244 u1_read_mb_type = uc_more_data_flag;
1245 }
1246
1247 /***************************************************************/
1248 /* Get the required information for decoding of MB */
1249 /* mb_x, mb_y , neighbour availablity, */
1250 /***************************************************************/
1251 ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
1252
1253 /***************************************************************/
1254 /* Set the deblocking parameters for this MB */
1255 /***************************************************************/
1256 if(ps_dec->u4_app_disable_deblk_frm == 0)
1257 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
1258 ps_dec->u1_mb_ngbr_availablity,
1259 ps_dec->u1_cur_mb_fld_dec_flag);
1260
1261 if(i2_mb_skip_run)
1262 {
1263 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
1264 ps_dec->i1_prev_mb_qp_delta = 0;
1265 ps_dec->u1_sub_mb_num = 0;
1266 ps_cur_mb_info->u1_mb_type = MB_SKIP;
1267 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
1268 ps_cur_mb_info->u1_cbp = 0;
1269
1270 {
1271 /* Storing Skip partition info */
1272 parse_part_params_t *ps_part_info = ps_dec->ps_part;
1273 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
1274 ps_part_info->u1_sub_mb_num = 0;
1275 ps_dec->ps_part++;
1276 }
1277
1278 /* Update Nnzs */
1279 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
1280
1281 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1282 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1283
1284 i2_mb_skip_run--;
1285 }
1286 else
1287 {
1288 u1_read_mb_type = 0;
1289 /**************************************************************/
1290 /* Macroblock Layer Begins, Decode the u1_mb_type */
1291 /**************************************************************/
1292 {
1293 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
1294 UWORD32 u4_word, u4_ldz, u4_temp;
1295
1296
1297 //Inlined ih264d_uev
1298 /***************************************************************/
1299 /* Find leading zeros in next 32 bits */
1300 /***************************************************************/
1301 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
1302 u4_ldz = CLZ(u4_word);
1303 /* Flush the ps_bitstrm */
1304 u4_bitstream_offset += (u4_ldz + 1);
1305 /* Read the suffix from the ps_bitstrm */
1306 u4_word = 0;
1307 if(u4_ldz)
1308 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf,
1309 u4_ldz);
1310 *pu4_bitstrm_ofst = u4_bitstream_offset;
1311 u4_temp = ((1 << u4_ldz) + u4_word - 1);
1312 //Inlined ih264d_uev
1313 if(u4_temp > (UWORD32)(25 + u1_mb_threshold))
1314 return ERROR_MB_TYPE;
1315 u1_mb_type = u4_temp;
1316 COPYTHECONTEXT("u1_mb_type", u1_mb_type);
1317 }
1318 ps_cur_mb_info->u1_mb_type = u1_mb_type;
1319
1320 /**************************************************************/
1321 /* Parse Macroblock data */
1322 /**************************************************************/
1323 if(u1_mb_type < u1_mb_threshold)
1324 {
1325 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1326
1327 ret = ps_dec->pf_parse_inter_mb(ps_dec, ps_cur_mb_info, u1_num_mbs,
1328 u1_num_mbsNby2);
1329 if(ret != OK)
1330 return ret;
1331 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1332 }
1333 else
1334 {
1335 /* Storing Intra partition info */
1336 ps_parse_mb_data->u1_num_part = 0;
1337 ps_parse_mb_data->u1_isI_mb = 1;
1338
1339 if((25 + u1_mb_threshold) == u1_mb_type)
1340 {
1341 /* I_PCM_MB */
1342 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
1343 ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
1344 if(ret != OK)
1345 return ret;
1346 ps_dec->u1_qp = 0;
1347 }
1348 else
1349 {
1350 ret = ih264d_parse_imb_cavlc(
1351 ps_dec, ps_cur_mb_info, u1_num_mbs,
1352 (UWORD8)(u1_mb_type - u1_mb_threshold));
1353 if(ret != OK)
1354 return ret;
1355 }
1356
1357 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
1358 }
1359 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
1360 }
1361 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
1362
1363 if(ps_dec->u1_enable_mb_info)
1364 {
1365 ih264d_populate_mb_info_map(ps_dec, ps_cur_mb_info, ps_cur_mb_info->u2_mbx << 1,
1366 ps_cur_mb_info->u2_mby << 1, ps_cur_deblk_mb->u1_mb_qp);
1367 }
1368
1369 if(u1_mbaff)
1370 {
1371 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
1372 if(!uc_more_data_flag && !i2_mb_skip_run && (0 == (i2_cur_mb_addr & 1)))
1373 {
1374 return ERROR_EOB_FLUSHBITS_T;
1375 }
1376 }
1377 /**************************************************************/
1378 /* Get next Macroblock address */
1379 /**************************************************************/
1380 i2_cur_mb_addr++;
1381
1382 u1_num_mbs++;
1383 u1_num_mbsNby2++;
1384 ps_parse_mb_data++;
1385
1386 /****************************************************************/
1387 /* Check for End Of Row and other flags that determine when to */
1388 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1389 /* N-Mb */
1390 /****************************************************************/
1391 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1392 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
1393 u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run));
1394 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
1395 || u1_slice_end;
1396 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
1397 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1398
1399 /*u1_dma_nby2mb = u1_decode_nmb ||
1400 (u1_num_mbsNby2 == ps_dec->u1_recon_mb_grp_pair);*/
1401
1402 //if(u1_dma_nby2mb)
1403 if(u1_decode_nmb)
1404 {
1405 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1406 u1_num_mbsNby2 = 0;
1407
1408 {
1409 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1410 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1411 }
1412 }
1413
1414 /*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d",
1415 ps_slice->i4_poc >> ps_slice->u1_field_pic_flag,
1416 ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb));
1417 H264_DEC_DEBUG_PRINT("u1_decode_nmb: %d", u1_decode_nmb);*/
1418 if(u1_decode_nmb)
1419 {
1420
1421
1422
1423 if(ps_dec->u1_separate_parse)
1424 {
1425 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1426 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1427 ps_dec->ps_nmb_info += u1_num_mbs;
1428 }
1429 else
1430 {
1431 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1432 u1_num_mbs_next, u1_tfr_n_mb,
1433 u1_end_of_row);
1434 }
1435 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1436 if(u1_tfr_n_mb)
1437 u1_num_mbs = 0;
1438 u1_mb_idx = u1_num_mbs;
1439 ps_dec->u1_mb_idx = u1_num_mbs;
1440
1441 }
1442 //ps_dec->ps_pred++;
1443 }
1444
1445 ps_dec->u4_num_mbs_cur_nmb = 0;
1446 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
1447 - (u2_first_mb_in_slice << u1_mbaff);
1448
1449
1450 return ret;
1451 }
1452
ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,WORD32 num_mb_skip,UWORD8 u1_is_idr_slice,UWORD16 u2_frame_num,pocstruct_t * ps_cur_poc,WORD32 prev_slice_err)1453 WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
1454 WORD32 num_mb_skip,
1455 UWORD8 u1_is_idr_slice,
1456 UWORD16 u2_frame_num,
1457 pocstruct_t *ps_cur_poc,
1458 WORD32 prev_slice_err)
1459 {
1460 WORD32 i2_cur_mb_addr;
1461 UWORD32 u1_num_mbs, u1_num_mbsNby2;
1462 UWORD32 u1_mb_idx = ps_dec->u1_mb_idx;
1463 UWORD32 i2_mb_skip_run;
1464
1465 UWORD32 u1_num_mbs_next, u1_end_of_row;
1466 const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
1467 UWORD32 u1_slice_end;
1468 UWORD32 u1_tfr_n_mb;
1469 UWORD32 u1_decode_nmb;
1470 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
1471 dec_slice_params_t * ps_slice = ps_dec->ps_cur_slice;
1472 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1473 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1474 deblk_mb_t *ps_cur_deblk_mb;
1475 dec_mb_info_t *ps_cur_mb_info;
1476 parse_pmbarams_t *ps_parse_mb_data;
1477 UWORD32 u1_inter_mb_type;
1478 UWORD32 u1_deblk_mb_type;
1479 UWORD16 u2_total_mbs_coded;
1480 UWORD32 u1_mbaff;
1481 parse_part_params_t *ps_part_info;
1482 WORD32 ret;
1483 UNUSED(u1_is_idr_slice);
1484
1485 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
1486 {
1487 ih264d_err_pic_dispbuf_mgr(ps_dec);
1488 return 0;
1489 }
1490
1491 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag && (num_mb_skip & 1))
1492 {
1493 num_mb_skip++;
1494 }
1495 ps_dec->ps_dpb_cmds->u1_long_term_reference_flag = 0;
1496 if(prev_slice_err == 1)
1497 {
1498 /* first slice - missing/header corruption */
1499 ps_dec->ps_cur_slice->u2_frame_num = u2_frame_num;
1500 {
1501 WORD32 i, j, poc = 0;
1502
1503 ps_dec->ps_cur_slice->u2_first_mb_in_slice = 0;
1504
1505 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff;
1506 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
1507 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp;
1508
1509 if(ps_dec->ps_cur_pic != NULL)
1510 {
1511 poc = ps_dec->ps_cur_pic->i4_poc;
1512 if (poc <= INT32_MAX - 2)
1513 poc += 2;
1514 }
1515
1516 j = -1;
1517 for(i = 0; i < MAX_NUM_PIC_PARAMS; i++)
1518 {
1519 if(ps_dec->ps_pps[i].u1_is_valid == TRUE)
1520 {
1521 if(ps_dec->ps_pps[i].ps_sps->u1_is_valid == TRUE)
1522 {
1523 j = i;
1524 break;
1525 }
1526 }
1527 }
1528
1529 //if valid SPS PPS is not found return error
1530 if(j == -1)
1531 {
1532 return ERROR_INV_SLICE_HDR_T;
1533 }
1534
1535 /* call ih264d_start_of_pic only if it was not called earlier*/
1536 if(ps_dec->u4_pic_buf_got == 0)
1537 {
1538 //initialize slice params required by ih264d_start_of_pic to valid values
1539 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE;
1540 ps_dec->ps_cur_slice->u1_nal_ref_idc = 1;
1541 ps_dec->ps_cur_slice->u1_nal_unit_type = 1;
1542 ret = ih264d_start_of_pic(ps_dec, poc, ps_cur_poc,
1543 ps_dec->ps_cur_slice->u2_frame_num,
1544 &ps_dec->ps_pps[j]);
1545
1546 if(ret != OK)
1547 {
1548 return ret;
1549 }
1550 }
1551
1552 ps_dec->ps_ref_pic_buf_lx[0][0]->u1_pic_buf_id = 0;
1553
1554 ps_dec->u4_output_present = 0;
1555
1556 {
1557 ih264d_get_next_display_field(ps_dec,
1558 ps_dec->ps_out_buffer,
1559 &(ps_dec->s_disp_op));
1560 /* If error code is non-zero then there is no buffer available for display,
1561 hence avoid format conversion */
1562
1563 if(0 != ps_dec->s_disp_op.u4_error_code)
1564 {
1565 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht;
1566 }
1567 else
1568 ps_dec->u4_output_present = 1;
1569 }
1570
1571 if(ps_dec->u1_separate_parse == 1)
1572 {
1573 if(ps_dec->u4_dec_thread_created == 0)
1574 {
1575 ithread_create(ps_dec->pv_dec_thread_handle, NULL,
1576 (void *)ih264d_decode_picture_thread,
1577 (void *)ps_dec);
1578
1579 ps_dec->u4_dec_thread_created = 1;
1580 }
1581 #ifdef KEEP_THREADS_ACTIVE
1582 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[0]);
1583 RETURN_IF((ret != IV_SUCCESS), ret);
1584
1585 ps_dec->ai4_process_start[0] = PROC_START;
1586 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[0]);
1587 RETURN_IF((ret != IV_SUCCESS), ret);
1588
1589 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[0]);
1590 RETURN_IF((ret != IV_SUCCESS), ret);
1591 #endif
1592
1593 if((ps_dec->u4_num_cores == 3) &&
1594 ((ps_dec->u4_app_disable_deblk_frm == 0) || ps_dec->i1_recon_in_thread3_flag)
1595 && (ps_dec->u4_bs_deblk_thread_created == 0))
1596 {
1597 ps_dec->u4_start_recon_deblk = 0;
1598 ithread_create(ps_dec->pv_bs_deblk_thread_handle, NULL,
1599 (void *)ih264d_recon_deblk_thread,
1600 (void *)ps_dec);
1601 ps_dec->u4_bs_deblk_thread_created = 1;
1602 }
1603 #ifdef KEEP_THREADS_ACTIVE
1604 if (ps_dec->u4_bs_deblk_thread_created)
1605 {
1606 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[1]);
1607 RETURN_IF((ret != IV_SUCCESS), ret);
1608
1609 ps_dec->ai4_process_start[1] = PROC_START;
1610 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[1]);
1611 RETURN_IF((ret != IV_SUCCESS), ret);
1612
1613 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[1]);
1614 RETURN_IF((ret != IV_SUCCESS), ret);
1615 }
1616 #endif
1617 }
1618 }
1619 }
1620 else
1621 {
1622 // Middle / last slice
1623
1624 dec_slice_struct_t *ps_parse_cur_slice;
1625 ps_parse_cur_slice = ps_dec->ps_dec_slice_buf + ps_dec->u2_cur_slice_num;
1626
1627 if(ps_dec->u1_slice_header_done
1628 && ps_parse_cur_slice == ps_dec->ps_parse_cur_slice)
1629 {
1630 // Slice data corrupted
1631 // in the case of mbaff, conceal from the even mb.
1632 if((ps_dec->ps_cur_slice->u1_mbaff_frame_flag) && (ps_dec->u4_num_mbs_cur_nmb & 1))
1633 {
1634 ps_dec->u4_num_mbs_cur_nmb = ps_dec->u4_num_mbs_cur_nmb - 1;
1635 ps_dec->u2_cur_mb_addr--;
1636 }
1637
1638 u1_num_mbs = ps_dec->u4_num_mbs_cur_nmb;
1639 if(u1_num_mbs)
1640 {
1641 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs - 1;
1642 }
1643 else
1644 {
1645 if(ps_dec->u1_separate_parse)
1646 {
1647 ps_cur_mb_info = ps_dec->ps_nmb_info;
1648 }
1649 else
1650 {
1651 ps_cur_mb_info = ps_dec->ps_nmb_info
1652 + ps_dec->u4_num_mbs_prev_nmb - 1;
1653 }
1654 }
1655
1656 ps_dec->u2_mby = ps_cur_mb_info->u2_mby;
1657 ps_dec->u2_mbx = ps_cur_mb_info->u2_mbx;
1658
1659 ps_dec->u1_mb_ngbr_availablity =
1660 ps_cur_mb_info->u1_mb_ngbr_availablity;
1661
1662 if(u1_num_mbs)
1663 {
1664 // Going back 1 mb
1665 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_prev_mb_parse_tu_coeff_data;
1666 ps_dec->u2_cur_mb_addr--;
1667 ps_dec->i4_submb_ofst -= SUB_BLK_SIZE;
1668
1669 // Parse/decode N-MB left unparsed
1670 if (ps_dec->u1_pr_sl_type == P_SLICE
1671 || ps_dec->u1_pr_sl_type == B_SLICE)
1672 {
1673 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1674 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1675 }
1676
1677 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1678 u1_end_of_row = (!u1_num_mbs_next)
1679 && (!(ps_dec->ps_cur_slice->u1_mbaff_frame_flag && (u1_num_mbs & 0x01)));
1680 u1_slice_end = 1;
1681 u1_tfr_n_mb = 1;
1682 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1683
1684 if(ps_dec->u1_separate_parse)
1685 {
1686 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1687 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1688 ps_dec->ps_nmb_info += u1_num_mbs;
1689 }
1690 else
1691 {
1692 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1693 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1694 }
1695 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1696 ps_dec->u1_mb_idx = 0;
1697 ps_dec->u4_num_mbs_cur_nmb = 0;
1698 }
1699
1700 if(ps_dec->u2_total_mbs_coded
1701 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1702 {
1703 ps_dec->u1_pic_decode_done = 1;
1704 return 0;
1705 }
1706
1707 /* Inserting new slice only if the current slice has atleast 1 MB*/
1708 if(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
1709 (UWORD32)(ps_dec->u2_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
1710 {
1711 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1712 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1713 ps_dec->u2_cur_slice_num++;
1714 ps_dec->ps_parse_cur_slice++;
1715 }
1716
1717 }
1718 else
1719 {
1720 // Slice missing / header corrupted
1721 ps_dec->ps_parse_cur_slice = ps_dec->ps_dec_slice_buf
1722 + ps_dec->u2_cur_slice_num;
1723 }
1724 }
1725
1726 /******************************************************/
1727 /* Initializations to new slice */
1728 /******************************************************/
1729 {
1730 WORD32 num_entries;
1731 WORD32 size;
1732 UWORD8 *pu1_buf;
1733
1734 num_entries = MAX_FRAMES;
1735 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
1736 (0 == ps_dec->i4_display_delay))
1737 {
1738 num_entries = 1;
1739 }
1740 num_entries = ((2 * num_entries) + 1);
1741 num_entries *= 2;
1742
1743 size = num_entries * sizeof(void *);
1744 size += PAD_MAP_IDX_POC * sizeof(void *);
1745
1746 pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf;
1747 pu1_buf += size * ps_dec->u2_cur_slice_num;
1748 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **)pu1_buf;
1749 }
1750 u1_mbaff = ps_slice->u1_mbaff_frame_flag;
1751 ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
1752 ps_dec->ps_cur_slice->i1_slice_alpha_c0_offset = 0;
1753 ps_dec->ps_cur_slice->i1_slice_beta_offset = 0;
1754
1755 if(ps_dec->ps_cur_slice->u1_field_pic_flag)
1756 ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num;
1757
1758 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
1759 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd;
1760
1761
1762 if(ps_dec->u1_separate_parse)
1763 {
1764 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
1765 }
1766 else
1767 {
1768 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1769 }
1770
1771 /******************************************************/
1772 /* Initializations specific to P slice */
1773 /******************************************************/
1774 u1_inter_mb_type = P_MB;
1775 u1_deblk_mb_type = D_INTER_MB;
1776
1777 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE;
1778 ps_dec->ps_parse_cur_slice->slice_type = P_SLICE;
1779 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
1780 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1781 ps_dec->u2_mbx =
1782 (MOD(ps_dec->ps_cur_slice->u2_first_mb_in_slice - 1, ps_dec->u2_frm_wd_in_mbs));
1783 ps_dec->u2_mby =
1784 (DIV(ps_dec->ps_cur_slice->u2_first_mb_in_slice - 1, ps_dec->u2_frm_wd_in_mbs));
1785 ps_dec->u2_mby <<= u1_mbaff;
1786
1787 /******************************************************/
1788 /* Parsing / decoding the slice */
1789 /******************************************************/
1790 ps_dec->u1_slice_header_done = 2;
1791 ps_dec->u1_qp = ps_slice->u1_slice_qp;
1792 ih264d_update_qp(ps_dec, 0);
1793 u1_mb_idx = ps_dec->u1_mb_idx;
1794 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1795 u1_num_mbs = u1_mb_idx;
1796
1797 u1_slice_end = 0;
1798 u1_tfr_n_mb = 0;
1799 u1_decode_nmb = 0;
1800 u1_num_mbsNby2 = 0;
1801 i2_cur_mb_addr = ps_dec->u2_total_mbs_coded;
1802 i2_mb_skip_run = num_mb_skip;
1803
1804 while(!u1_slice_end)
1805 {
1806 UWORD8 u1_mb_type;
1807
1808 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
1809 break;
1810
1811 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
1812 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
1813
1814 ps_cur_mb_info->u1_Mux = 0;
1815 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
1816 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
1817
1818 ps_cur_mb_info->u1_end_of_slice = 0;
1819
1820 /* Storing Default partition info */
1821 ps_parse_mb_data->u1_num_part = 1;
1822 ps_parse_mb_data->u1_isI_mb = 0;
1823
1824 /**************************************************************/
1825 /* Get the required information for decoding of MB */
1826 /**************************************************************/
1827 /* mb_x, mb_y, neighbor availablity, */
1828 if (u1_mbaff)
1829 ih264d_get_mb_info_cavlc_mbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
1830 else
1831 ih264d_get_mb_info_cavlc_nonmbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
1832
1833 /* Set the deblocking parameters for this MB */
1834 if(ps_dec->u4_app_disable_deblk_frm == 0)
1835 {
1836 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
1837 ps_dec->u1_mb_ngbr_availablity,
1838 ps_dec->u1_cur_mb_fld_dec_flag);
1839 }
1840
1841 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
1842 ps_dec->i1_prev_mb_qp_delta = 0;
1843 ps_dec->u1_sub_mb_num = 0;
1844 ps_cur_mb_info->u1_mb_type = MB_SKIP;
1845 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
1846 ps_cur_mb_info->u1_cbp = 0;
1847
1848 /* Storing Skip partition info */
1849 ps_part_info = ps_dec->ps_part;
1850 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
1851 ps_part_info->u1_sub_mb_num = 0;
1852 ps_dec->ps_part++;
1853
1854 /* Update Nnzs */
1855 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
1856
1857 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1858 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1859
1860 i2_mb_skip_run--;
1861
1862 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
1863
1864 if (u1_mbaff)
1865 {
1866 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
1867 }
1868
1869 /**************************************************************/
1870 /* Get next Macroblock address */
1871 /**************************************************************/
1872 i2_cur_mb_addr++;
1873
1874 u1_num_mbs++;
1875 u1_num_mbsNby2++;
1876 ps_parse_mb_data++;
1877
1878 /****************************************************************/
1879 /* Check for End Of Row and other flags that determine when to */
1880 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1881 /* N-Mb */
1882 /****************************************************************/
1883 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1884 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
1885 u1_slice_end = !i2_mb_skip_run;
1886 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
1887 || u1_slice_end;
1888 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
1889 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1890
1891 if(u1_decode_nmb)
1892 {
1893 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1894 u1_num_mbsNby2 = 0;
1895
1896 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1897 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1898
1899 if(ps_dec->u1_separate_parse)
1900 {
1901 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1902 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1903 ps_dec->ps_nmb_info += u1_num_mbs;
1904 }
1905 else
1906 {
1907 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
1908 u1_tfr_n_mb, u1_end_of_row);
1909 }
1910 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1911 if(u1_tfr_n_mb)
1912 u1_num_mbs = 0;
1913 u1_mb_idx = u1_num_mbs;
1914 ps_dec->u1_mb_idx = u1_num_mbs;
1915 }
1916 }
1917
1918 ps_dec->u4_num_mbs_cur_nmb = 0;
1919 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
1920 - ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice;
1921
1922 H264_DEC_DEBUG_PRINT("Mbs in slice: %d\n", ps_dec->ps_cur_slice->u4_mbs_in_slice);
1923
1924
1925 /* incremented here only if first slice is inserted */
1926 if(ps_dec->u4_first_slice_in_pic != 0)
1927 {
1928 ps_dec->ps_parse_cur_slice++;
1929 ps_dec->u2_cur_slice_num++;
1930 }
1931
1932 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1933 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1934
1935 if(ps_dec->u2_total_mbs_coded
1936 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1937 {
1938 ps_dec->u1_pic_decode_done = 1;
1939 }
1940
1941 return 0;
1942
1943 }
1944
1945 /*!
1946 **************************************************************************
1947 * \if Function name : ih264d_decode_pslice \endif
1948 *
1949 * \brief
1950 * Decodes a P Slice
1951 *
1952 *
1953 * \return
1954 * 0 on Success and Error code otherwise
1955 **************************************************************************
1956 */
ih264d_parse_pslice(dec_struct_t * ps_dec,UWORD16 u2_first_mb_in_slice)1957 WORD32 ih264d_parse_pslice(dec_struct_t *ps_dec, UWORD16 u2_first_mb_in_slice)
1958 {
1959 dec_pic_params_t * ps_pps = ps_dec->ps_cur_pps;
1960 dec_slice_params_t * ps_cur_slice = ps_dec->ps_cur_slice;
1961 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
1962 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1963 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1964 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; //ps_dec->ps_cur_sps->u1_mb_aff_flag;
1965 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
1966
1967 UWORD64 u8_ref_idx_l0;
1968 UWORD32 u4_temp;
1969 WORD32 i_temp;
1970 WORD32 ret;
1971
1972 /*--------------------------------------------------------------------*/
1973 /* Read remaining contents of the slice header */
1974 /*--------------------------------------------------------------------*/
1975 {
1976 WORD8 *pi1_buf;
1977 WORD16 *pi2_mv = ps_dec->s_default_mv_pred.i2_mv;
1978 WORD32 *pi4_mv = (WORD32*)pi2_mv;
1979 WORD16 *pi16_refFrame;
1980
1981 pi1_buf = ps_dec->s_default_mv_pred.i1_ref_frame;
1982 pi16_refFrame = (WORD16*)pi1_buf;
1983 *pi4_mv = 0;
1984 *(pi4_mv + 1) = 0;
1985 *pi16_refFrame = OUT_OF_RANGE_REF;
1986 ps_dec->s_default_mv_pred.u1_col_ref_pic_idx = (UWORD8)-1;
1987 ps_dec->s_default_mv_pred.u1_pic_type = (UWORD8)-1;
1988 }
1989
1990 ps_cur_slice->u1_num_ref_idx_active_override_flag = ih264d_get_bit_h264(
1991 ps_bitstrm);
1992
1993 COPYTHECONTEXT("SH: num_ref_idx_override_flag",
1994 ps_cur_slice->u1_num_ref_idx_active_override_flag);
1995
1996 u8_ref_idx_l0 = ps_dec->ps_cur_pps->u1_num_ref_idx_lx_active[0];
1997 if(ps_cur_slice->u1_num_ref_idx_active_override_flag)
1998 {
1999 u8_ref_idx_l0 = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf) + (UWORD64)1;
2000 }
2001
2002 {
2003 UWORD8 u1_max_ref_idx = H264_MAX_REF_PICS << u1_field_pic_flag;
2004 if(u8_ref_idx_l0 > u1_max_ref_idx)
2005 {
2006 return ERROR_NUM_REF;
2007 }
2008 ps_cur_slice->u1_num_ref_idx_lx_active[0] = u8_ref_idx_l0;
2009 COPYTHECONTEXT("SH: num_ref_idx_l0_active_minus1",
2010 ps_cur_slice->u1_num_ref_idx_lx_active[0] - 1);
2011
2012 }
2013
2014 {
2015 UWORD8 uc_refIdxReFlagL0 = ih264d_get_bit_h264(ps_bitstrm);
2016 COPYTHECONTEXT("SH: ref_pic_list_reordering_flag_l0",uc_refIdxReFlagL0);
2017
2018 ih264d_init_ref_idx_lx_p(ps_dec);
2019 /* Store the value for future slices in the same picture */
2020 ps_dec->u1_num_ref_idx_lx_active_prev =
2021 ps_cur_slice->u1_num_ref_idx_lx_active[0];
2022
2023 /* Modified temporarily */
2024 if(uc_refIdxReFlagL0)
2025 {
2026 WORD8 ret;
2027 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
2028 ret = ih264d_ref_idx_reordering(ps_dec, 0);
2029 if(ret == -1)
2030 return ERROR_REFIDX_ORDER_T;
2031 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
2032 }
2033 else
2034 ps_dec->ps_ref_pic_buf_lx[0] =
2035 ps_dec->ps_dpb_mgr->ps_init_dpb[0];
2036 }
2037 /* Create refIdx to POC mapping */
2038 {
2039 void **pui_map_ref_idx_to_poc_lx0, **pui_map_ref_idx_to_poc_lx1;
2040 WORD8 idx;
2041 struct pic_buffer_t *ps_pic;
2042
2043 pui_map_ref_idx_to_poc_lx0 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L0;
2044 pui_map_ref_idx_to_poc_lx0[0] = 0; //For ref_idx = -1
2045 pui_map_ref_idx_to_poc_lx0++;
2046 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
2047 {
2048 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
2049 pui_map_ref_idx_to_poc_lx0[idx] = (ps_pic->pu1_buf1);
2050 }
2051
2052 /* Bug Fix Deblocking */
2053 pui_map_ref_idx_to_poc_lx1 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L1;
2054 pui_map_ref_idx_to_poc_lx1[0] = 0;
2055
2056 if(u1_mbaff)
2057 {
2058 void **ppv_map_ref_idx_to_poc_lx_t, **ppv_map_ref_idx_to_poc_lx_b;
2059 void **ppv_map_ref_idx_to_poc_lx_t1, **ppv_map_ref_idx_to_poc_lx_b1;
2060 ppv_map_ref_idx_to_poc_lx_t = ps_dec->ppv_map_ref_idx_to_poc
2061 + TOP_LIST_FLD_L0;
2062 ppv_map_ref_idx_to_poc_lx_b = ps_dec->ppv_map_ref_idx_to_poc
2063 + BOT_LIST_FLD_L0;
2064
2065 ppv_map_ref_idx_to_poc_lx_t[0] = 0; // For ref_idx = -1
2066 ppv_map_ref_idx_to_poc_lx_t++;
2067 ppv_map_ref_idx_to_poc_lx_b[0] = 0; // For ref_idx = -1
2068 ppv_map_ref_idx_to_poc_lx_b++;
2069
2070 idx = 0;
2071 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
2072 {
2073 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
2074 ppv_map_ref_idx_to_poc_lx_t[0] = (ps_pic->pu1_buf1);
2075 ppv_map_ref_idx_to_poc_lx_b[1] = (ps_pic->pu1_buf1);
2076
2077 ppv_map_ref_idx_to_poc_lx_b[0] = (ps_pic->pu1_buf1) + 1;
2078 ppv_map_ref_idx_to_poc_lx_t[1] = (ps_pic->pu1_buf1) + 1;
2079
2080 ppv_map_ref_idx_to_poc_lx_t += 2;
2081 ppv_map_ref_idx_to_poc_lx_b += 2;
2082 }
2083 ppv_map_ref_idx_to_poc_lx_t1 = ps_dec->ppv_map_ref_idx_to_poc
2084 + TOP_LIST_FLD_L1;
2085 ppv_map_ref_idx_to_poc_lx_t1[0] = 0;
2086 ppv_map_ref_idx_to_poc_lx_b1 = ps_dec->ppv_map_ref_idx_to_poc
2087 + BOT_LIST_FLD_L1;
2088 ppv_map_ref_idx_to_poc_lx_b1[0] = 0;
2089
2090 }
2091
2092 if(ps_dec->u4_num_cores >= 3)
2093 {
2094 WORD32 num_entries;
2095 WORD32 size;
2096
2097 num_entries = MAX_FRAMES;
2098 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
2099 (0 == ps_dec->i4_display_delay))
2100 {
2101 num_entries = 1;
2102 }
2103 num_entries = ((2 * num_entries) + 1);
2104 num_entries *= 2;
2105
2106 size = num_entries * sizeof(void *);
2107 size += PAD_MAP_IDX_POC * sizeof(void *);
2108
2109 memcpy((void *)ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc,
2110 ps_dec->ppv_map_ref_idx_to_poc,
2111 size);
2112 }
2113
2114
2115 }
2116 if(ps_pps->u1_wted_pred_flag)
2117 {
2118 ret = ih264d_parse_pred_weight_table(ps_cur_slice, ps_bitstrm);
2119 if(ret != OK)
2120 return ret;
2121 ih264d_form_pred_weight_matrix(ps_dec);
2122 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
2123 }
2124 else
2125 {
2126 ps_dec->ps_cur_slice->u2_log2Y_crwd = 0;
2127 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
2128 }
2129
2130 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd =
2131 ps_dec->ps_cur_slice->u2_log2Y_crwd;
2132
2133 if(u1_mbaff && (u1_field_pic_flag == 0))
2134 {
2135 ih264d_convert_frm_mbaff_list(ps_dec);
2136 }
2137
2138 /* G050 */
2139 if(ps_cur_slice->u1_nal_ref_idc != 0)
2140 {
2141 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
2142 {
2143 i_temp = ih264d_read_mmco_commands(ps_dec);
2144 if (i_temp < 0)
2145 {
2146 return ERROR_DBP_MANAGER_T;
2147 }
2148 ps_dec->u4_bitoffset = i_temp;
2149 }
2150 else
2151 ps_bitstrm->u4_ofst += ps_dec->u4_bitoffset;
2152
2153 }
2154 /* G050 */
2155
2156 if(ps_pps->u1_entropy_coding_mode == CABAC)
2157 {
2158 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2159
2160 if(u4_temp > MAX_CABAC_INIT_IDC)
2161 {
2162 return ERROR_INV_SLICE_HDR_T;
2163 }
2164 ps_cur_slice->u1_cabac_init_idc = u4_temp;
2165 COPYTHECONTEXT("SH: cabac_init_idc",ps_cur_slice->u1_cabac_init_idc);
2166 }
2167 {
2168 WORD64 i8_temp;
2169 /* Read slice_qp_delta */
2170 i8_temp = (WORD64)ps_pps->u1_pic_init_qp
2171 + ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2172 if((i8_temp < MIN_H264_QP) || (i8_temp > MAX_H264_QP))
2173 {
2174 return ERROR_INV_RANGE_QP_T;
2175 }
2176 ps_cur_slice->u1_slice_qp = i8_temp;
2177 COPYTHECONTEXT("SH: slice_qp_delta",
2178 (WORD8)(ps_cur_slice->u1_slice_qp - ps_pps->u1_pic_init_qp));
2179 }
2180
2181 if(ps_pps->u1_deblocking_filter_parameters_present_flag == 1)
2182 {
2183 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2184 if(u4_temp > SLICE_BOUNDARY_DBLK_DISABLED)
2185 {
2186 return ERROR_INV_SLICE_HDR_T;
2187 }
2188
2189 COPYTHECONTEXT("SH: disable_deblocking_filter_idc", u4_temp);
2190 ps_cur_slice->u1_disable_dblk_filter_idc = u4_temp;
2191 if(u4_temp != 1)
2192 {
2193 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf)
2194 << 1;
2195 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
2196 {
2197 return ERROR_INV_SLICE_HDR_T;
2198 }
2199 ps_cur_slice->i1_slice_alpha_c0_offset = i_temp;
2200 COPYTHECONTEXT("SH: slice_alpha_c0_offset_div2",
2201 ps_cur_slice->i1_slice_alpha_c0_offset >> 1);
2202
2203 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf)
2204 << 1;
2205 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
2206 {
2207 return ERROR_INV_SLICE_HDR_T;
2208 }
2209 ps_cur_slice->i1_slice_beta_offset = i_temp;
2210 COPYTHECONTEXT("SH: slice_beta_offset_div2",
2211 ps_cur_slice->i1_slice_beta_offset >> 1);
2212 }
2213 else
2214 {
2215 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
2216 ps_cur_slice->i1_slice_beta_offset = 0;
2217 }
2218 }
2219 else
2220 {
2221 ps_cur_slice->u1_disable_dblk_filter_idc = 0;
2222 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
2223 ps_cur_slice->i1_slice_beta_offset = 0;
2224 }
2225
2226 ps_dec->u1_slice_header_done = 2;
2227
2228 if(ps_pps->u1_entropy_coding_mode)
2229 {
2230 SWITCHOFFTRACE; SWITCHONTRACECABAC;
2231 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cabac;
2232 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cabac;
2233 ih264d_init_cabac_contexts(P_SLICE, ps_dec);
2234
2235 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
2236 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_mbaff;
2237 else
2238 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_nonmbaff;
2239 }
2240 else
2241 {
2242 SWITCHONTRACE; SWITCHOFFTRACECABAC;
2243 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cavlc;
2244 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cavlc;
2245 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
2246 {
2247 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_mbaff;
2248 }
2249 else
2250 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_nonmbaff;
2251 }
2252
2253 ps_dec->u1_B = 0;
2254 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
2255 ret = ps_dec->pf_parse_inter_slice(ps_dec, ps_cur_slice, u2_first_mb_in_slice);
2256 if(ret != OK)
2257 return ret;
2258 // ps_dec->curr_slice_in_error = 0 ;
2259 return OK;
2260 }
2261