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