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
1570 if((ps_dec->u4_num_cores == 3) &&
1571 ((ps_dec->u4_app_disable_deblk_frm == 0) || ps_dec->i1_recon_in_thread3_flag)
1572 && (ps_dec->u4_bs_deblk_thread_created == 0))
1573 {
1574 ps_dec->u4_start_recon_deblk = 0;
1575 ithread_create(ps_dec->pv_bs_deblk_thread_handle, NULL,
1576 (void *)ih264d_recon_deblk_thread,
1577 (void *)ps_dec);
1578 ps_dec->u4_bs_deblk_thread_created = 1;
1579 }
1580 }
1581 }
1582 }
1583 else
1584 {
1585 // Middle / last slice
1586
1587 dec_slice_struct_t *ps_parse_cur_slice;
1588 ps_parse_cur_slice = ps_dec->ps_dec_slice_buf + ps_dec->u2_cur_slice_num;
1589
1590 if(ps_dec->u1_slice_header_done
1591 && ps_parse_cur_slice == ps_dec->ps_parse_cur_slice)
1592 {
1593 // Slice data corrupted
1594 // in the case of mbaff, conceal from the even mb.
1595 if((ps_dec->ps_cur_slice->u1_mbaff_frame_flag) && (ps_dec->u4_num_mbs_cur_nmb & 1))
1596 {
1597 ps_dec->u4_num_mbs_cur_nmb = ps_dec->u4_num_mbs_cur_nmb - 1;
1598 ps_dec->u2_cur_mb_addr--;
1599 }
1600
1601 u1_num_mbs = ps_dec->u4_num_mbs_cur_nmb;
1602 if(u1_num_mbs)
1603 {
1604 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs - 1;
1605 }
1606 else
1607 {
1608 if(ps_dec->u1_separate_parse)
1609 {
1610 ps_cur_mb_info = ps_dec->ps_nmb_info;
1611 }
1612 else
1613 {
1614 ps_cur_mb_info = ps_dec->ps_nmb_info
1615 + ps_dec->u4_num_mbs_prev_nmb - 1;
1616 }
1617 }
1618
1619 ps_dec->u2_mby = ps_cur_mb_info->u2_mby;
1620 ps_dec->u2_mbx = ps_cur_mb_info->u2_mbx;
1621
1622 ps_dec->u1_mb_ngbr_availablity =
1623 ps_cur_mb_info->u1_mb_ngbr_availablity;
1624
1625 if(u1_num_mbs)
1626 {
1627 // Going back 1 mb
1628 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_prev_mb_parse_tu_coeff_data;
1629 ps_dec->u2_cur_mb_addr--;
1630 ps_dec->i4_submb_ofst -= SUB_BLK_SIZE;
1631
1632 // Parse/decode N-MB left unparsed
1633 if (ps_dec->u1_pr_sl_type == P_SLICE
1634 || ps_dec->u1_pr_sl_type == B_SLICE)
1635 {
1636 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1637 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1638 }
1639
1640 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1641 u1_end_of_row = (!u1_num_mbs_next)
1642 && (!(ps_dec->ps_cur_slice->u1_mbaff_frame_flag && (u1_num_mbs & 0x01)));
1643 u1_slice_end = 1;
1644 u1_tfr_n_mb = 1;
1645 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1646
1647 if(ps_dec->u1_separate_parse)
1648 {
1649 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1650 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1651 ps_dec->ps_nmb_info += u1_num_mbs;
1652 }
1653 else
1654 {
1655 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1656 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1657 }
1658 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1659 ps_dec->u1_mb_idx = 0;
1660 ps_dec->u4_num_mbs_cur_nmb = 0;
1661 }
1662
1663 if(ps_dec->u2_total_mbs_coded
1664 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1665 {
1666 ps_dec->u1_pic_decode_done = 1;
1667 return 0;
1668 }
1669
1670 /* Inserting new slice only if the current slice has atleast 1 MB*/
1671 if(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
1672 (UWORD32)(ps_dec->u2_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
1673 {
1674 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1675 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1676 ps_dec->u2_cur_slice_num++;
1677 ps_dec->ps_parse_cur_slice++;
1678 }
1679
1680 }
1681 else
1682 {
1683 // Slice missing / header corrupted
1684 ps_dec->ps_parse_cur_slice = ps_dec->ps_dec_slice_buf
1685 + ps_dec->u2_cur_slice_num;
1686 }
1687 }
1688
1689 /******************************************************/
1690 /* Initializations to new slice */
1691 /******************************************************/
1692 {
1693 WORD32 num_entries;
1694 WORD32 size;
1695 UWORD8 *pu1_buf;
1696
1697 num_entries = MAX_FRAMES;
1698 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
1699 (0 == ps_dec->i4_display_delay))
1700 {
1701 num_entries = 1;
1702 }
1703 num_entries = ((2 * num_entries) + 1);
1704 num_entries *= 2;
1705
1706 size = num_entries * sizeof(void *);
1707 size += PAD_MAP_IDX_POC * sizeof(void *);
1708
1709 pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf;
1710 pu1_buf += size * ps_dec->u2_cur_slice_num;
1711 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **)pu1_buf;
1712 }
1713 u1_mbaff = ps_slice->u1_mbaff_frame_flag;
1714 ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
1715 ps_dec->ps_cur_slice->i1_slice_alpha_c0_offset = 0;
1716 ps_dec->ps_cur_slice->i1_slice_beta_offset = 0;
1717
1718 if(ps_dec->ps_cur_slice->u1_field_pic_flag)
1719 ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num;
1720
1721 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
1722 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd;
1723
1724
1725 if(ps_dec->u1_separate_parse)
1726 {
1727 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
1728 }
1729 else
1730 {
1731 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1732 }
1733
1734 /******************************************************/
1735 /* Initializations specific to P slice */
1736 /******************************************************/
1737 u1_inter_mb_type = P_MB;
1738 u1_deblk_mb_type = D_INTER_MB;
1739
1740 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE;
1741 ps_dec->ps_parse_cur_slice->slice_type = P_SLICE;
1742 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
1743 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1744 ps_dec->u2_mbx =
1745 (MOD(ps_dec->ps_cur_slice->u2_first_mb_in_slice - 1, ps_dec->u2_frm_wd_in_mbs));
1746 ps_dec->u2_mby =
1747 (DIV(ps_dec->ps_cur_slice->u2_first_mb_in_slice - 1, ps_dec->u2_frm_wd_in_mbs));
1748 ps_dec->u2_mby <<= u1_mbaff;
1749
1750 /******************************************************/
1751 /* Parsing / decoding the slice */
1752 /******************************************************/
1753 ps_dec->u1_slice_header_done = 2;
1754 ps_dec->u1_qp = ps_slice->u1_slice_qp;
1755 ih264d_update_qp(ps_dec, 0);
1756 u1_mb_idx = ps_dec->u1_mb_idx;
1757 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1758 u1_num_mbs = u1_mb_idx;
1759
1760 u1_slice_end = 0;
1761 u1_tfr_n_mb = 0;
1762 u1_decode_nmb = 0;
1763 u1_num_mbsNby2 = 0;
1764 i2_cur_mb_addr = ps_dec->u2_total_mbs_coded;
1765 i2_mb_skip_run = num_mb_skip;
1766
1767 while(!u1_slice_end)
1768 {
1769 UWORD8 u1_mb_type;
1770
1771 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
1772 break;
1773
1774 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
1775 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
1776
1777 ps_cur_mb_info->u1_Mux = 0;
1778 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
1779 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
1780
1781 ps_cur_mb_info->u1_end_of_slice = 0;
1782
1783 /* Storing Default partition info */
1784 ps_parse_mb_data->u1_num_part = 1;
1785 ps_parse_mb_data->u1_isI_mb = 0;
1786
1787 /**************************************************************/
1788 /* Get the required information for decoding of MB */
1789 /**************************************************************/
1790 /* mb_x, mb_y, neighbor availablity, */
1791 if (u1_mbaff)
1792 ih264d_get_mb_info_cavlc_mbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
1793 else
1794 ih264d_get_mb_info_cavlc_nonmbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
1795
1796 /* Set the deblocking parameters for this MB */
1797 if(ps_dec->u4_app_disable_deblk_frm == 0)
1798 {
1799 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
1800 ps_dec->u1_mb_ngbr_availablity,
1801 ps_dec->u1_cur_mb_fld_dec_flag);
1802 }
1803
1804 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
1805 ps_dec->i1_prev_mb_qp_delta = 0;
1806 ps_dec->u1_sub_mb_num = 0;
1807 ps_cur_mb_info->u1_mb_type = MB_SKIP;
1808 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
1809 ps_cur_mb_info->u1_cbp = 0;
1810
1811 /* Storing Skip partition info */
1812 ps_part_info = ps_dec->ps_part;
1813 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
1814 ps_part_info->u1_sub_mb_num = 0;
1815 ps_dec->ps_part++;
1816
1817 /* Update Nnzs */
1818 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
1819
1820 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1821 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1822
1823 i2_mb_skip_run--;
1824
1825 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
1826
1827 if (u1_mbaff)
1828 {
1829 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
1830 }
1831
1832 /**************************************************************/
1833 /* Get next Macroblock address */
1834 /**************************************************************/
1835 i2_cur_mb_addr++;
1836
1837 u1_num_mbs++;
1838 u1_num_mbsNby2++;
1839 ps_parse_mb_data++;
1840
1841 /****************************************************************/
1842 /* Check for End Of Row and other flags that determine when to */
1843 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1844 /* N-Mb */
1845 /****************************************************************/
1846 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1847 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
1848 u1_slice_end = !i2_mb_skip_run;
1849 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
1850 || u1_slice_end;
1851 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
1852 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1853
1854 if(u1_decode_nmb)
1855 {
1856 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1857 u1_num_mbsNby2 = 0;
1858
1859 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1860 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1861
1862 if(ps_dec->u1_separate_parse)
1863 {
1864 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1865 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1866 ps_dec->ps_nmb_info += u1_num_mbs;
1867 }
1868 else
1869 {
1870 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
1871 u1_tfr_n_mb, u1_end_of_row);
1872 }
1873 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1874 if(u1_tfr_n_mb)
1875 u1_num_mbs = 0;
1876 u1_mb_idx = u1_num_mbs;
1877 ps_dec->u1_mb_idx = u1_num_mbs;
1878 }
1879 }
1880
1881 ps_dec->u4_num_mbs_cur_nmb = 0;
1882 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
1883 - ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice;
1884
1885 H264_DEC_DEBUG_PRINT("Mbs in slice: %d\n", ps_dec->ps_cur_slice->u4_mbs_in_slice);
1886
1887
1888 /* incremented here only if first slice is inserted */
1889 if(ps_dec->u4_first_slice_in_pic != 0)
1890 {
1891 ps_dec->ps_parse_cur_slice++;
1892 ps_dec->u2_cur_slice_num++;
1893 }
1894
1895 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1896 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1897
1898 if(ps_dec->u2_total_mbs_coded
1899 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1900 {
1901 ps_dec->u1_pic_decode_done = 1;
1902 }
1903
1904 return 0;
1905
1906 }
1907
1908 /*!
1909 **************************************************************************
1910 * \if Function name : ih264d_decode_pslice \endif
1911 *
1912 * \brief
1913 * Decodes a P Slice
1914 *
1915 *
1916 * \return
1917 * 0 on Success and Error code otherwise
1918 **************************************************************************
1919 */
ih264d_parse_pslice(dec_struct_t * ps_dec,UWORD16 u2_first_mb_in_slice)1920 WORD32 ih264d_parse_pslice(dec_struct_t *ps_dec, UWORD16 u2_first_mb_in_slice)
1921 {
1922 dec_pic_params_t * ps_pps = ps_dec->ps_cur_pps;
1923 dec_slice_params_t * ps_cur_slice = ps_dec->ps_cur_slice;
1924 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
1925 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1926 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1927 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; //ps_dec->ps_cur_sps->u1_mb_aff_flag;
1928 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
1929
1930 UWORD64 u8_ref_idx_l0;
1931 UWORD32 u4_temp;
1932 WORD32 i_temp;
1933 WORD32 ret;
1934
1935 /*--------------------------------------------------------------------*/
1936 /* Read remaining contents of the slice header */
1937 /*--------------------------------------------------------------------*/
1938 {
1939 WORD8 *pi1_buf;
1940 WORD16 *pi2_mv = ps_dec->s_default_mv_pred.i2_mv;
1941 WORD32 *pi4_mv = (WORD32*)pi2_mv;
1942 WORD16 *pi16_refFrame;
1943
1944 pi1_buf = ps_dec->s_default_mv_pred.i1_ref_frame;
1945 pi16_refFrame = (WORD16*)pi1_buf;
1946 *pi4_mv = 0;
1947 *(pi4_mv + 1) = 0;
1948 *pi16_refFrame = OUT_OF_RANGE_REF;
1949 ps_dec->s_default_mv_pred.u1_col_ref_pic_idx = (UWORD8)-1;
1950 ps_dec->s_default_mv_pred.u1_pic_type = (UWORD8)-1;
1951 }
1952
1953 ps_cur_slice->u1_num_ref_idx_active_override_flag = ih264d_get_bit_h264(
1954 ps_bitstrm);
1955
1956 COPYTHECONTEXT("SH: num_ref_idx_override_flag",
1957 ps_cur_slice->u1_num_ref_idx_active_override_flag);
1958
1959 u8_ref_idx_l0 = ps_dec->ps_cur_pps->u1_num_ref_idx_lx_active[0];
1960 if(ps_cur_slice->u1_num_ref_idx_active_override_flag)
1961 {
1962 u8_ref_idx_l0 = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf) + (UWORD64)1;
1963 }
1964
1965 {
1966 UWORD8 u1_max_ref_idx = H264_MAX_REF_PICS << u1_field_pic_flag;
1967 if(u8_ref_idx_l0 > u1_max_ref_idx)
1968 {
1969 return ERROR_NUM_REF;
1970 }
1971 ps_cur_slice->u1_num_ref_idx_lx_active[0] = u8_ref_idx_l0;
1972 COPYTHECONTEXT("SH: num_ref_idx_l0_active_minus1",
1973 ps_cur_slice->u1_num_ref_idx_lx_active[0] - 1);
1974
1975 }
1976
1977 {
1978 UWORD8 uc_refIdxReFlagL0 = ih264d_get_bit_h264(ps_bitstrm);
1979 COPYTHECONTEXT("SH: ref_pic_list_reordering_flag_l0",uc_refIdxReFlagL0);
1980
1981 ih264d_init_ref_idx_lx_p(ps_dec);
1982 /* Store the value for future slices in the same picture */
1983 ps_dec->u1_num_ref_idx_lx_active_prev =
1984 ps_cur_slice->u1_num_ref_idx_lx_active[0];
1985
1986 /* Modified temporarily */
1987 if(uc_refIdxReFlagL0)
1988 {
1989 WORD8 ret;
1990 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
1991 ret = ih264d_ref_idx_reordering(ps_dec, 0);
1992 if(ret == -1)
1993 return ERROR_REFIDX_ORDER_T;
1994 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
1995 }
1996 else
1997 ps_dec->ps_ref_pic_buf_lx[0] =
1998 ps_dec->ps_dpb_mgr->ps_init_dpb[0];
1999 }
2000 /* Create refIdx to POC mapping */
2001 {
2002 void **pui_map_ref_idx_to_poc_lx0, **pui_map_ref_idx_to_poc_lx1;
2003 WORD8 idx;
2004 struct pic_buffer_t *ps_pic;
2005
2006 pui_map_ref_idx_to_poc_lx0 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L0;
2007 pui_map_ref_idx_to_poc_lx0[0] = 0; //For ref_idx = -1
2008 pui_map_ref_idx_to_poc_lx0++;
2009 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
2010 {
2011 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
2012 pui_map_ref_idx_to_poc_lx0[idx] = (ps_pic->pu1_buf1);
2013 }
2014
2015 /* Bug Fix Deblocking */
2016 pui_map_ref_idx_to_poc_lx1 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L1;
2017 pui_map_ref_idx_to_poc_lx1[0] = 0;
2018
2019 if(u1_mbaff)
2020 {
2021 void **ppv_map_ref_idx_to_poc_lx_t, **ppv_map_ref_idx_to_poc_lx_b;
2022 void **ppv_map_ref_idx_to_poc_lx_t1, **ppv_map_ref_idx_to_poc_lx_b1;
2023 ppv_map_ref_idx_to_poc_lx_t = ps_dec->ppv_map_ref_idx_to_poc
2024 + TOP_LIST_FLD_L0;
2025 ppv_map_ref_idx_to_poc_lx_b = ps_dec->ppv_map_ref_idx_to_poc
2026 + BOT_LIST_FLD_L0;
2027
2028 ppv_map_ref_idx_to_poc_lx_t[0] = 0; // For ref_idx = -1
2029 ppv_map_ref_idx_to_poc_lx_t++;
2030 ppv_map_ref_idx_to_poc_lx_b[0] = 0; // For ref_idx = -1
2031 ppv_map_ref_idx_to_poc_lx_b++;
2032
2033 idx = 0;
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 ppv_map_ref_idx_to_poc_lx_t[0] = (ps_pic->pu1_buf1);
2038 ppv_map_ref_idx_to_poc_lx_b[1] = (ps_pic->pu1_buf1);
2039
2040 ppv_map_ref_idx_to_poc_lx_b[0] = (ps_pic->pu1_buf1) + 1;
2041 ppv_map_ref_idx_to_poc_lx_t[1] = (ps_pic->pu1_buf1) + 1;
2042
2043 ppv_map_ref_idx_to_poc_lx_t += 2;
2044 ppv_map_ref_idx_to_poc_lx_b += 2;
2045 }
2046 ppv_map_ref_idx_to_poc_lx_t1 = ps_dec->ppv_map_ref_idx_to_poc
2047 + TOP_LIST_FLD_L1;
2048 ppv_map_ref_idx_to_poc_lx_t1[0] = 0;
2049 ppv_map_ref_idx_to_poc_lx_b1 = ps_dec->ppv_map_ref_idx_to_poc
2050 + BOT_LIST_FLD_L1;
2051 ppv_map_ref_idx_to_poc_lx_b1[0] = 0;
2052
2053 }
2054
2055 if(ps_dec->u4_num_cores >= 3)
2056 {
2057 WORD32 num_entries;
2058 WORD32 size;
2059
2060 num_entries = MAX_FRAMES;
2061 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
2062 (0 == ps_dec->i4_display_delay))
2063 {
2064 num_entries = 1;
2065 }
2066 num_entries = ((2 * num_entries) + 1);
2067 num_entries *= 2;
2068
2069 size = num_entries * sizeof(void *);
2070 size += PAD_MAP_IDX_POC * sizeof(void *);
2071
2072 memcpy((void *)ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc,
2073 ps_dec->ppv_map_ref_idx_to_poc,
2074 size);
2075 }
2076
2077
2078 }
2079 if(ps_pps->u1_wted_pred_flag)
2080 {
2081 ret = ih264d_parse_pred_weight_table(ps_cur_slice, ps_bitstrm);
2082 if(ret != OK)
2083 return ret;
2084 ih264d_form_pred_weight_matrix(ps_dec);
2085 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
2086 }
2087 else
2088 {
2089 ps_dec->ps_cur_slice->u2_log2Y_crwd = 0;
2090 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
2091 }
2092
2093 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd =
2094 ps_dec->ps_cur_slice->u2_log2Y_crwd;
2095
2096 if(u1_mbaff && (u1_field_pic_flag == 0))
2097 {
2098 ih264d_convert_frm_mbaff_list(ps_dec);
2099 }
2100
2101 /* G050 */
2102 if(ps_cur_slice->u1_nal_ref_idc != 0)
2103 {
2104 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
2105 {
2106 i_temp = ih264d_read_mmco_commands(ps_dec);
2107 if (i_temp < 0)
2108 {
2109 return ERROR_DBP_MANAGER_T;
2110 }
2111 ps_dec->u4_bitoffset = i_temp;
2112 }
2113 else
2114 ps_bitstrm->u4_ofst += ps_dec->u4_bitoffset;
2115
2116 }
2117 /* G050 */
2118
2119 if(ps_pps->u1_entropy_coding_mode == CABAC)
2120 {
2121 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2122
2123 if(u4_temp > MAX_CABAC_INIT_IDC)
2124 {
2125 return ERROR_INV_SLICE_HDR_T;
2126 }
2127 ps_cur_slice->u1_cabac_init_idc = u4_temp;
2128 COPYTHECONTEXT("SH: cabac_init_idc",ps_cur_slice->u1_cabac_init_idc);
2129 }
2130
2131 /* Read slice_qp_delta */
2132 WORD64 i8_temp = (WORD64)ps_pps->u1_pic_init_qp
2133 + ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2134 if((i8_temp < MIN_H264_QP) || (i8_temp > MAX_H264_QP))
2135 {
2136 return ERROR_INV_RANGE_QP_T;
2137 }
2138 ps_cur_slice->u1_slice_qp = i8_temp;
2139 COPYTHECONTEXT("SH: slice_qp_delta",
2140 (WORD8)(ps_cur_slice->u1_slice_qp - ps_pps->u1_pic_init_qp));
2141
2142 if(ps_pps->u1_deblocking_filter_parameters_present_flag == 1)
2143 {
2144 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2145 if(u4_temp > SLICE_BOUNDARY_DBLK_DISABLED)
2146 {
2147 return ERROR_INV_SLICE_HDR_T;
2148 }
2149
2150 COPYTHECONTEXT("SH: disable_deblocking_filter_idc", u4_temp);
2151 ps_cur_slice->u1_disable_dblk_filter_idc = u4_temp;
2152 if(u4_temp != 1)
2153 {
2154 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf)
2155 << 1;
2156 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
2157 {
2158 return ERROR_INV_SLICE_HDR_T;
2159 }
2160 ps_cur_slice->i1_slice_alpha_c0_offset = i_temp;
2161 COPYTHECONTEXT("SH: slice_alpha_c0_offset_div2",
2162 ps_cur_slice->i1_slice_alpha_c0_offset >> 1);
2163
2164 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf)
2165 << 1;
2166 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
2167 {
2168 return ERROR_INV_SLICE_HDR_T;
2169 }
2170 ps_cur_slice->i1_slice_beta_offset = i_temp;
2171 COPYTHECONTEXT("SH: slice_beta_offset_div2",
2172 ps_cur_slice->i1_slice_beta_offset >> 1);
2173 }
2174 else
2175 {
2176 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
2177 ps_cur_slice->i1_slice_beta_offset = 0;
2178 }
2179 }
2180 else
2181 {
2182 ps_cur_slice->u1_disable_dblk_filter_idc = 0;
2183 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
2184 ps_cur_slice->i1_slice_beta_offset = 0;
2185 }
2186
2187 ps_dec->u1_slice_header_done = 2;
2188
2189 if(ps_pps->u1_entropy_coding_mode)
2190 {
2191 SWITCHOFFTRACE; SWITCHONTRACECABAC;
2192 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cabac;
2193 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cabac;
2194 ih264d_init_cabac_contexts(P_SLICE, ps_dec);
2195
2196 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
2197 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_mbaff;
2198 else
2199 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_nonmbaff;
2200 }
2201 else
2202 {
2203 SWITCHONTRACE; SWITCHOFFTRACECABAC;
2204 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cavlc;
2205 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cavlc;
2206 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
2207 {
2208 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_mbaff;
2209 }
2210 else
2211 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_nonmbaff;
2212 }
2213
2214 ps_dec->u1_B = 0;
2215 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
2216 ret = ps_dec->pf_parse_inter_slice(ps_dec, ps_cur_slice, u2_first_mb_in_slice);
2217 if(ret != OK)
2218 return ret;
2219 // ps_dec->curr_slice_in_error = 0 ;
2220 return OK;
2221 }
2222