Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libavc / 251b007eccf5a0ddac897ce27de88d3901bc5d00 / . / decoder / ih264d_parse_pslice.c
blob: f300e2b770f2090ceeb5300cd23af695219cbd31 [file] [log] [blame]
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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"
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]60#include "ih264d_thread_compute_bs.h"
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]61#include "ih264d_process_bslice.h"
62#include "ithread.h"
63#include "ih264d_utils.h"
64#include "ih264d_format_conv.h"
65
66void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec);
67void 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 */
82WORD32 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 */
430WORD32 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 */
749void 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/*****************************************************************************/
800WORD32 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;
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]824 WORD32 ret = OK;
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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;
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]849 ih264d_update_qp(ps_dec, 0);
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]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 }
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]882
883 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]884 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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 */
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1047 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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 {
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]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);
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]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
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]1088 - (u2_first_mb_in_slice << u1_mbaff);
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1089
1090 return ret;
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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
1119WORD32 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;
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1145 WORD32 ret = OK;
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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 /******************************************************/
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]1166 ps_dec->u1_qp = ps_slice->u1_slice_qp;
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1167 ih264d_update_qp(ps_dec, 0);
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1182 ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1183
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]1184 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
1185 {
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1186 ret = ERROR_MB_ADDRESS_T;
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]1187 break;
1188 }
1189
1190
1191 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1192 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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 {
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1384 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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 {
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]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);
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1424 ps_dec->u4_num_mbs_cur_nmb = 0;
1425 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]1426 - (u2_first_mb_in_slice << u1_mbaff);
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1427
1428
1429 return ret;
1430}
1431
1432WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
1433 WORD32 num_mb_skip,
1434 UWORD8 u1_is_idr_slice,
Hamsalekha S9f0dcba2015-06-09 15:54:31 +0530[diff] [blame]1435 UWORD16 u2_frame_num,
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]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;
Hamsalekha S9f0dcba2015-06-09 15:54:31 +0530[diff] [blame]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 }
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1469
1470 if(prev_slice_err == 1)
1471 {
Hamsalekha S9f0dcba2015-06-09 15:54:31 +0530[diff] [blame]1472 /* first slice - missing/header corruption */
1473 ps_dec->ps_cur_slice->u2_frame_num = u2_frame_num;
1474
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]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;
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]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;
Hamsalekha S9f0dcba2015-06-09 15:54:31 +0530[diff] [blame]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]);
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1504
Hamsalekha S9f0dcba2015-06-09 15:54:31 +0530[diff] [blame]1505 if(ret != OK)
1506 {
1507 return ret;
1508 }
1509 }
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]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;
Hamsalekha S9f0dcba2015-06-09 15:54:31 +0530[diff] [blame]1632 return 0;
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]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 }
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]1648 }
1649
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1650 /******************************************************/
1651 /* Initializations to new slice */
1652 /******************************************************/
1653 {
1654 WORD32 num_entries;
1655 WORD32 size;
1656 UWORD8 *pu1_buf;
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]1657
Harish Mahendrakar251b0072015-08-04 09:55:15 +0530[diff] [blame^]1658 num_entries = MAX_FRAMES;
1659 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
1660 (0 == ps_dec->i4_display_delay))
1661 {
1662 num_entries = 1;
1663 }
1664 num_entries = ((2 * num_entries) + 1);
1665 if(BASE_PROFILE_IDC != ps_dec->ps_cur_sps->u1_profile_idc)
1666 {
1667 num_entries *= 2;
1668 }
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1669 size = num_entries * sizeof(void *);
1670 size += PAD_MAP_IDX_POC * sizeof(void *);
1671
1672 pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf;
1673 pu1_buf += size * ps_dec->u2_cur_slice_num;
1674 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **)pu1_buf;
1675 }
1676
1677 ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded << u1_mbaff;
1678 if(ps_dec->ps_cur_slice->u1_field_pic_flag)
1679 ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num;
1680
1681 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded << u1_mbaff;
1682 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd;
1683
1684
1685 if(ps_dec->u1_separate_parse)
1686 {
1687 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
1688 }
1689 else
1690 {
1691 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1692 }
1693
1694 /******************************************************/
1695 /* Initializations specific to P slice */
1696 /******************************************************/
1697 u1_inter_mb_type = P_MB;
1698 u1_deblk_mb_type = D_INTER_MB;
1699
1700 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE;
1701 ps_dec->ps_parse_cur_slice->slice_type = P_SLICE;
1702 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
1703 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1704
1705 /******************************************************/
1706 /* Parsing / decoding the slice */
1707 /******************************************************/
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1708 ps_dec->u1_slice_header_done = 2;
1709 ps_dec->u1_qp = ps_slice->u1_slice_qp;
1710 ih264d_update_qp(ps_dec, 0);
1711 u1_mb_idx = ps_dec->u1_mb_idx;
1712 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1713 u1_num_mbs = u1_mb_idx;
1714
1715 u1_slice_end = 0;
1716 u1_tfr_n_mb = 0;
1717 u1_decode_nmb = 0;
1718 u1_num_mbsNby2 = 0;
1719 i2_cur_mb_addr = ps_dec->u2_total_mbs_coded;
1720 i2_mb_skip_run = num_mb_skip;
1721
1722 while(!u1_slice_end)
1723 {
1724 UWORD8 u1_mb_type;
1725
1726 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
1727 break;
1728
1729 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
1730 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
1731
1732 ps_cur_mb_info->u1_Mux = 0;
1733 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
1734 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
1735
1736 ps_cur_mb_info->u1_end_of_slice = 0;
1737
1738 /* Storing Default partition info */
1739 ps_parse_mb_data->u1_num_part = 1;
1740 ps_parse_mb_data->u1_isI_mb = 0;
1741
1742 /**************************************************************/
1743 /* Get the required information for decoding of MB */
1744 /**************************************************************/
1745 /* mb_x, mb_y, neighbor availablity, */
1746 if (u1_mbaff)
1747 ih264d_get_mb_info_cavlc_mbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
1748 else
1749 ih264d_get_mb_info_cavlc_nonmbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
1750
1751 /* Set the deblocking parameters for this MB */
1752 if(ps_dec->u4_app_disable_deblk_frm == 0)
1753 {
1754 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
1755 ps_dec->u1_mb_ngbr_availablity,
1756 ps_dec->u1_cur_mb_fld_dec_flag);
1757 }
1758
1759 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
1760 ps_dec->i1_prev_mb_qp_delta = 0;
1761 ps_dec->u1_sub_mb_num = 0;
1762 ps_cur_mb_info->u1_mb_type = MB_SKIP;
1763 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
1764 ps_cur_mb_info->u1_cbp = 0;
1765
1766 /* Storing Skip partition info */
1767 ps_part_info = ps_dec->ps_part;
1768 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
1769 ps_part_info->u1_sub_mb_num = 0;
1770 ps_dec->ps_part++;
1771
1772 /* Update Nnzs */
1773 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
1774
1775 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1776 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1777
1778 i2_mb_skip_run--;
1779
1780 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
1781
1782 if (u1_mbaff)
1783 {
1784 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
1785 }
1786
1787 /**************************************************************/
1788 /* Get next Macroblock address */
1789 /**************************************************************/
1790 i2_cur_mb_addr++;
1791
1792 u1_num_mbs++;
1793 ps_dec->u2_total_mbs_coded++;
1794 u1_num_mbsNby2++;
1795 ps_parse_mb_data++;
1796
1797 /****************************************************************/
1798 /* Check for End Of Row and other flags that determine when to */
1799 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1800 /* N-Mb */
1801 /****************************************************************/
1802 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1803 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
1804 u1_slice_end = !i2_mb_skip_run;
1805 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
1806 || u1_slice_end;
1807 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
1808 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1809
1810 if(u1_decode_nmb)
1811 {
1812 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1813 u1_num_mbsNby2 = 0;
1814
1815 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1816 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1817
1818 if(ps_dec->u1_separate_parse)
1819 {
1820 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
1821 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
1822 ps_dec->ps_nmb_info += u1_num_mbs;
1823 }
1824 else
1825 {
1826 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
1827 u1_tfr_n_mb, u1_end_of_row);
1828 }
1829
1830 if(u1_tfr_n_mb)
1831 u1_num_mbs = 0;
1832 u1_mb_idx = u1_num_mbs;
1833 ps_dec->u1_mb_idx = u1_num_mbs;
1834 }
1835 }
1836
1837 ps_dec->u4_num_mbs_cur_nmb = 0;
1838 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
1839 - ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice;
1840
1841 H264_DEC_DEBUG_PRINT("Mbs in slice: %d\n", ps_dec->ps_cur_slice->u4_mbs_in_slice);
1842
1843 ps_dec->u2_cur_slice_num++;
Hamsalekha S9f0dcba2015-06-09 15:54:31 +0530[diff] [blame]1844
1845 /* incremented here only if first slice is inserted */
1846 if(ps_dec->u4_first_slice_in_pic != 0)
1847 ps_dec->ps_parse_cur_slice++;
1848
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1849 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1850 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1851
1852 if(ps_dec->u2_total_mbs_coded
1853 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1854 {
1855 ps_dec->u1_pic_decode_done = 1;
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]1856 }
1857
1858 return 0;
1859
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]1860}
1861
1862/*!
1863 **************************************************************************
1864 * \if Function name : ih264d_decode_pslice \endif
1865 *
1866 * \brief
1867 * Decodes a P Slice
1868 *
1869 *
1870 * \return
1871 * 0 on Success and Error code otherwise
1872 **************************************************************************
1873 */
1874WORD32 ih264d_parse_pslice(dec_struct_t *ps_dec, UWORD16 u2_first_mb_in_slice)
1875{
1876 dec_pic_params_t * ps_pps = ps_dec->ps_cur_pps;
1877 dec_slice_params_t * ps_cur_slice = ps_dec->ps_cur_slice;
1878 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
1879 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1880 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1881 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; //ps_dec->ps_cur_sps->u1_mb_aff_flag;
1882 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
1883
1884 UWORD32 u4_temp;
1885 WORD32 i_temp;
1886 WORD32 ret;
1887
1888 /*--------------------------------------------------------------------*/
1889 /* Read remaining contents of the slice header */
1890 /*--------------------------------------------------------------------*/
1891 {
1892 WORD8 *pi1_buf;
1893 WORD16 *pi2_mv = ps_dec->s_default_mv_pred.i2_mv;
1894 WORD32 *pi4_mv = (WORD32*)pi2_mv;
1895 WORD16 *pi16_refFrame;
1896
1897 pi1_buf = ps_dec->s_default_mv_pred.i1_ref_frame;
1898 pi16_refFrame = (WORD16*)pi1_buf;
1899 *pi4_mv = 0;
1900 *(pi4_mv + 1) = 0;
1901 *pi16_refFrame = OUT_OF_RANGE_REF;
1902 ps_dec->s_default_mv_pred.u1_col_ref_pic_idx = (UWORD8)-1;
1903 ps_dec->s_default_mv_pred.u1_pic_type = (UWORD8)-1;
1904 }
1905
1906 ps_cur_slice->u1_num_ref_idx_active_override_flag = ih264d_get_bit_h264(
1907 ps_bitstrm);
1908
1909 COPYTHECONTEXT("SH: num_ref_idx_override_flag",
1910 ps_cur_slice->u1_num_ref_idx_active_override_flag);
1911
1912 u4_temp = ps_dec->ps_cur_pps->u1_num_ref_idx_lx_active[0];
1913 if(ps_cur_slice->u1_num_ref_idx_active_override_flag)
1914 {
1915 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf) + 1;
1916 }
1917
1918 {
1919
1920
1921
1922 UWORD8 u1_max_ref_idx = MAX_FRAMES << u1_field_pic_flag;
1923 if(u4_temp > u1_max_ref_idx)
1924 {
1925 return ERROR_NUM_REF;
1926 }
1927 ps_cur_slice->u1_num_ref_idx_lx_active[0] = u4_temp;
1928 COPYTHECONTEXT("SH: num_ref_idx_l0_active_minus1",
1929 ps_cur_slice->u1_num_ref_idx_lx_active[0] - 1);
1930
1931 }
1932
1933 {
1934 UWORD8 uc_refIdxReFlagL0 = ih264d_get_bit_h264(ps_bitstrm);
1935 COPYTHECONTEXT("SH: ref_pic_list_reordering_flag_l0",uc_refIdxReFlagL0);
1936
1937 /* Initialize the Reference list once in Picture if the slice type */
1938 /* of first slice is between 5 to 9 defined in table 7.3 of standard */
1939 /* If picture contains both P & B slices then Initialize the Reference*/
1940 /* List only when it switches from P to B and B to P */
1941 {
1942 UWORD8 init_idx_flg = (ps_dec->u1_pr_sl_type
1943 != ps_dec->ps_cur_slice->u1_slice_type);
1944 if(ps_dec->u1_first_pb_nal_in_pic
1945 || (init_idx_flg & !ps_dec->u1_sl_typ_5_9)
1946 || ps_dec->u1_num_ref_idx_lx_active_prev
1947 != ps_cur_slice->u1_num_ref_idx_lx_active[0])
1948 {
1949 ih264d_init_ref_idx_lx_p(ps_dec);
1950 }
1951 if(ps_dec->u1_first_pb_nal_in_pic & ps_dec->u1_sl_typ_5_9)
1952 ps_dec->u1_first_pb_nal_in_pic = 0;
1953 }
1954 /* Store the value for future slices in the same picture */
1955 ps_dec->u1_num_ref_idx_lx_active_prev =
1956 ps_cur_slice->u1_num_ref_idx_lx_active[0];
1957
1958 /* Modified temporarily */
1959 if(uc_refIdxReFlagL0)
1960 {
1961 WORD8 ret;
1962 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
1963 ret = ih264d_ref_idx_reordering(ps_dec, 0);
1964 if(ret == -1)
1965 return ERROR_REFIDX_ORDER_T;
1966 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
1967 }
1968 else
1969 ps_dec->ps_ref_pic_buf_lx[0] =
1970 ps_dec->ps_dpb_mgr->ps_init_dpb[0];
1971 }
1972 /* Create refIdx to POC mapping */
1973 {
1974 void **pui_map_ref_idx_to_poc_lx0, **pui_map_ref_idx_to_poc_lx1;
1975 WORD8 idx;
1976 struct pic_buffer_t *ps_pic;
1977
1978 pui_map_ref_idx_to_poc_lx0 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L0;
1979 pui_map_ref_idx_to_poc_lx0[0] = 0; //For ref_idx = -1
1980 pui_map_ref_idx_to_poc_lx0++;
1981 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
1982 {
1983 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
1984 pui_map_ref_idx_to_poc_lx0[idx] = (ps_pic->pu1_buf1);
1985 }
1986
1987 /* Bug Fix Deblocking */
1988 pui_map_ref_idx_to_poc_lx1 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L1;
1989 pui_map_ref_idx_to_poc_lx1[0] = 0;
1990
1991 if(u1_mbaff)
1992 {
1993 void **ppv_map_ref_idx_to_poc_lx_t, **ppv_map_ref_idx_to_poc_lx_b;
1994 void **ppv_map_ref_idx_to_poc_lx_t1, **ppv_map_ref_idx_to_poc_lx_b1;
1995 ppv_map_ref_idx_to_poc_lx_t = ps_dec->ppv_map_ref_idx_to_poc
1996 + TOP_LIST_FLD_L0;
1997 ppv_map_ref_idx_to_poc_lx_b = ps_dec->ppv_map_ref_idx_to_poc
1998 + BOT_LIST_FLD_L0;
1999
2000 ppv_map_ref_idx_to_poc_lx_t[0] = 0; // For ref_idx = -1
2001 ppv_map_ref_idx_to_poc_lx_t++;
2002 ppv_map_ref_idx_to_poc_lx_b[0] = 0; // For ref_idx = -1
2003 ppv_map_ref_idx_to_poc_lx_b++;
2004
2005 idx = 0;
2006 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
2007 {
2008 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
2009 ppv_map_ref_idx_to_poc_lx_t[0] = (ps_pic->pu1_buf1);
2010 ppv_map_ref_idx_to_poc_lx_b[1] = (ps_pic->pu1_buf1);
2011
2012 ppv_map_ref_idx_to_poc_lx_b[0] = (ps_pic->pu1_buf1) + 1;
2013 ppv_map_ref_idx_to_poc_lx_t[1] = (ps_pic->pu1_buf1) + 1;
2014
2015 ppv_map_ref_idx_to_poc_lx_t += 2;
2016 ppv_map_ref_idx_to_poc_lx_b += 2;
2017 }
2018 ppv_map_ref_idx_to_poc_lx_t1 = ps_dec->ppv_map_ref_idx_to_poc
2019 + TOP_LIST_FLD_L1;
2020 ppv_map_ref_idx_to_poc_lx_t1[0] = 0;
2021 ppv_map_ref_idx_to_poc_lx_b1 = ps_dec->ppv_map_ref_idx_to_poc
2022 + BOT_LIST_FLD_L1;
2023 ppv_map_ref_idx_to_poc_lx_b1[0] = 0;
2024
2025 }
2026
2027 if(ps_dec->u4_num_cores >= 3)
2028 {
2029 WORD32 num_entries;
2030 WORD32 size;
2031
Harish Mahendrakar251b0072015-08-04 09:55:15 +0530[diff] [blame^]2032 num_entries = MAX_FRAMES;
2033 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
2034 (0 == ps_dec->i4_display_delay))
2035 {
2036 num_entries = 1;
2037 }
2038 num_entries = ((2 * num_entries) + 1);
2039 if(BASE_PROFILE_IDC != ps_dec->ps_cur_sps->u1_profile_idc)
2040 {
2041 num_entries *= 2;
2042 }
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]2043
2044 size = num_entries * sizeof(void *);
2045 size += PAD_MAP_IDX_POC * sizeof(void *);
2046
2047 memcpy((void *)ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc,
2048 ps_dec->ppv_map_ref_idx_to_poc,
2049 size);
2050 }
2051
2052
2053 }
2054 if(ps_pps->u1_wted_pred_flag)
2055 {
2056 ret = ih264d_parse_pred_weight_table(ps_cur_slice, ps_bitstrm);
2057 if(ret != OK)
2058 return ret;
2059 ih264d_form_pred_weight_matrix(ps_dec);
2060 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
2061 }
2062 else
2063 {
2064 ps_dec->ps_cur_slice->u2_log2Y_crwd = 0;
2065 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
2066 }
2067
2068 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd =
2069 ps_dec->ps_cur_slice->u2_log2Y_crwd;
2070
2071 if(u1_mbaff && (u1_field_pic_flag == 0))
2072 {
2073 ih264d_convert_frm_mbaff_list(ps_dec);
2074 }
2075
2076 /* G050 */
2077 if(ps_cur_slice->u1_nal_ref_idc != 0)
2078 {
2079 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
2080 ps_dec->u4_bitoffset = ih264d_read_mmco_commands(ps_dec);
2081 else
2082 ps_bitstrm->u4_ofst += ps_dec->u4_bitoffset;
2083
2084 }
2085 /* G050 */
2086
2087 if(ps_pps->u1_entropy_coding_mode == CABAC)
2088 {
2089 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2090
2091 if(u4_temp > MAX_CABAC_INIT_IDC)
2092 {
2093 return ERROR_INV_SLICE_HDR_T;
2094 }
2095 ps_cur_slice->u1_cabac_init_idc = u4_temp;
2096 COPYTHECONTEXT("SH: cabac_init_idc",ps_cur_slice->u1_cabac_init_idc);
2097 }
2098
2099 /* Read slice_qp_delta */
2100 i_temp = ps_pps->u1_pic_init_qp
2101 + ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2102 if((i_temp < 0) || (i_temp > 51))
2103 {
2104 return ERROR_INV_RANGE_QP_T;
2105 }
2106 ps_cur_slice->u1_slice_qp = i_temp;
2107 COPYTHECONTEXT("SH: slice_qp_delta",
2108 (WORD8)(ps_cur_slice->u1_slice_qp - ps_pps->u1_pic_init_qp));
2109
2110 if(ps_pps->u1_deblocking_filter_parameters_present_flag == 1)
2111 {
2112 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2113 if(u4_temp > SLICE_BOUNDARY_DBLK_DISABLED)
2114 {
2115 return ERROR_INV_SLICE_HDR_T;
2116 }
2117
2118 COPYTHECONTEXT("SH: disable_deblocking_filter_idc", u4_temp);
2119 ps_cur_slice->u1_disable_dblk_filter_idc = u4_temp;
2120 if(u4_temp != 1)
2121 {
2122 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf)
2123 << 1;
2124 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
2125 {
2126 return ERROR_INV_SLICE_HDR_T;
2127 }
2128 ps_cur_slice->i1_slice_alpha_c0_offset = i_temp;
2129 COPYTHECONTEXT("SH: slice_alpha_c0_offset_div2",
2130 ps_cur_slice->i1_slice_alpha_c0_offset >> 1);
2131
2132 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf)
2133 << 1;
2134 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
2135 {
2136 return ERROR_INV_SLICE_HDR_T;
2137 }
2138 ps_cur_slice->i1_slice_beta_offset = i_temp;
2139 COPYTHECONTEXT("SH: slice_beta_offset_div2",
2140 ps_cur_slice->i1_slice_beta_offset >> 1);
2141 }
2142 else
2143 {
2144 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
2145 ps_cur_slice->i1_slice_beta_offset = 0;
2146 }
2147 }
2148 else
2149 {
2150 ps_cur_slice->u1_disable_dblk_filter_idc = 0;
2151 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
2152 ps_cur_slice->i1_slice_beta_offset = 0;
2153 }
2154
Marco Nelissen8ef4c3f2015-06-03 07:26:32 -0700[diff] [blame]2155 ps_dec->u1_slice_header_done = 2;
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]2156
2157 if(ps_pps->u1_entropy_coding_mode)
2158 {
2159 SWITCHOFFTRACE; SWITCHONTRACECABAC;
2160 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cabac;
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]2161 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cabac;
2162 ih264d_init_cabac_contexts(P_SLICE, ps_dec);
2163
2164 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
2165 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_mbaff;
2166 else
2167 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_nonmbaff;
2168 }
2169 else
2170 {
2171 SWITCHONTRACE; SWITCHOFFTRACECABAC;
2172 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cavlc;
2173 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cavlc;
2174 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
2175 {
2176 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_mbaff;
2177 }
2178 else
2179 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_nonmbaff;
2180 }
2181
2182 ps_dec->u1_B = 0;
2183 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
2184 ret = ps_dec->pf_parse_inter_slice(ps_dec, ps_cur_slice, u2_first_mb_in_slice);
2185 if(ret != OK)
2186 return ret;
2187// ps_dec->curr_slice_in_error = 0 ;
2188 return OK;
2189}