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