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(u1_mbaff)
1007 {
1008 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
1009 }
1010
1011
1012 if(ps_cur_mb_info->u1_topmb && u1_mbaff)
1013 uc_more_data_flag = 1;
1014 else
1015 {
1016 uc_more_data_flag = ih264d_decode_terminate(&ps_dec->s_cab_dec_env,
1017 ps_bitstrm);
1018 uc_more_data_flag = !uc_more_data_flag;
1019 COPYTHECONTEXT("Decode Sliceterm",!uc_more_data_flag);
1020 }
1021
1022 if(u1_mbaff)
1023 {
1024 if(!uc_more_data_flag && (0 == (i2_cur_mb_addr & 1)))
1025 {
1026 return ERROR_EOB_FLUSHBITS_T;
1027 }
1028 }
1029 /* Next macroblock information */
1030 i2_cur_mb_addr++;
1031 u1_num_mbs++;
1032 u1_num_mbsNby2++;
1033 ps_parse_mb_data++;
1034
1035 /****************************************************************/
1036 /* Check for End Of Row and other flags that determine when to */
1037 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1038 /* N-Mb */
1039 /****************************************************************/
1040 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1041 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
1042 u1_slice_end = !uc_more_data_flag;
1043 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
1044 || u1_slice_end;
1045 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
1046 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1047 /*u1_dma_nby2mb = u1_decode_nmb ||
1048 (u1_num_mbsNby2 == ps_dec->u1_recon_mb_grp_pair);*/
1049
1050 //if(u1_dma_nby2mb)
1051 if(u1_decode_nmb)
1052 {
1053
1054 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1055 u1_num_mbsNby2 = 0;
1056
1057 {
1058 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1059 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1060 }
1061 }
1062
1063 /*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d",
1064 ps_slice->i4_poc >> ps_slice->u1_field_pic_flag,
1065 ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb));
1066 H264_DEC_DEBUG_PRINT("u1_decode_nmb: %d, u1_num_mbs: %d", u1_decode_nmb, u1_num_mbs);*/
1067 if(u1_decode_nmb)
1068 {
1069
1070 if(ps_dec->u1_separate_parse)
1071 {
1072 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1073 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1074 ps_dec->ps_nmb_info += u1_num_mbs;
1075 }
1076 else
1077 {
1078 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1079 u1_num_mbs_next, u1_tfr_n_mb,
1080 u1_end_of_row);
1081 }
1082 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1083 if(u1_tfr_n_mb)
1084 u1_num_mbs = 0;
1085 u1_mb_idx = u1_num_mbs;
1086 ps_dec->u1_mb_idx = u1_num_mbs;
1087
1088 }
1089 }
1090
1091
1092 ps_dec->u4_num_mbs_cur_nmb = 0;
1093 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
1094
1095 - (u2_first_mb_in_slice << u1_mbaff);
1096
1097 return ret;
1098 }
1099
1100 /*****************************************************************************/
1101 /* */
1102 /* Function Name : ih264d_parse_inter_slice_data_cavlc */
1103 /* */
1104 /* Description : This function parses cavlc syntax of a inter slice on */
1105 /* N MB basis. */
1106 /* */
1107 /* Inputs : ps_dec */
1108 /* sliceparams */
1109 /* firstMbInSlice */
1110 /* */
1111 /* Processing : 1. After parsing syntax for N MBs those N MBs are */
1112 /* decoded till the end of slice. */
1113 /* 2. MV prediction and DMA happens on a N/2 MB basis. */
1114 /* */
1115 /* Returns : 0 */
1116 /* */
1117 /* Issues : <List any issues or problems with this function> */
1118 /* */
1119 /* Revision History: */
1120 /* */
1121 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1122 /* 13 07 2002 Jay Draft */
1123 /* */
1124 /*****************************************************************************/
1125
ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,dec_slice_params_t * ps_slice,UWORD16 u2_first_mb_in_slice)1126 WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
1127 dec_slice_params_t * ps_slice,
1128 UWORD16 u2_first_mb_in_slice)
1129 {
1130 UWORD32 uc_more_data_flag;
1131 WORD32 i2_cur_mb_addr;
1132 UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx;
1133 UWORD32 i2_mb_skip_run;
1134 UWORD32 u1_read_mb_type;
1135
1136 UWORD32 u1_mbaff;
1137 UWORD32 u1_num_mbs_next, u1_end_of_row;
1138 const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
1139 UWORD32 u1_slice_end = 0;
1140 UWORD32 u1_tfr_n_mb = 0;
1141 UWORD32 u1_decode_nmb = 0;
1142
1143 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
1144 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1145 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1146 deblk_mb_t *ps_cur_deblk_mb;
1147 dec_mb_info_t *ps_cur_mb_info;
1148 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1149 UWORD32 u1_inter_mb_type;
1150 UWORD32 u1_deblk_mb_type;
1151 UWORD32 u1_mb_threshold;
1152 WORD32 ret = OK;
1153
1154 /******************************************************/
1155 /* Initialisations specific to B or P slice */
1156 /******************************************************/
1157
1158 if(ps_slice->u1_slice_type == P_SLICE)
1159 {
1160 u1_inter_mb_type = P_MB;
1161 u1_deblk_mb_type = D_INTER_MB;
1162 u1_mb_threshold = 5;
1163 }
1164 else // B_SLICE
1165 {
1166 u1_inter_mb_type = B_MB;
1167 u1_deblk_mb_type = D_B_SLICE;
1168 u1_mb_threshold = 23;
1169 }
1170 /******************************************************/
1171 /* Slice Level Initialisations */
1172 /******************************************************/
1173 ps_dec->u1_qp = ps_slice->u1_slice_qp;
1174 ih264d_update_qp(ps_dec, 0);
1175 u1_mb_idx = ps_dec->u1_mb_idx;
1176 u1_num_mbs = u1_mb_idx;
1177
1178 u1_num_mbsNby2 = 0;
1179 u1_mbaff = ps_slice->u1_mbaff_frame_flag;
1180 i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
1181 i2_mb_skip_run = 0;
1182 uc_more_data_flag = 1;
1183 u1_read_mb_type = 0;
1184
1185 while(!u1_slice_end)
1186 {
1187 UWORD8 u1_mb_type;
1188
1189 ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1190
1191 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
1192 {
1193 break;
1194 }
1195
1196
1197 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
1198 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
1199
1200 ps_cur_mb_info->u1_Mux = 0;
1201 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
1202 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
1203
1204 ps_cur_mb_info->u1_end_of_slice = 0;
1205
1206 /* Storing Default partition info */
1207 ps_parse_mb_data->u1_num_part = 1;
1208 ps_parse_mb_data->u1_isI_mb = 0;
1209
1210 if((!i2_mb_skip_run) && (!u1_read_mb_type))
1211 {
1212
1213 //Inlined ih264d_uev
1214 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
1215 UWORD32 u4_word, u4_ldz;
1216
1217 /***************************************************************/
1218 /* Find leading zeros in next 32 bits */
1219 /***************************************************************/
1220 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
1221
1222 u4_ldz = CLZ(u4_word);
1223
1224 /* Flush the ps_bitstrm */
1225 u4_bitstream_offset += (u4_ldz + 1);
1226 /* Read the suffix from the ps_bitstrm */
1227 u4_word = 0;
1228 if(u4_ldz)
1229 {
1230 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf,
1231 u4_ldz);
1232 }
1233 *pu4_bitstrm_ofst = u4_bitstream_offset;
1234 i2_mb_skip_run = ((1 << u4_ldz) + u4_word - 1);
1235 //Inlined ih264d_uev
1236 COPYTHECONTEXT("mb_skip_run", i2_mb_skip_run);
1237 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
1238 u1_read_mb_type = uc_more_data_flag;
1239 }
1240
1241 /***************************************************************/
1242 /* Get the required information for decoding of MB */
1243 /* mb_x, mb_y , neighbour availablity, */
1244 /***************************************************************/
1245 ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
1246
1247 /***************************************************************/
1248 /* Set the deblocking parameters for this MB */
1249 /***************************************************************/
1250 if(ps_dec->u4_app_disable_deblk_frm == 0)
1251 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
1252 ps_dec->u1_mb_ngbr_availablity,
1253 ps_dec->u1_cur_mb_fld_dec_flag);
1254
1255 if(i2_mb_skip_run)
1256 {
1257 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
1258 ps_dec->i1_prev_mb_qp_delta = 0;
1259 ps_dec->u1_sub_mb_num = 0;
1260 ps_cur_mb_info->u1_mb_type = MB_SKIP;
1261 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
1262 ps_cur_mb_info->u1_cbp = 0;
1263
1264 {
1265 /* Storing Skip partition info */
1266 parse_part_params_t *ps_part_info = ps_dec->ps_part;
1267 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
1268 ps_part_info->u1_sub_mb_num = 0;
1269 ps_dec->ps_part++;
1270 }
1271
1272 /* Update Nnzs */
1273 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
1274
1275 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1276 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1277
1278 i2_mb_skip_run--;
1279 }
1280 else
1281 {
1282 u1_read_mb_type = 0;
1283 /**************************************************************/
1284 /* Macroblock Layer Begins, Decode the u1_mb_type */
1285 /**************************************************************/
1286 {
1287 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
1288 UWORD32 u4_word, u4_ldz, u4_temp;
1289
1290
1291 //Inlined ih264d_uev
1292 /***************************************************************/
1293 /* Find leading zeros in next 32 bits */
1294 /***************************************************************/
1295 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
1296 u4_ldz = CLZ(u4_word);
1297 /* Flush the ps_bitstrm */
1298 u4_bitstream_offset += (u4_ldz + 1);
1299 /* Read the suffix from the ps_bitstrm */
1300 u4_word = 0;
1301 if(u4_ldz)
1302 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf,
1303 u4_ldz);
1304 *pu4_bitstrm_ofst = u4_bitstream_offset;
1305 u4_temp = ((1 << u4_ldz) + u4_word - 1);
1306 //Inlined ih264d_uev
1307 if(u4_temp > (UWORD32)(25 + u1_mb_threshold))
1308 return ERROR_MB_TYPE;
1309 u1_mb_type = u4_temp;
1310 COPYTHECONTEXT("u1_mb_type", u1_mb_type);
1311 }
1312 ps_cur_mb_info->u1_mb_type = u1_mb_type;
1313
1314 /**************************************************************/
1315 /* Parse Macroblock data */
1316 /**************************************************************/
1317 if(u1_mb_type < u1_mb_threshold)
1318 {
1319 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1320
1321 ret = ps_dec->pf_parse_inter_mb(ps_dec, ps_cur_mb_info, u1_num_mbs,
1322 u1_num_mbsNby2);
1323 if(ret != OK)
1324 return ret;
1325 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1326 }
1327 else
1328 {
1329 /* Storing Intra partition info */
1330 ps_parse_mb_data->u1_num_part = 0;
1331 ps_parse_mb_data->u1_isI_mb = 1;
1332
1333 if((25 + u1_mb_threshold) == u1_mb_type)
1334 {
1335 /* I_PCM_MB */
1336 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
1337 ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
1338 if(ret != OK)
1339 return ret;
1340 ps_dec->u1_qp = 0;
1341 }
1342 else
1343 {
1344 ret = ih264d_parse_imb_cavlc(
1345 ps_dec, ps_cur_mb_info, u1_num_mbs,
1346 (UWORD8)(u1_mb_type - u1_mb_threshold));
1347 if(ret != OK)
1348 return ret;
1349 }
1350
1351 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
1352 }
1353 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
1354 }
1355 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
1356
1357 if(u1_mbaff)
1358 {
1359 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
1360 if(!uc_more_data_flag && !i2_mb_skip_run && (0 == (i2_cur_mb_addr & 1)))
1361 {
1362 return ERROR_EOB_FLUSHBITS_T;
1363 }
1364 }
1365 /**************************************************************/
1366 /* Get next Macroblock address */
1367 /**************************************************************/
1368 i2_cur_mb_addr++;
1369
1370 u1_num_mbs++;
1371 u1_num_mbsNby2++;
1372 ps_parse_mb_data++;
1373
1374 /****************************************************************/
1375 /* Check for End Of Row and other flags that determine when to */
1376 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1377 /* N-Mb */
1378 /****************************************************************/
1379 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1380 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
1381 u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run));
1382 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
1383 || u1_slice_end;
1384 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
1385 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1386
1387 /*u1_dma_nby2mb = u1_decode_nmb ||
1388 (u1_num_mbsNby2 == ps_dec->u1_recon_mb_grp_pair);*/
1389
1390 //if(u1_dma_nby2mb)
1391 if(u1_decode_nmb)
1392 {
1393 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1394 u1_num_mbsNby2 = 0;
1395
1396 {
1397 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1398 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1399 }
1400 }
1401
1402 /*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d",
1403 ps_slice->i4_poc >> ps_slice->u1_field_pic_flag,
1404 ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb));
1405 H264_DEC_DEBUG_PRINT("u1_decode_nmb: %d", u1_decode_nmb);*/
1406 if(u1_decode_nmb)
1407 {
1408
1409
1410
1411 if(ps_dec->u1_separate_parse)
1412 {
1413 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1414 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1415 ps_dec->ps_nmb_info += u1_num_mbs;
1416 }
1417 else
1418 {
1419 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1420 u1_num_mbs_next, u1_tfr_n_mb,
1421 u1_end_of_row);
1422 }
1423 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1424 if(u1_tfr_n_mb)
1425 u1_num_mbs = 0;
1426 u1_mb_idx = u1_num_mbs;
1427 ps_dec->u1_mb_idx = u1_num_mbs;
1428
1429 }
1430 //ps_dec->ps_pred++;
1431 }
1432
1433 ps_dec->u4_num_mbs_cur_nmb = 0;
1434 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
1435 - (u2_first_mb_in_slice << u1_mbaff);
1436
1437
1438 return ret;
1439 }
1440
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)1441 WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
1442 WORD32 num_mb_skip,
1443 UWORD8 u1_is_idr_slice,
1444 UWORD16 u2_frame_num,
1445 pocstruct_t *ps_cur_poc,
1446 WORD32 prev_slice_err)
1447 {
1448 WORD32 i2_cur_mb_addr;
1449 UWORD32 u1_num_mbs, u1_num_mbsNby2;
1450 UWORD32 u1_mb_idx = ps_dec->u1_mb_idx;
1451 UWORD32 i2_mb_skip_run;
1452
1453 UWORD32 u1_num_mbs_next, u1_end_of_row;
1454 const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
1455 UWORD32 u1_slice_end;
1456 UWORD32 u1_tfr_n_mb;
1457 UWORD32 u1_decode_nmb;
1458 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
1459 dec_slice_params_t * ps_slice = ps_dec->ps_cur_slice;
1460 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1461 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1462 deblk_mb_t *ps_cur_deblk_mb;
1463 dec_mb_info_t *ps_cur_mb_info;
1464 parse_pmbarams_t *ps_parse_mb_data;
1465 UWORD32 u1_inter_mb_type;
1466 UWORD32 u1_deblk_mb_type;
1467 UWORD16 u2_total_mbs_coded;
1468 UWORD32 u1_mbaff;
1469 parse_part_params_t *ps_part_info;
1470 WORD32 ret;
1471 UNUSED(u1_is_idr_slice);
1472
1473 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
1474 {
1475 ih264d_err_pic_dispbuf_mgr(ps_dec);
1476 return 0;
1477 }
1478
1479 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag && (num_mb_skip & 1))
1480 {
1481 num_mb_skip++;
1482 }
1483 ps_dec->ps_dpb_cmds->u1_long_term_reference_flag = 0;
1484 if(prev_slice_err == 1)
1485 {
1486 /* first slice - missing/header corruption */
1487 ps_dec->ps_cur_slice->u2_frame_num = u2_frame_num;
1488 {
1489 WORD32 i, j, poc = 0;
1490
1491 ps_dec->ps_cur_slice->u2_first_mb_in_slice = 0;
1492
1493 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff;
1494 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
1495 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp;
1496
1497 if(ps_dec->ps_cur_pic != NULL)
1498 {
1499 poc = ps_dec->ps_cur_pic->i4_poc;
1500 if (poc <= INT32_MAX - 2)
1501 poc += 2;
1502 }
1503
1504 j = -1;
1505 for(i = 0; i < MAX_NUM_PIC_PARAMS; i++)
1506 {
1507 if(ps_dec->ps_pps[i].u1_is_valid == TRUE)
1508 {
1509 if(ps_dec->ps_pps[i].ps_sps->u1_is_valid == TRUE)
1510 {
1511 j = i;
1512 break;
1513 }
1514 }
1515 }
1516
1517 //if valid SPS PPS is not found return error
1518 if(j == -1)
1519 {
1520 return ERROR_INV_SLICE_HDR_T;
1521 }
1522
1523 /* call ih264d_start_of_pic only if it was not called earlier*/
1524 if(ps_dec->u4_pic_buf_got == 0)
1525 {
1526 //initialize slice params required by ih264d_start_of_pic to valid values
1527 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE;
1528 ps_dec->ps_cur_slice->u1_nal_ref_idc = 1;
1529 ps_dec->ps_cur_slice->u1_nal_unit_type = 1;
1530 ret = ih264d_start_of_pic(ps_dec, poc, ps_cur_poc,
1531 ps_dec->ps_cur_slice->u2_frame_num,
1532 &ps_dec->ps_pps[j]);
1533
1534 if(ret != OK)
1535 {
1536 return ret;
1537 }
1538 }
1539
1540 ps_dec->ps_ref_pic_buf_lx[0][0]->u1_pic_buf_id = 0;
1541
1542 ps_dec->u4_output_present = 0;
1543
1544 {
1545 ih264d_get_next_display_field(ps_dec,
1546 ps_dec->ps_out_buffer,
1547 &(ps_dec->s_disp_op));
1548 /* If error code is non-zero then there is no buffer available for display,
1549 hence avoid format conversion */
1550
1551 if(0 != ps_dec->s_disp_op.u4_error_code)
1552 {
1553 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht;
1554 }
1555 else
1556 ps_dec->u4_output_present = 1;
1557 }
1558
1559 if(ps_dec->u1_separate_parse == 1)
1560 {
1561 if(ps_dec->u4_dec_thread_created == 0)
1562 {
1563 ithread_create(ps_dec->pv_dec_thread_handle, NULL,
1564 (void *)ih264d_decode_picture_thread,
1565 (void *)ps_dec);
1566
1567 ps_dec->u4_dec_thread_created = 1;
1568 }
1569 #ifdef KEEP_THREADS_ACTIVE
1570 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[0]);
1571 RETURN_IF((ret != IV_SUCCESS), ret);
1572
1573 ps_dec->ai4_process_start[0] = PROC_START;
1574 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[0]);
1575 RETURN_IF((ret != IV_SUCCESS), ret);
1576
1577 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[0]);
1578 RETURN_IF((ret != IV_SUCCESS), ret);
1579 #endif
1580
1581 if((ps_dec->u4_num_cores == 3) &&
1582 ((ps_dec->u4_app_disable_deblk_frm == 0) || ps_dec->i1_recon_in_thread3_flag)
1583 && (ps_dec->u4_bs_deblk_thread_created == 0))
1584 {
1585 ps_dec->u4_start_recon_deblk = 0;
1586 ithread_create(ps_dec->pv_bs_deblk_thread_handle, NULL,
1587 (void *)ih264d_recon_deblk_thread,
1588 (void *)ps_dec);
1589 ps_dec->u4_bs_deblk_thread_created = 1;
1590 }
1591 #ifdef KEEP_THREADS_ACTIVE
1592 if (ps_dec->u4_bs_deblk_thread_created)
1593 {
1594 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[1]);
1595 RETURN_IF((ret != IV_SUCCESS), ret);
1596
1597 ps_dec->ai4_process_start[1] = PROC_START;
1598 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[1]);
1599 RETURN_IF((ret != IV_SUCCESS), ret);
1600
1601 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[1]);
1602 RETURN_IF((ret != IV_SUCCESS), ret);
1603 }
1604 #endif
1605 }
1606 }
1607 }
1608 else
1609 {
1610 // Middle / last slice
1611
1612 dec_slice_struct_t *ps_parse_cur_slice;
1613 ps_parse_cur_slice = ps_dec->ps_dec_slice_buf + ps_dec->u2_cur_slice_num;
1614
1615 if(ps_dec->u1_slice_header_done
1616 && ps_parse_cur_slice == ps_dec->ps_parse_cur_slice)
1617 {
1618 // Slice data corrupted
1619 // in the case of mbaff, conceal from the even mb.
1620 if((ps_dec->ps_cur_slice->u1_mbaff_frame_flag) && (ps_dec->u4_num_mbs_cur_nmb & 1))
1621 {
1622 ps_dec->u4_num_mbs_cur_nmb = ps_dec->u4_num_mbs_cur_nmb - 1;
1623 ps_dec->u2_cur_mb_addr--;
1624 }
1625
1626 u1_num_mbs = ps_dec->u4_num_mbs_cur_nmb;
1627 if(u1_num_mbs)
1628 {
1629 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs - 1;
1630 }
1631 else
1632 {
1633 if(ps_dec->u1_separate_parse)
1634 {
1635 ps_cur_mb_info = ps_dec->ps_nmb_info;
1636 }
1637 else
1638 {
1639 ps_cur_mb_info = ps_dec->ps_nmb_info
1640 + ps_dec->u4_num_mbs_prev_nmb - 1;
1641 }
1642 }
1643
1644 ps_dec->u2_mby = ps_cur_mb_info->u2_mby;
1645 ps_dec->u2_mbx = ps_cur_mb_info->u2_mbx;
1646
1647 ps_dec->u1_mb_ngbr_availablity =
1648 ps_cur_mb_info->u1_mb_ngbr_availablity;
1649
1650 if(u1_num_mbs)
1651 {
1652 // Going back 1 mb
1653 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_prev_mb_parse_tu_coeff_data;
1654 ps_dec->u2_cur_mb_addr--;
1655 ps_dec->i4_submb_ofst -= SUB_BLK_SIZE;
1656
1657 // Parse/decode N-MB left unparsed
1658 if (ps_dec->u1_pr_sl_type == P_SLICE
1659 || ps_dec->u1_pr_sl_type == B_SLICE)
1660 {
1661 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1662 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1663 }
1664
1665 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1666 u1_end_of_row = (!u1_num_mbs_next)
1667 && (!(ps_dec->ps_cur_slice->u1_mbaff_frame_flag && (u1_num_mbs & 0x01)));
1668 u1_slice_end = 1;
1669 u1_tfr_n_mb = 1;
1670 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1671
1672 if(ps_dec->u1_separate_parse)
1673 {
1674 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1675 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1676 ps_dec->ps_nmb_info += u1_num_mbs;
1677 }
1678 else
1679 {
1680 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1681 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1682 }
1683 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1684 ps_dec->u1_mb_idx = 0;
1685 ps_dec->u4_num_mbs_cur_nmb = 0;
1686 }
1687
1688 if(ps_dec->u2_total_mbs_coded
1689 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1690 {
1691 ps_dec->u1_pic_decode_done = 1;
1692 return 0;
1693 }
1694
1695 /* Inserting new slice only if the current slice has atleast 1 MB*/
1696 if(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
1697 (UWORD32)(ps_dec->u2_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
1698 {
1699 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1700 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1701 ps_dec->u2_cur_slice_num++;
1702 ps_dec->ps_parse_cur_slice++;
1703 }
1704
1705 }
1706 else
1707 {
1708 // Slice missing / header corrupted
1709 ps_dec->ps_parse_cur_slice = ps_dec->ps_dec_slice_buf
1710 + ps_dec->u2_cur_slice_num;
1711 }
1712 }
1713
1714 /******************************************************/
1715 /* Initializations to new slice */
1716 /******************************************************/
1717 {
1718 WORD32 num_entries;
1719 WORD32 size;
1720 UWORD8 *pu1_buf;
1721
1722 num_entries = MAX_FRAMES;
1723 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
1724 (0 == ps_dec->i4_display_delay))
1725 {
1726 num_entries = 1;
1727 }
1728 num_entries = ((2 * num_entries) + 1);
1729 num_entries *= 2;
1730
1731 size = num_entries * sizeof(void *);
1732 size += PAD_MAP_IDX_POC * sizeof(void *);
1733
1734 pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf;
1735 pu1_buf += size * ps_dec->u2_cur_slice_num;
1736 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **)pu1_buf;
1737 }
1738 u1_mbaff = ps_slice->u1_mbaff_frame_flag;
1739 ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
1740 ps_dec->ps_cur_slice->i1_slice_alpha_c0_offset = 0;
1741 ps_dec->ps_cur_slice->i1_slice_beta_offset = 0;
1742
1743 if(ps_dec->ps_cur_slice->u1_field_pic_flag)
1744 ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num;
1745
1746 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
1747 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd;
1748
1749
1750 if(ps_dec->u1_separate_parse)
1751 {
1752 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
1753 }
1754 else
1755 {
1756 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1757 }
1758
1759 /******************************************************/
1760 /* Initializations specific to P slice */
1761 /******************************************************/
1762 u1_inter_mb_type = P_MB;
1763 u1_deblk_mb_type = D_INTER_MB;
1764
1765 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE;
1766 ps_dec->ps_parse_cur_slice->slice_type = P_SLICE;
1767 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
1768 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1769 ps_dec->u2_mbx =
1770 (MOD(ps_dec->ps_cur_slice->u2_first_mb_in_slice - 1, ps_dec->u2_frm_wd_in_mbs));
1771 ps_dec->u2_mby =
1772 (DIV(ps_dec->ps_cur_slice->u2_first_mb_in_slice - 1, ps_dec->u2_frm_wd_in_mbs));
1773 ps_dec->u2_mby <<= u1_mbaff;
1774
1775 /******************************************************/
1776 /* Parsing / decoding the slice */
1777 /******************************************************/
1778 ps_dec->u1_slice_header_done = 2;
1779 ps_dec->u1_qp = ps_slice->u1_slice_qp;
1780 ih264d_update_qp(ps_dec, 0);
1781 u1_mb_idx = ps_dec->u1_mb_idx;
1782 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1783 u1_num_mbs = u1_mb_idx;
1784
1785 u1_slice_end = 0;
1786 u1_tfr_n_mb = 0;
1787 u1_decode_nmb = 0;
1788 u1_num_mbsNby2 = 0;
1789 i2_cur_mb_addr = ps_dec->u2_total_mbs_coded;
1790 i2_mb_skip_run = num_mb_skip;
1791
1792 while(!u1_slice_end)
1793 {
1794 UWORD8 u1_mb_type;
1795
1796 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
1797 break;
1798
1799 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
1800 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
1801
1802 ps_cur_mb_info->u1_Mux = 0;
1803 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
1804 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
1805
1806 ps_cur_mb_info->u1_end_of_slice = 0;
1807
1808 /* Storing Default partition info */
1809 ps_parse_mb_data->u1_num_part = 1;
1810 ps_parse_mb_data->u1_isI_mb = 0;
1811
1812 /**************************************************************/
1813 /* Get the required information for decoding of MB */
1814 /**************************************************************/
1815 /* mb_x, mb_y, neighbor availablity, */
1816 if (u1_mbaff)
1817 ih264d_get_mb_info_cavlc_mbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
1818 else
1819 ih264d_get_mb_info_cavlc_nonmbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
1820
1821 /* Set the deblocking parameters for this MB */
1822 if(ps_dec->u4_app_disable_deblk_frm == 0)
1823 {
1824 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
1825 ps_dec->u1_mb_ngbr_availablity,
1826 ps_dec->u1_cur_mb_fld_dec_flag);
1827 }
1828
1829 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
1830 ps_dec->i1_prev_mb_qp_delta = 0;
1831 ps_dec->u1_sub_mb_num = 0;
1832 ps_cur_mb_info->u1_mb_type = MB_SKIP;
1833 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
1834 ps_cur_mb_info->u1_cbp = 0;
1835
1836 /* Storing Skip partition info */
1837 ps_part_info = ps_dec->ps_part;
1838 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
1839 ps_part_info->u1_sub_mb_num = 0;
1840 ps_dec->ps_part++;
1841
1842 /* Update Nnzs */
1843 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
1844
1845 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1846 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1847
1848 i2_mb_skip_run--;
1849
1850 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
1851
1852 if (u1_mbaff)
1853 {
1854 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
1855 }
1856
1857 /**************************************************************/
1858 /* Get next Macroblock address */
1859 /**************************************************************/
1860 i2_cur_mb_addr++;
1861
1862 u1_num_mbs++;
1863 u1_num_mbsNby2++;
1864 ps_parse_mb_data++;
1865
1866 /****************************************************************/
1867 /* Check for End Of Row and other flags that determine when to */
1868 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1869 /* N-Mb */
1870 /****************************************************************/
1871 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1872 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
1873 u1_slice_end = !i2_mb_skip_run;
1874 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
1875 || u1_slice_end;
1876 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
1877 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1878
1879 if(u1_decode_nmb)
1880 {
1881 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1882 u1_num_mbsNby2 = 0;
1883
1884 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1885 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1886
1887 if(ps_dec->u1_separate_parse)
1888 {
1889 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1890 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1891 ps_dec->ps_nmb_info += u1_num_mbs;
1892 }
1893 else
1894 {
1895 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
1896 u1_tfr_n_mb, u1_end_of_row);
1897 }
1898 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1899 if(u1_tfr_n_mb)
1900 u1_num_mbs = 0;
1901 u1_mb_idx = u1_num_mbs;
1902 ps_dec->u1_mb_idx = u1_num_mbs;
1903 }
1904 }
1905
1906 ps_dec->u4_num_mbs_cur_nmb = 0;
1907 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
1908 - ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice;
1909
1910 H264_DEC_DEBUG_PRINT("Mbs in slice: %d\n", ps_dec->ps_cur_slice->u4_mbs_in_slice);
1911
1912
1913 /* incremented here only if first slice is inserted */
1914 if(ps_dec->u4_first_slice_in_pic != 0)
1915 {
1916 ps_dec->ps_parse_cur_slice++;
1917 ps_dec->u2_cur_slice_num++;
1918 }
1919
1920 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1921 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1922
1923 if(ps_dec->u2_total_mbs_coded
1924 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1925 {
1926 ps_dec->u1_pic_decode_done = 1;
1927 }
1928
1929 return 0;
1930
1931 }
1932
1933 /*!
1934 **************************************************************************
1935 * \if Function name : ih264d_decode_pslice \endif
1936 *
1937 * \brief
1938 * Decodes a P Slice
1939 *
1940 *
1941 * \return
1942 * 0 on Success and Error code otherwise
1943 **************************************************************************
1944 */
ih264d_parse_pslice(dec_struct_t * ps_dec,UWORD16 u2_first_mb_in_slice)1945 WORD32 ih264d_parse_pslice(dec_struct_t *ps_dec, UWORD16 u2_first_mb_in_slice)
1946 {
1947 dec_pic_params_t * ps_pps = ps_dec->ps_cur_pps;
1948 dec_slice_params_t * ps_cur_slice = ps_dec->ps_cur_slice;
1949 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
1950 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1951 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1952 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; //ps_dec->ps_cur_sps->u1_mb_aff_flag;
1953 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
1954
1955 UWORD64 u8_ref_idx_l0;
1956 UWORD32 u4_temp;
1957 WORD32 i_temp;
1958 WORD32 ret;
1959
1960 /*--------------------------------------------------------------------*/
1961 /* Read remaining contents of the slice header */
1962 /*--------------------------------------------------------------------*/
1963 {
1964 WORD8 *pi1_buf;
1965 WORD16 *pi2_mv = ps_dec->s_default_mv_pred.i2_mv;
1966 WORD32 *pi4_mv = (WORD32*)pi2_mv;
1967 WORD16 *pi16_refFrame;
1968
1969 pi1_buf = ps_dec->s_default_mv_pred.i1_ref_frame;
1970 pi16_refFrame = (WORD16*)pi1_buf;
1971 *pi4_mv = 0;
1972 *(pi4_mv + 1) = 0;
1973 *pi16_refFrame = OUT_OF_RANGE_REF;
1974 ps_dec->s_default_mv_pred.u1_col_ref_pic_idx = (UWORD8)-1;
1975 ps_dec->s_default_mv_pred.u1_pic_type = (UWORD8)-1;
1976 }
1977
1978 ps_cur_slice->u1_num_ref_idx_active_override_flag = ih264d_get_bit_h264(
1979 ps_bitstrm);
1980
1981 COPYTHECONTEXT("SH: num_ref_idx_override_flag",
1982 ps_cur_slice->u1_num_ref_idx_active_override_flag);
1983
1984 u8_ref_idx_l0 = ps_dec->ps_cur_pps->u1_num_ref_idx_lx_active[0];
1985 if(ps_cur_slice->u1_num_ref_idx_active_override_flag)
1986 {
1987 u8_ref_idx_l0 = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf) + (UWORD64)1;
1988 }
1989
1990 {
1991 UWORD8 u1_max_ref_idx = H264_MAX_REF_PICS << u1_field_pic_flag;
1992 if(u8_ref_idx_l0 > u1_max_ref_idx)
1993 {
1994 return ERROR_NUM_REF;
1995 }
1996 ps_cur_slice->u1_num_ref_idx_lx_active[0] = u8_ref_idx_l0;
1997 COPYTHECONTEXT("SH: num_ref_idx_l0_active_minus1",
1998 ps_cur_slice->u1_num_ref_idx_lx_active[0] - 1);
1999
2000 }
2001
2002 {
2003 UWORD8 uc_refIdxReFlagL0 = ih264d_get_bit_h264(ps_bitstrm);
2004 COPYTHECONTEXT("SH: ref_pic_list_reordering_flag_l0",uc_refIdxReFlagL0);
2005
2006 ih264d_init_ref_idx_lx_p(ps_dec);
2007 /* Store the value for future slices in the same picture */
2008 ps_dec->u1_num_ref_idx_lx_active_prev =
2009 ps_cur_slice->u1_num_ref_idx_lx_active[0];
2010
2011 /* Modified temporarily */
2012 if(uc_refIdxReFlagL0)
2013 {
2014 WORD8 ret;
2015 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
2016 ret = ih264d_ref_idx_reordering(ps_dec, 0);
2017 if(ret == -1)
2018 return ERROR_REFIDX_ORDER_T;
2019 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
2020 }
2021 else
2022 ps_dec->ps_ref_pic_buf_lx[0] =
2023 ps_dec->ps_dpb_mgr->ps_init_dpb[0];
2024 }
2025 /* Create refIdx to POC mapping */
2026 {
2027 void **pui_map_ref_idx_to_poc_lx0, **pui_map_ref_idx_to_poc_lx1;
2028 WORD8 idx;
2029 struct pic_buffer_t *ps_pic;
2030
2031 pui_map_ref_idx_to_poc_lx0 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L0;
2032 pui_map_ref_idx_to_poc_lx0[0] = 0; //For ref_idx = -1
2033 pui_map_ref_idx_to_poc_lx0++;
2034 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
2035 {
2036 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
2037 pui_map_ref_idx_to_poc_lx0[idx] = (ps_pic->pu1_buf1);
2038 }
2039
2040 /* Bug Fix Deblocking */
2041 pui_map_ref_idx_to_poc_lx1 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L1;
2042 pui_map_ref_idx_to_poc_lx1[0] = 0;
2043
2044 if(u1_mbaff)
2045 {
2046 void **ppv_map_ref_idx_to_poc_lx_t, **ppv_map_ref_idx_to_poc_lx_b;
2047 void **ppv_map_ref_idx_to_poc_lx_t1, **ppv_map_ref_idx_to_poc_lx_b1;
2048 ppv_map_ref_idx_to_poc_lx_t = ps_dec->ppv_map_ref_idx_to_poc
2049 + TOP_LIST_FLD_L0;
2050 ppv_map_ref_idx_to_poc_lx_b = ps_dec->ppv_map_ref_idx_to_poc
2051 + BOT_LIST_FLD_L0;
2052
2053 ppv_map_ref_idx_to_poc_lx_t[0] = 0; // For ref_idx = -1
2054 ppv_map_ref_idx_to_poc_lx_t++;
2055 ppv_map_ref_idx_to_poc_lx_b[0] = 0; // For ref_idx = -1
2056 ppv_map_ref_idx_to_poc_lx_b++;
2057
2058 idx = 0;
2059 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
2060 {
2061 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
2062 ppv_map_ref_idx_to_poc_lx_t[0] = (ps_pic->pu1_buf1);
2063 ppv_map_ref_idx_to_poc_lx_b[1] = (ps_pic->pu1_buf1);
2064
2065 ppv_map_ref_idx_to_poc_lx_b[0] = (ps_pic->pu1_buf1) + 1;
2066 ppv_map_ref_idx_to_poc_lx_t[1] = (ps_pic->pu1_buf1) + 1;
2067
2068 ppv_map_ref_idx_to_poc_lx_t += 2;
2069 ppv_map_ref_idx_to_poc_lx_b += 2;
2070 }
2071 ppv_map_ref_idx_to_poc_lx_t1 = ps_dec->ppv_map_ref_idx_to_poc
2072 + TOP_LIST_FLD_L1;
2073 ppv_map_ref_idx_to_poc_lx_t1[0] = 0;
2074 ppv_map_ref_idx_to_poc_lx_b1 = ps_dec->ppv_map_ref_idx_to_poc
2075 + BOT_LIST_FLD_L1;
2076 ppv_map_ref_idx_to_poc_lx_b1[0] = 0;
2077
2078 }
2079
2080 if(ps_dec->u4_num_cores >= 3)
2081 {
2082 WORD32 num_entries;
2083 WORD32 size;
2084
2085 num_entries = MAX_FRAMES;
2086 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
2087 (0 == ps_dec->i4_display_delay))
2088 {
2089 num_entries = 1;
2090 }
2091 num_entries = ((2 * num_entries) + 1);
2092 num_entries *= 2;
2093
2094 size = num_entries * sizeof(void *);
2095 size += PAD_MAP_IDX_POC * sizeof(void *);
2096
2097 memcpy((void *)ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc,
2098 ps_dec->ppv_map_ref_idx_to_poc,
2099 size);
2100 }
2101
2102
2103 }
2104 if(ps_pps->u1_wted_pred_flag)
2105 {
2106 ret = ih264d_parse_pred_weight_table(ps_cur_slice, ps_bitstrm);
2107 if(ret != OK)
2108 return ret;
2109 ih264d_form_pred_weight_matrix(ps_dec);
2110 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
2111 }
2112 else
2113 {
2114 ps_dec->ps_cur_slice->u2_log2Y_crwd = 0;
2115 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
2116 }
2117
2118 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd =
2119 ps_dec->ps_cur_slice->u2_log2Y_crwd;
2120
2121 if(u1_mbaff && (u1_field_pic_flag == 0))
2122 {
2123 ih264d_convert_frm_mbaff_list(ps_dec);
2124 }
2125
2126 /* G050 */
2127 if(ps_cur_slice->u1_nal_ref_idc != 0)
2128 {
2129 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
2130 {
2131 i_temp = ih264d_read_mmco_commands(ps_dec);
2132 if (i_temp < 0)
2133 {
2134 return ERROR_DBP_MANAGER_T;
2135 }
2136 ps_dec->u4_bitoffset = i_temp;
2137 }
2138 else
2139 ps_bitstrm->u4_ofst += ps_dec->u4_bitoffset;
2140
2141 }
2142 /* G050 */
2143
2144 if(ps_pps->u1_entropy_coding_mode == CABAC)
2145 {
2146 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2147
2148 if(u4_temp > MAX_CABAC_INIT_IDC)
2149 {
2150 return ERROR_INV_SLICE_HDR_T;
2151 }
2152 ps_cur_slice->u1_cabac_init_idc = u4_temp;
2153 COPYTHECONTEXT("SH: cabac_init_idc",ps_cur_slice->u1_cabac_init_idc);
2154 }
2155
2156 /* Read slice_qp_delta */
2157 WORD64 i8_temp = (WORD64)ps_pps->u1_pic_init_qp
2158 + ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2159 if((i8_temp < MIN_H264_QP) || (i8_temp > MAX_H264_QP))
2160 {
2161 return ERROR_INV_RANGE_QP_T;
2162 }
2163 ps_cur_slice->u1_slice_qp = i8_temp;
2164 COPYTHECONTEXT("SH: slice_qp_delta",
2165 (WORD8)(ps_cur_slice->u1_slice_qp - ps_pps->u1_pic_init_qp));
2166
2167 if(ps_pps->u1_deblocking_filter_parameters_present_flag == 1)
2168 {
2169 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2170 if(u4_temp > SLICE_BOUNDARY_DBLK_DISABLED)
2171 {
2172 return ERROR_INV_SLICE_HDR_T;
2173 }
2174
2175 COPYTHECONTEXT("SH: disable_deblocking_filter_idc", u4_temp);
2176 ps_cur_slice->u1_disable_dblk_filter_idc = u4_temp;
2177 if(u4_temp != 1)
2178 {
2179 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf)
2180 << 1;
2181 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
2182 {
2183 return ERROR_INV_SLICE_HDR_T;
2184 }
2185 ps_cur_slice->i1_slice_alpha_c0_offset = i_temp;
2186 COPYTHECONTEXT("SH: slice_alpha_c0_offset_div2",
2187 ps_cur_slice->i1_slice_alpha_c0_offset >> 1);
2188
2189 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf)
2190 << 1;
2191 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
2192 {
2193 return ERROR_INV_SLICE_HDR_T;
2194 }
2195 ps_cur_slice->i1_slice_beta_offset = i_temp;
2196 COPYTHECONTEXT("SH: slice_beta_offset_div2",
2197 ps_cur_slice->i1_slice_beta_offset >> 1);
2198 }
2199 else
2200 {
2201 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
2202 ps_cur_slice->i1_slice_beta_offset = 0;
2203 }
2204 }
2205 else
2206 {
2207 ps_cur_slice->u1_disable_dblk_filter_idc = 0;
2208 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
2209 ps_cur_slice->i1_slice_beta_offset = 0;
2210 }
2211
2212 ps_dec->u1_slice_header_done = 2;
2213
2214 if(ps_pps->u1_entropy_coding_mode)
2215 {
2216 SWITCHOFFTRACE; SWITCHONTRACECABAC;
2217 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cabac;
2218 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cabac;
2219 ih264d_init_cabac_contexts(P_SLICE, ps_dec);
2220
2221 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
2222 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_mbaff;
2223 else
2224 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_nonmbaff;
2225 }
2226 else
2227 {
2228 SWITCHONTRACE; SWITCHOFFTRACECABAC;
2229 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cavlc;
2230 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cavlc;
2231 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
2232 {
2233 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_mbaff;
2234 }
2235 else
2236 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_nonmbaff;
2237 }
2238
2239 ps_dec->u1_B = 0;
2240 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
2241 ret = ps_dec->pf_parse_inter_slice(ps_dec, ps_cur_slice, u2_first_mb_in_slice);
2242 if(ret != OK)
2243 return ret;
2244 // ps_dec->curr_slice_in_error = 0 ;
2245 return OK;
2246 }
2247