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