1 /******************************************************************************
2 *
3 * Copyright (C) 2021 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 Name : imvcd_slice_functions.c */
24 /* */
25 /* Description : Functions for MVC Slice parsing, etc. */
26 /* */
27 /*****************************************************************************/
28
29 #include "ih264_typedefs.h"
30 #include "ih264_error.h"
31 #include "ih264_buf_mgr.h"
32 #include "ih264d_bitstrm.h"
33 #include "ih264d_deblocking.h"
34 #include "ih264d_debug.h"
35 #include "ih264d_defs.h"
36 #include "ih264d_error_handler.h"
37 #include "ih264d_inter_pred.h"
38 #include "ih264d_mb_utils.h"
39 #include "ih264d_mvpred.h"
40 #include "ih264d_parse_slice.h"
41 #include "ih264d_parse_islice.h"
42 #include "ih264d_process_bslice.h"
43 #include "ih264d_process_pslice.h"
44 #include "ih264d_quant_scaling.h"
45 #include "ih264d_tables.h"
46 #include "ih264d_thread_compute_bs.h"
47 #include "ih264d_thread_parse_decode.h"
48 #include "ih264d_structs.h"
49 #include "ih264d_utils.h"
50 #include "ih264d_api_utils.h"
51 #include "ithread.h"
52 #include "imvc_defs.h"
53 #include "imvcd_dpb_manager.h"
54 #include "imvcd_error_handler.h"
55 #include "imvcd_structs.h"
56 #include "imvcd_utils.h"
57
imvcd_set_first_mb_in_slice(dec_struct_t * ps_view_ctxt)58 static WORD32 imvcd_set_first_mb_in_slice(dec_struct_t *ps_view_ctxt)
59 {
60 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
61 dec_slice_params_t *ps_cur_slice = ps_view_ctxt->ps_cur_slice;
62
63 ps_cur_slice->u2_first_mb_in_slice = ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
64
65 if(ps_cur_slice->u2_first_mb_in_slice >=
66 (ps_view_ctxt->u2_frm_ht_in_mbs * ps_view_ctxt->u2_frm_wd_in_mbs))
67 {
68 return ERROR_CORRUPTED_SLICE;
69 }
70
71 if(((ps_cur_slice->u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <=
72 ps_view_ctxt->u2_cur_mb_addr) &&
73 (ps_view_ctxt->u4_first_slice_in_pic == 0))
74 {
75 return ERROR_CORRUPTED_SLICE;
76 }
77
78 COPYTHECONTEXT("SH: first_mb_in_slice", ps_cur_slice->u2_first_mb_in_slice);
79
80 return OK;
81 }
82
imvcd_set_slice_type(dec_struct_t * ps_view_ctxt)83 static WORD32 imvcd_set_slice_type(dec_struct_t *ps_view_ctxt)
84 {
85 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
86 dec_slice_params_t *ps_cur_slice = ps_view_ctxt->ps_cur_slice;
87
88 ps_cur_slice->u1_slice_type = ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
89
90 if(ps_cur_slice->u1_slice_type > 9)
91 {
92 return ERROR_INV_SLC_TYPE_T;
93 }
94
95 if(ps_cur_slice->u1_slice_type > 4)
96 {
97 ps_cur_slice->u1_slice_type -= 5;
98 }
99
100 COPYTHECONTEXT("SH: slice_type", ps_cur_slice->u1_slice_type);
101
102 return OK;
103 }
104
imvcd_set_cur_pps(dec_struct_t * ps_view_ctxt,UWORD8 * pu1_pps_id)105 static WORD32 imvcd_set_cur_pps(dec_struct_t *ps_view_ctxt, UWORD8 *pu1_pps_id)
106 {
107 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
108
109 pu1_pps_id[0] = ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
110
111 ps_view_ctxt->ps_cur_pps = &ps_view_ctxt->ps_pps[pu1_pps_id[0]];
112 ps_view_ctxt->ps_cur_sps = ps_view_ctxt->ps_pps[pu1_pps_id[0]].ps_sps;
113
114 if(!ps_view_ctxt->ps_cur_pps->u1_is_valid || !ps_view_ctxt->ps_cur_pps->ps_sps->u1_is_valid)
115 {
116 return ERROR_INV_SLICE_HDR_T;
117 }
118
119 COPYTHECONTEXT("SH: pps_id", pu1_pps_id[0]);
120
121 return OK;
122 }
123
imvcd_set_frame_num(dec_struct_t * ps_view_ctxt,UWORD8 u1_bits_in_frm_num)124 static WORD32 imvcd_set_frame_num(dec_struct_t *ps_view_ctxt, UWORD8 u1_bits_in_frm_num)
125 {
126 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
127 dec_slice_params_t *ps_cur_slice = ps_view_ctxt->ps_cur_slice;
128
129 ps_cur_slice->u2_frame_num = ih264d_get_bits_h264(ps_bitstrm, u1_bits_in_frm_num);
130
131 COPYTHECONTEXT("SH: frame_num", ps_cur_slice->u2_frame_num);
132
133 return OK;
134 }
135
imvcd_set_idr_pic_id(dec_struct_t * ps_view_ctxt,UWORD32 * pu4_idr_pic_id)136 static WORD32 imvcd_set_idr_pic_id(dec_struct_t *ps_view_ctxt, UWORD32 *pu4_idr_pic_id)
137 {
138 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
139
140 pu4_idr_pic_id[0] = ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
141
142 if(pu4_idr_pic_id[0] > 65535)
143 {
144 return ERROR_INV_SLICE_HDR_T;
145 }
146
147 COPYTHECONTEXT("SH: idr_pic_id", pu4_idr_pic_id[0]);
148
149 return OK;
150 }
151
imvcd_set_poc_lsb(dec_struct_t * ps_view_ctxt,WORD32 * pi4_pic_order_cnt_lsb,WORD32 i4_max_poc_lsb,UWORD8 u1_log2_max_poc_lsb)152 static WORD32 imvcd_set_poc_lsb(dec_struct_t *ps_view_ctxt, WORD32 *pi4_pic_order_cnt_lsb,
153 WORD32 i4_max_poc_lsb, UWORD8 u1_log2_max_poc_lsb)
154 {
155 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
156
157 pi4_pic_order_cnt_lsb[0] = ih264d_get_bits_h264(ps_bitstrm, u1_log2_max_poc_lsb);
158
159 if((pi4_pic_order_cnt_lsb[0] < 0) || (pi4_pic_order_cnt_lsb[0] > i4_max_poc_lsb))
160 {
161 return ERROR_INV_SLICE_HDR_T;
162 }
163
164 COPYTHECONTEXT("SH: pic_order_cnt_lsb", pi4_pic_order_cnt_lsb[0]);
165
166 return OK;
167 }
168
imvcd_set_delta_poc(dec_struct_t * ps_view_ctxt,WORD32 * pi4_delta_poc)169 static WORD32 imvcd_set_delta_poc(dec_struct_t *ps_view_ctxt, WORD32 *pi4_delta_poc)
170 {
171 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
172
173 pi4_delta_poc[0] = ih264d_sev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
174
175 COPYTHECONTEXT("SH: delta_pic_order_cnt", pi4_delta_poc[0]);
176
177 return OK;
178 }
179
imvcd_set_redundant_pic_cnt(dec_struct_t * ps_view_ctxt,UWORD8 * pu1_redundant_pic_cnt)180 static WORD32 imvcd_set_redundant_pic_cnt(dec_struct_t *ps_view_ctxt, UWORD8 *pu1_redundant_pic_cnt)
181 {
182 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
183
184 pu1_redundant_pic_cnt[0] = ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
185
186 if(pu1_redundant_pic_cnt[0] > MAX_REDUNDANT_PIC_CNT)
187 {
188 return ERROR_INV_SLICE_HDR_T;
189 }
190
191 COPYTHECONTEXT("SH: redundant_pic_cnt", pu1_redundant_pic_cnt[0]);
192
193 return OK;
194 }
195
imvcd_set_direct_spatial_mv_pred_flag(dec_struct_t * ps_view_ctxt)196 static WORD32 imvcd_set_direct_spatial_mv_pred_flag(dec_struct_t *ps_view_ctxt)
197 {
198 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
199 dec_slice_params_t *ps_cur_slice = ps_view_ctxt->ps_cur_slice;
200
201 ps_cur_slice->u1_direct_spatial_mv_pred_flag = ih264d_get_bit_h264(ps_bitstrm);
202
203 COPYTHECONTEXT("SH: direct_spatial_mv_pred_flag", ps_cur_slice->u1_direct_spatial_mv_pred_flag);
204
205 return OK;
206 }
207
imvcd_set_ref_idx_override_flag(dec_struct_t * ps_view_ctxt)208 static WORD32 imvcd_set_ref_idx_override_flag(dec_struct_t *ps_view_ctxt)
209 {
210 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
211 dec_slice_params_t *ps_cur_slice = ps_view_ctxt->ps_cur_slice;
212
213 ps_cur_slice->u1_num_ref_idx_active_override_flag = ih264d_get_bit_h264(ps_bitstrm);
214
215 COPYTHECONTEXT("SH: num_ref_idx_override_flag",
216 ps_cur_slice->u1_num_ref_idx_active_override_flag);
217
218 return OK;
219 }
220
imvcd_set_num_ref_idx_active(dec_struct_t * ps_view_ctxt,UWORD8 * pu1_num_ref_idx)221 static WORD32 imvcd_set_num_ref_idx_active(dec_struct_t *ps_view_ctxt, UWORD8 *pu1_num_ref_idx)
222 {
223 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
224 UWORD32 u4_num_ref_idx_m1 = ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
225
226 if(u4_num_ref_idx_m1 >= H264_MAX_REF_PICS)
227 {
228 return ERROR_NUM_REF;
229 }
230
231 pu1_num_ref_idx[0] = 1 + u4_num_ref_idx_m1;
232
233 COPYTHECONTEXT("SH: num_ref_idx_lx_active_minus1", u4_num_ref_idx_m1);
234
235 return OK;
236 }
237
imvcd_set_ref_pic_list_reordering_flag(dec_struct_t * ps_view_ctxt,UWORD8 * pu1_ref_idx_reorder_flag)238 static WORD32 imvcd_set_ref_pic_list_reordering_flag(dec_struct_t *ps_view_ctxt,
239 UWORD8 *pu1_ref_idx_reorder_flag)
240 {
241 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
242
243 pu1_ref_idx_reorder_flag[0] = ih264d_get_bit_h264(ps_bitstrm);
244
245 COPYTHECONTEXT("SH: ref_pic_list_reordering_flag_lx", pu1_ref_idx_reorder_flag[0]);
246
247 return OK;
248 }
249
imvcd_set_modification_of_pic_nums_idc(dec_struct_t * ps_view_ctxt,UWORD8 * pu1_modification_of_pic_nums_idc)250 static WORD32 imvcd_set_modification_of_pic_nums_idc(dec_struct_t *ps_view_ctxt,
251 UWORD8 *pu1_modification_of_pic_nums_idc)
252 {
253 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
254
255 pu1_modification_of_pic_nums_idc[0] = ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
256
257 COPYTHECONTEXT("SH: modification_of_pic_nums_idc", pu1_modification_of_pic_nums_idc[0]);
258
259 return OK;
260 }
261
imvcd_set_abs_diff_pic_num_minus1(dec_struct_t * ps_view_ctxt,WORD32 * pi4_abs_diff_pic_num_minus1)262 static WORD32 imvcd_set_abs_diff_pic_num_minus1(dec_struct_t *ps_view_ctxt,
263 WORD32 *pi4_abs_diff_pic_num_minus1)
264 {
265 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
266
267 pi4_abs_diff_pic_num_minus1[0] = ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
268
269 COPYTHECONTEXT("SH: abs_diff_pic_num_minus1", pi4_abs_diff_pic_num_minus1[0]);
270
271 return OK;
272 }
273
imvcd_set_abs_diff_view_idx_minus1(dec_struct_t * ps_view_ctxt,WORD32 * pi4_abs_diff_view_idx_minus1)274 static WORD32 imvcd_set_abs_diff_view_idx_minus1(dec_struct_t *ps_view_ctxt,
275 WORD32 *pi4_abs_diff_view_idx_minus1)
276 {
277 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
278
279 pi4_abs_diff_view_idx_minus1[0] = ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
280
281 COPYTHECONTEXT("SH: abs_diff_view_idx_minus1", pi4_abs_diff_view_idx_minus1[0]);
282
283 return OK;
284 }
285
imvcd_set_long_term_pic_num(dec_struct_t * ps_view_ctxt,WORD32 * pi4_long_term_pic_num)286 static WORD32 imvcd_set_long_term_pic_num(dec_struct_t *ps_view_ctxt, WORD32 *pi4_long_term_pic_num)
287 {
288 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
289
290 pi4_long_term_pic_num[0] = ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
291
292 COPYTHECONTEXT("SH: long_term_pic_num", pi4_long_term_pic_num[0]);
293
294 return OK;
295 }
296
imvcd_set_cabac_init_idc(dec_struct_t * ps_view_ctxt)297 static WORD32 imvcd_set_cabac_init_idc(dec_struct_t *ps_view_ctxt)
298 {
299 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
300 dec_slice_params_t *ps_cur_slice = ps_view_ctxt->ps_cur_slice;
301
302 ps_cur_slice->u1_cabac_init_idc = ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
303
304 if(ps_cur_slice->u1_cabac_init_idc > MAX_CABAC_INIT_IDC)
305 {
306 return ERROR_INV_SLICE_HDR_T;
307 }
308
309 COPYTHECONTEXT("SH: cabac_init_idc", ps_cur_slice->u1_cabac_init_idc);
310
311 return OK;
312 }
313
imvcd_set_slice_qp(dec_struct_t * ps_view_ctxt)314 static WORD32 imvcd_set_slice_qp(dec_struct_t *ps_view_ctxt)
315 {
316 WORD8 i1_slice_qp_delta;
317
318 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
319 dec_slice_params_t *ps_cur_slice = ps_view_ctxt->ps_cur_slice;
320 dec_pic_params_t *ps_cur_pps = ps_view_ctxt->ps_cur_pps;
321
322 i1_slice_qp_delta = ih264d_sev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
323 ps_cur_slice->u1_slice_qp = i1_slice_qp_delta + ps_cur_pps->u1_pic_init_qp;
324
325 if(ps_cur_slice->u1_slice_qp > MAX_H264_QP)
326 {
327 return ERROR_INV_RANGE_QP_T;
328 }
329
330 COPYTHECONTEXT("SH: slice_qp_delta", i1_slice_qp_delta);
331
332 return OK;
333 }
334
imvcd_set_slice_deblk_params(dec_struct_t * ps_view_ctxt)335 static WORD32 imvcd_set_slice_deblk_params(dec_struct_t *ps_view_ctxt)
336 {
337 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
338 dec_slice_params_t *ps_cur_slice = ps_view_ctxt->ps_cur_slice;
339 dec_pic_params_t *ps_cur_pps = ps_view_ctxt->ps_cur_pps;
340
341 if(ps_cur_pps->u1_deblocking_filter_parameters_present_flag)
342 {
343 ps_cur_slice->u1_disable_dblk_filter_idc =
344 ih264d_uev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer);
345
346 if(ps_cur_slice->u1_disable_dblk_filter_idc > SLICE_BOUNDARY_DBLK_DISABLED)
347 {
348 return ERROR_INV_SLICE_HDR_T;
349 }
350
351 COPYTHECONTEXT("SH: disable_deblocking_filter_idc",
352 ps_cur_slice->u1_disable_dblk_filter_idc);
353
354 if(ps_cur_slice->u1_disable_dblk_filter_idc != 1)
355 {
356 ps_cur_slice->i1_slice_alpha_c0_offset =
357 ih264d_sev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer) << 1;
358
359 if((MIN_DBLK_FIL_OFF > ps_cur_slice->i1_slice_alpha_c0_offset) ||
360 (ps_cur_slice->i1_slice_alpha_c0_offset > MAX_DBLK_FIL_OFF))
361 {
362 return ERROR_INV_SLICE_HDR_T;
363 }
364
365 COPYTHECONTEXT("SH: slice_alpha_c0_offset_div2",
366 ps_cur_slice->i1_slice_alpha_c0_offset >> 1);
367
368 ps_cur_slice->i1_slice_beta_offset =
369 ih264d_sev(&ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer) << 1;
370
371 if((MIN_DBLK_FIL_OFF > ps_cur_slice->i1_slice_beta_offset) ||
372 (ps_cur_slice->i1_slice_beta_offset > MAX_DBLK_FIL_OFF))
373 {
374 return ERROR_INV_SLICE_HDR_T;
375 }
376
377 COPYTHECONTEXT("SH: slice_beta_offset_div2", ps_cur_slice->i1_slice_beta_offset >> 1);
378 }
379 else
380 {
381 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
382 ps_cur_slice->i1_slice_beta_offset = 0;
383 }
384 }
385 else
386 {
387 ps_cur_slice->u1_disable_dblk_filter_idc = 0;
388 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
389 ps_cur_slice->i1_slice_beta_offset = 0;
390 }
391
392 return OK;
393 }
394
imvcd_set_ref_pic_list_mod_data(mvc_dec_ctxt_t * ps_mvcd_ctxt)395 static WORD32 imvcd_set_ref_pic_list_mod_data(mvc_dec_ctxt_t *ps_mvcd_ctxt)
396 {
397 WORD32 i4_error_code;
398 WORD32 i;
399
400 dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;
401 dec_slice_params_t *ps_cur_slice = ps_view_ctxt->ps_cur_slice;
402 ref_pic_list_mod_data_t *ps_ref_pic_list_mod_data =
403 imvcd_get_cur_ref_pic_list_mod_data(ps_mvcd_ctxt);
404
405 bool b_is_b_pic = ps_cur_slice->u1_slice_type == BSLICE;
406
407 for(i = 0; i < 1 + ((WORD32) b_is_b_pic); i++)
408 {
409 ps_ref_pic_list_mod_data->au1_num_active_refs[i] =
410 ps_cur_slice->u1_num_ref_idx_lx_active[i];
411
412 i4_error_code = imvcd_set_ref_pic_list_reordering_flag(
413 ps_view_ctxt, &ps_ref_pic_list_mod_data->au1_ref_pic_list_modification_flag_lx[i]);
414
415 if(OK != i4_error_code)
416 {
417 return i4_error_code;
418 }
419
420 if(ps_ref_pic_list_mod_data->au1_ref_pic_list_modification_flag_lx[i])
421 {
422 UWORD8 *pu1_modification_of_pic_nums_idc =
423 ps_ref_pic_list_mod_data->au1_modification_of_pic_nums_idc[i];
424 WORD32 *pi4_abs_diff_pic_num_minus1 =
425 ps_ref_pic_list_mod_data->ai4_abs_diff_pic_num_minus1[i];
426 WORD32 *pi4_long_term_pic_num = ps_ref_pic_list_mod_data->ai4_long_term_pic_num[i];
427 WORD32 *pi4_abs_diff_view_idx_minus1 =
428 ps_ref_pic_list_mod_data->ai4_abs_diff_view_idx_minus1[i];
429 UWORD32 u4_pic_num_mod_count = 0;
430
431 do
432 {
433 i4_error_code = imvcd_set_modification_of_pic_nums_idc(
434 ps_view_ctxt, pu1_modification_of_pic_nums_idc);
435
436 if(OK != i4_error_code)
437 {
438 return i4_error_code;
439 }
440
441 if((0 == pu1_modification_of_pic_nums_idc[0]) ||
442 (1 == pu1_modification_of_pic_nums_idc[0]))
443 {
444 i4_error_code = imvcd_set_abs_diff_pic_num_minus1(ps_view_ctxt,
445 pi4_abs_diff_pic_num_minus1);
446
447 if(OK != i4_error_code)
448 {
449 return i4_error_code;
450 }
451 }
452 else if(2 == pu1_modification_of_pic_nums_idc[0])
453 {
454 i4_error_code =
455 imvcd_set_long_term_pic_num(ps_view_ctxt, pi4_long_term_pic_num);
456
457 if(OK != i4_error_code)
458 {
459 return i4_error_code;
460 }
461 }
462 else if((4 == pu1_modification_of_pic_nums_idc[0]) ||
463 (5 == pu1_modification_of_pic_nums_idc[0]))
464 {
465 i4_error_code = imvcd_set_abs_diff_view_idx_minus1(
466 ps_view_ctxt, pi4_abs_diff_view_idx_minus1);
467
468 if(OK != i4_error_code)
469 {
470 return i4_error_code;
471 }
472 }
473 else if(3 != pu1_modification_of_pic_nums_idc[0])
474 {
475 return ERROR_REFIDX_ORDER_T;
476 }
477 else
478 {
479 break;
480 }
481
482 pu1_modification_of_pic_nums_idc++;
483 pi4_abs_diff_pic_num_minus1++;
484 pi4_long_term_pic_num++;
485 pi4_abs_diff_view_idx_minus1++;
486 u4_pic_num_mod_count++;
487
488 if(u4_pic_num_mod_count > ps_ref_pic_list_mod_data->au1_num_active_refs[i])
489 {
490 return ERROR_INV_SLICE_HDR_T;
491 }
492 } while(true);
493 }
494 }
495
496 return OK;
497 }
498
imvcd_decode_gaps_in_frame_num(mvc_dec_ctxt_t * ps_mvcd_ctxt)499 static WORD32 imvcd_decode_gaps_in_frame_num(mvc_dec_ctxt_t *ps_mvcd_ctxt)
500 {
501 pocstruct_t s_tmp_poc;
502
503 UWORD32 u4_start_frm_num;
504 WORD32 i4_poc;
505 WORD8 i1_gap_idx;
506 WORD8 *pi1_gaps_per_seq;
507 WORD32 i4_error_code;
508 WORD64 i8_display_poc;
509
510 dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;
511 dec_slice_params_t *ps_cur_slice = ps_view_ctxt->ps_cur_slice;
512 dec_pic_params_t *ps_pps = ps_view_ctxt->ps_cur_pps;
513 mvc_dpb_manager_t *ps_dpb_mgr = ps_mvcd_ctxt->ps_dpb_mgr;
514
515 UWORD16 u2_frame_num = ps_cur_slice->u2_frame_num;
516 UWORD32 u4_next_frm_num = ps_view_ctxt->u2_prev_ref_frame_num + 1;
517 UWORD32 u4_max_frm_num = ps_view_ctxt->ps_cur_sps->u2_u4_max_pic_num_minus1 + 1;
518 WORD32 *pi4_gaps_start_frm_num = ps_dpb_mgr->ai4_gaps_start_frm_num;
519 bool b_is_idr_slice = imvcd_is_idr_au(ps_mvcd_ctxt);
520
521 if(ps_cur_slice->u1_field_pic_flag)
522 {
523 if(ps_view_ctxt->u2_prev_ref_frame_num == u2_frame_num)
524 {
525 return OK;
526 }
527 }
528
529 if(u4_next_frm_num >= u4_max_frm_num)
530 {
531 u4_next_frm_num -= u4_max_frm_num;
532 }
533
534 if(u4_next_frm_num == u2_frame_num)
535 {
536 return OK;
537 }
538
539 if(b_is_idr_slice && (u4_next_frm_num >= u2_frame_num))
540 {
541 return OK;
542 }
543
544 u4_start_frm_num = u4_next_frm_num;
545
546 s_tmp_poc.i4_pic_order_cnt_lsb = 0;
547 s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0;
548 s_tmp_poc.i4_pic_order_cnt_lsb = 0;
549 s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0;
550 s_tmp_poc.i4_delta_pic_order_cnt[0] = 0;
551 s_tmp_poc.i4_delta_pic_order_cnt[1] = 0;
552
553 for(i1_gap_idx = 0; i1_gap_idx < MAX_FRAMES; i1_gap_idx++)
554 {
555 if(INVALID_FRAME_NUM == pi4_gaps_start_frm_num[i1_gap_idx])
556 {
557 break;
558 }
559 }
560
561 if(MAX_FRAMES == i1_gap_idx)
562 {
563 return ERROR_DBP_MANAGER_T;
564 }
565
566 i4_poc = 0;
567 pi4_gaps_start_frm_num[i1_gap_idx] = u4_start_frm_num;
568 ps_dpb_mgr->ai4_gaps_end_frm_num[i1_gap_idx] = u2_frame_num - 1;
569 pi1_gaps_per_seq = ps_dpb_mgr->ai1_gaps_per_seq;
570 pi1_gaps_per_seq[i1_gap_idx] = 0;
571
572 while(u4_next_frm_num != u2_frame_num)
573 {
574 imvcd_dpb_delete_nonref_nondisplay_pics(ps_dpb_mgr);
575
576 if(ps_pps->ps_sps->u1_pic_order_cnt_type)
577 {
578 /* allocate a picture buffer and insert it as ST node */
579 i4_error_code =
580 ih264d_decode_pic_order_cnt(0, u4_next_frm_num, &ps_view_ctxt->s_prev_pic_poc,
581 &s_tmp_poc, ps_cur_slice, ps_pps, 1, 0, 0, &i4_poc);
582
583 if(i4_error_code != OK)
584 {
585 return i4_error_code;
586 }
587
588 /* Display seq no calculations */
589 if(i4_poc >= ps_view_ctxt->i4_max_poc)
590 {
591 ps_view_ctxt->i4_max_poc = i4_poc;
592 }
593
594 /* IDR Picture or POC wrap around */
595 if(i4_poc == 0)
596 {
597 imvcd_modulate_max_disp_seq(ps_view_ctxt);
598 }
599
600 ps_cur_slice->u1_mmco_equalto5 = 0;
601 ps_cur_slice->u2_frame_num = u4_next_frm_num;
602 }
603
604 if(ps_dpb_mgr->i1_poc_buf_id_entries >= ps_view_ctxt->u1_max_dec_frame_buffering)
605 {
606 i4_error_code = imvcd_dpb_assign_display_seq(ps_mvcd_ctxt->ps_dpb_mgr);
607
608 if(i4_error_code != OK)
609 {
610 return i4_error_code;
611 }
612 }
613
614 i8_display_poc = ((WORD64) ps_view_ctxt->i4_prev_max_display_seq) + ((WORD64) i4_poc);
615
616 if(IS_OUT_OF_RANGE_S32(i8_display_poc))
617 {
618 ps_view_ctxt->i4_prev_max_display_seq = 0;
619 i8_display_poc = i4_poc;
620 }
621
622 i4_error_code = imvcd_dpb_insert_pic_in_display_list(ps_dpb_mgr, (WORD32) i8_display_poc,
623 u4_next_frm_num, DO_NOT_DISP);
624
625 if(i4_error_code != OK)
626 {
627 return i4_error_code;
628 }
629
630 pi1_gaps_per_seq[i1_gap_idx]++;
631
632 i4_error_code =
633 imvcd_dpb_do_mmco_for_gaps(ps_dpb_mgr, ps_view_ctxt->ps_cur_sps->u1_num_ref_frames);
634
635 if(i4_error_code != OK)
636 {
637 return i4_error_code;
638 }
639
640 imvcd_dpb_delete_nonref_nondisplay_pics(ps_dpb_mgr);
641
642 u4_next_frm_num++;
643
644 if(u4_next_frm_num >= u4_max_frm_num)
645 {
646 u4_next_frm_num -= u4_max_frm_num;
647 }
648 }
649
650 return OK;
651 }
652
imvcd_pocstruct_init(dec_struct_t * ps_view_ctxt)653 static void imvcd_pocstruct_init(dec_struct_t *ps_view_ctxt)
654 {
655 pocstruct_t *ps_prev_poc = &ps_view_ctxt->s_prev_pic_poc;
656 pocstruct_t *ps_cur_poc = &ps_view_ctxt->s_cur_pic_poc;
657
658 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst;
659 ps_prev_poc->u2_frame_num = ps_cur_poc->u2_frame_num;
660 ps_prev_poc->u1_mmco_equalto5 = ps_cur_poc->u1_mmco_equalto5;
661
662 if(ps_view_ctxt->ps_cur_slice->u1_nal_ref_idc)
663 {
664 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb;
665 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb;
666 ps_prev_poc->i4_delta_pic_order_cnt_bottom = ps_cur_poc->i4_delta_pic_order_cnt_bottom;
667 ps_prev_poc->i4_delta_pic_order_cnt[0] = ps_cur_poc->i4_delta_pic_order_cnt[0];
668 ps_prev_poc->i4_delta_pic_order_cnt[1] = ps_cur_poc->i4_delta_pic_order_cnt[1];
669 ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
670 }
671 }
672
imvcd_pic_init(mvc_dec_ctxt_t * ps_mvcd_ctxt,pocstruct_t * ps_cur_poc,WORD32 i4_poc,bool b_is_idr_slice)673 static WORD32 imvcd_pic_init(mvc_dec_ctxt_t *ps_mvcd_ctxt, pocstruct_t *ps_cur_poc, WORD32 i4_poc,
674 bool b_is_idr_slice)
675 {
676 WORD32 i4_error_code;
677 WORD32 i;
678
679 dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;
680 pocstruct_t *ps_prev_poc = &ps_view_ctxt->s_cur_pic_poc;
681 dec_slice_params_t *ps_cur_slice = ps_view_ctxt->ps_cur_slice;
682 dec_pic_params_t *ps_pps = ps_view_ctxt->ps_cur_pps;
683 dec_seq_params_t *ps_sps = ps_pps->ps_sps;
684 subset_sps_t *ps_subset_sps = imvcd_get_valid_subset_sps(ps_mvcd_ctxt);
685 nalu_mvc_ext_t *ps_nalu_mvc_ext = imvcd_get_cur_nalu_mvc_ext(ps_mvcd_ctxt);
686 dec_err_status_t *ps_err = ps_view_ctxt->ps_dec_err_status;
687 prev_seq_params_t *ps_prev_seq_params = &ps_view_ctxt->s_prev_seq_params;
688
689 UWORD16 u2_num_views = ps_mvcd_ctxt->u2_num_views;
690 UWORD16 u2_view_order_id = ps_mvcd_ctxt->u2_num_views_decoded;
691 UWORD16 u2_view_id = ps_nalu_mvc_ext->u2_view_id;
692 UWORD16 u2_frame_num = ps_cur_slice->u2_frame_num;
693
694 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb;
695 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb;
696 ps_prev_poc->i4_delta_pic_order_cnt_bottom = ps_cur_poc->i4_delta_pic_order_cnt_bottom;
697 ps_prev_poc->i4_delta_pic_order_cnt[0] = ps_cur_poc->i4_delta_pic_order_cnt[0];
698 ps_prev_poc->i4_delta_pic_order_cnt[1] = ps_cur_poc->i4_delta_pic_order_cnt[1];
699 ps_prev_poc->u1_bot_field = ps_view_ctxt->ps_cur_slice->u1_bottom_field_flag;
700 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst;
701 ps_prev_poc->u2_frame_num = u2_frame_num;
702
703 ps_view_ctxt->i1_prev_mb_qp_delta = 0;
704 ps_view_ctxt->i1_next_ctxt_idx = 0;
705 ps_view_ctxt->u4_use_intrapred_line_copy = 1;
706
707 if(ps_view_ctxt->u4_num_cores == 1)
708 {
709 ps_view_ctxt->u4_nmb_deblk = 1;
710 }
711 else
712 {
713 ps_view_ctxt->u4_nmb_deblk = 0;
714 }
715
716 ps_view_ctxt->u4_app_disable_deblk_frm = 0;
717 if(ps_view_ctxt->i4_degrade_type && ps_view_ctxt->i4_degrade_pics)
718 {
719 WORD32 i4_degrade_pic = 0;
720
721 ps_view_ctxt->i4_degrade_pic_cnt++;
722
723 /* If degrade is to be done in all frames, then do not check further */
724 switch(ps_view_ctxt->i4_degrade_pics)
725 {
726 case 4:
727 {
728 i4_degrade_pic = 1;
729
730 break;
731 }
732 case 3:
733 {
734 if(ps_cur_slice->u1_slice_type != I_SLICE)
735 {
736 i4_degrade_pic = 1;
737 }
738
739 break;
740 }
741 case 2:
742 {
743 if((ps_cur_slice->u1_slice_type != I_SLICE) &&
744 (ps_view_ctxt->i4_degrade_pic_cnt != ps_view_ctxt->i4_nondegrade_interval))
745 {
746 i4_degrade_pic = 1;
747 }
748
749 break;
750 }
751 case 1:
752 {
753 if(0 == ps_cur_slice->u1_nal_ref_idc)
754 {
755 i4_degrade_pic = 1;
756 }
757
758 break;
759 }
760 }
761
762 if(i4_degrade_pic)
763 {
764 if(ps_view_ctxt->i4_degrade_type & 0x2)
765 {
766 ps_view_ctxt->u4_app_disable_deblk_frm = 1;
767 }
768
769 if(0 == ps_cur_slice->u1_nal_ref_idc)
770 {
771 if(ps_view_ctxt->i4_degrade_type & 0x4)
772 {
773 ps_view_ctxt->i4_mv_frac_mask = 0;
774 }
775
776 if(ps_view_ctxt->i4_degrade_type & 0x8)
777 {
778 ps_view_ctxt->i4_mv_frac_mask = 0;
779 }
780 }
781 }
782 else
783 {
784 ps_view_ctxt->i4_degrade_pic_cnt = 0;
785 }
786 }
787
788 if((ps_cur_slice->u1_slice_type == I_SLICE) || (ps_cur_slice->u1_slice_type == SI_SLICE))
789 {
790 ps_err->u1_cur_pic_type = PIC_TYPE_I;
791 }
792 else
793 {
794 ps_err->u1_cur_pic_type = PIC_TYPE_UNKNOWN;
795 }
796
797 if(ps_err->u1_pic_aud_i == PIC_TYPE_I)
798 {
799 ps_err->u1_cur_pic_type = PIC_TYPE_I;
800 ps_err->u1_pic_aud_i = PIC_TYPE_UNKNOWN;
801 }
802
803 if(b_is_idr_slice)
804 {
805 if(ps_err->u1_err_flag)
806 {
807 imvcd_reset_dpb(ps_mvcd_ctxt->ps_dpb_mgr);
808 }
809
810 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
811 }
812
813 if(ps_view_ctxt->u1_init_dec_flag && ps_view_ctxt->s_prev_seq_params.u1_eoseq_pending &&
814 (u2_view_order_id == (u2_num_views - 1)))
815 {
816 imvcd_release_all_ref_and_io_bufs(ps_mvcd_ctxt, MAX_DISP_BUFS_NEW);
817
818 ps_view_ctxt->u1_second_field = 0;
819 ps_view_ctxt->i4_cur_display_seq = 0;
820 ps_view_ctxt->s_prev_seq_params.u1_eoseq_pending = 0;
821
822 imvcd_dpb_set_display_num(ps_mvcd_ctxt->ps_dpb_mgr, 0);
823 }
824
825 if(0 == u2_view_order_id)
826 {
827 imvcd_dpb_set_max_pic_num(ps_mvcd_ctxt->ps_dpb_mgr, ps_sps->u2_u4_max_pic_num_minus1 + 1);
828 imvcd_dpb_set_num_views(ps_mvcd_ctxt->ps_dpb_mgr, u2_num_views);
829 }
830
831 ps_view_ctxt->i4_pic_type = NA_SLICE;
832 ps_view_ctxt->i4_frametype = IV_NA_FRAME;
833 ps_view_ctxt->i4_content_type = IV_CONTENTTYPE_NA;
834
835 ps_sps->u2_max_mb_addr = ps_sps->u2_frm_wd_in_mbs * ps_sps->u2_frm_ht_in_mbs - 1;
836 ps_view_ctxt->u2_frm_ht_in_mbs = ps_sps->u2_frm_ht_in_mbs;
837
838 if(!ps_view_ctxt->u1_init_dec_flag)
839 {
840 ps_view_ctxt->u1_max_dec_frame_buffering = ih264d_get_dpb_size(ps_sps);
841
842 ps_view_ctxt->i4_display_delay = ps_view_ctxt->u1_max_dec_frame_buffering;
843
844 if(ps_sps->u1_vui_parameters_present_flag && ps_sps->s_vui.u1_bitstream_restriction_flag)
845 {
846 if(ps_sps->u1_frame_mbs_only_flag)
847 {
848 ps_view_ctxt->i4_display_delay = ps_sps->s_vui.u4_num_reorder_frames + 1;
849 }
850 else
851 {
852 ps_view_ctxt->i4_display_delay = ps_sps->s_vui.u4_num_reorder_frames * 2 + 2;
853 }
854 }
855
856 if(IVD_DECODE_FRAME_OUT == ps_view_ctxt->e_frm_out_mode)
857 {
858 ps_view_ctxt->i4_display_delay = 0;
859 }
860
861 imvcd_dpb_set_display_delay(ps_mvcd_ctxt->ps_dpb_mgr, ps_view_ctxt->i4_display_delay);
862
863 ps_view_ctxt->u1_pic_bufs = ps_view_ctxt->i4_display_delay + ps_sps->u1_num_ref_frames + 1;
864 ps_view_ctxt->u1_pic_bufs += imvcd_get_max_num_ivp_refs(ps_mvcd_ctxt);
865 ps_view_ctxt->u1_pic_bufs = CLIP3(2, MVC_MAX_REF_PICS, ps_view_ctxt->u1_pic_bufs);
866
867 ps_view_ctxt->u1_max_dec_frame_buffering =
868 MIN(ps_view_ctxt->u1_max_dec_frame_buffering, ps_view_ctxt->u1_pic_bufs);
869
870 /*********************************************************************/
871 /* Configuring decoder parameters based on level and then */
872 /* fresh pointer initialisation in decoder scratch and state buffers */
873 /*********************************************************************/
874 i4_error_code = ih264d_init_dec_mb_grp(ps_view_ctxt);
875
876 if(i4_error_code != OK)
877 {
878 return i4_error_code;
879 }
880
881 i4_error_code = imvcd_allocate_dynamic_bufs(ps_mvcd_ctxt);
882
883 if(i4_error_code != OK)
884 {
885 imvcd_free_dynamic_bufs(ps_mvcd_ctxt);
886
887 return IVD_MEM_ALLOC_FAILED;
888 }
889
890 i4_error_code = imvcd_init_au_buffers(ps_mvcd_ctxt);
891
892 if(i4_error_code != OK)
893 {
894 return i4_error_code;
895 }
896
897 i4_error_code = imvcd_init_au_mv_pred_bufs(ps_mvcd_ctxt);
898
899 if(i4_error_code != OK)
900 {
901 return i4_error_code;
902 }
903
904 ps_view_ctxt->u1_init_dec_flag = 1;
905 ps_prev_seq_params->u2_frm_wd_in_mbs = ps_sps->u2_frm_wd_in_mbs;
906 ps_prev_seq_params->u1_level_idc = ps_sps->u1_level_idc;
907 ps_prev_seq_params->u1_profile_idc = ps_sps->u1_profile_idc;
908 ps_prev_seq_params->u2_frm_ht_in_mbs = ps_sps->u2_frm_ht_in_mbs;
909 ps_prev_seq_params->u1_frame_mbs_only_flag = ps_sps->u1_frame_mbs_only_flag;
910 ps_prev_seq_params->u1_direct_8x8_inference_flag = ps_sps->u1_direct_8x8_inference_flag;
911
912 ps_view_ctxt->i4_cur_display_seq = 0;
913 ps_view_ctxt->i4_prev_max_display_seq = 0;
914 ps_view_ctxt->i4_max_poc = 0;
915
916 imvcd_dpb_set_display_num(ps_mvcd_ctxt->ps_dpb_mgr, 0);
917
918 {
919 /* 0th entry of CtxtIncMbMap will be always be containing default values
920 for CABAC context representing MB not available */
921 ctxt_inc_mb_info_t *p_DefCtxt = ps_view_ctxt->p_ctxt_inc_mb_map - 1;
922 UWORD8 *pu1_temp;
923
924 p_DefCtxt->u1_mb_type = CAB_SKIP;
925
926 p_DefCtxt->u1_cbp = 0x0f;
927 p_DefCtxt->u1_intra_chroma_pred_mode = 0;
928
929 p_DefCtxt->u1_yuv_dc_csbp = 0x7;
930
931 p_DefCtxt->u1_transform8x8_ctxt = 0;
932
933 pu1_temp = (UWORD8 *) p_DefCtxt->i1_ref_idx;
934 for(i = 0; i < 4; i++, pu1_temp++)
935 {
936 (*pu1_temp) = 0;
937 }
938
939 pu1_temp = (UWORD8 *) p_DefCtxt->u1_mv;
940 for(i = 0; i < 16; i++, pu1_temp++)
941 {
942 (*pu1_temp) = 0;
943 }
944
945 ps_view_ctxt->ps_def_ctxt_mb_info = p_DefCtxt;
946 }
947 }
948
949 /* reset DBP commands read u4_flag */
950 ps_view_ctxt->ps_dpb_cmds->u1_dpb_commands_read = 0;
951
952 ps_view_ctxt->pv_parse_tu_coeff_data = ps_view_ctxt->pv_pic_tu_coeff_data;
953 ps_view_ctxt->pv_proc_tu_coeff_data = ps_view_ctxt->pv_pic_tu_coeff_data;
954 ps_view_ctxt->ps_nmb_info = ps_view_ctxt->ps_frm_mb_info;
955
956 if(ps_view_ctxt->u1_separate_parse)
957 {
958 UWORD32 num_mbs;
959
960 num_mbs = ps_view_ctxt->ps_cur_sps->u2_total_num_of_mbs;
961
962 if(ps_view_ctxt->pu1_dec_mb_map)
963 {
964 memset((void *) ps_view_ctxt->pu1_dec_mb_map, 0, num_mbs);
965 }
966
967 if(ps_view_ctxt->pu1_recon_mb_map)
968 {
969 memset((void *) ps_view_ctxt->pu1_recon_mb_map, 0, num_mbs);
970 }
971
972 if(ps_view_ctxt->pu2_slice_num_map)
973 {
974 memset((void *) ps_view_ctxt->pu2_slice_num_map, 0, (num_mbs * sizeof(UWORD16)));
975 }
976 }
977
978 ps_view_ctxt->ps_parse_cur_slice = &(ps_view_ctxt->ps_dec_slice_buf[0]);
979 ps_view_ctxt->ps_decode_cur_slice = &(ps_view_ctxt->ps_dec_slice_buf[0]);
980 ps_view_ctxt->ps_computebs_cur_slice = &(ps_view_ctxt->ps_dec_slice_buf[0]);
981 ps_view_ctxt->u2_cur_slice_num = 0;
982
983 ps_view_ctxt->s_high_profile.u1_scaling_present = 0;
984 ps_view_ctxt->s_high_profile.u1_transform8x8_present = 0;
985
986 if(0 == u2_view_order_id)
987 {
988 mvc_au_buffer_t *ps_cur_au;
989 mvc_au_mv_pred_t *ps_au_mv_data;
990
991 WORD32 i4_pic_buf_id, i4_mv_buf_id;
992
993 ps_cur_au = (mvc_au_buffer_t *) ih264_buf_mgr_get_next_free(
994 ps_mvcd_ctxt->s_mvc_au_buf_mgr.ps_buf_mgr_ctxt, &i4_pic_buf_id);
995
996 if(NULL == ps_cur_au)
997 {
998 return ERROR_UNAVAIL_PICBUF_T;
999 }
1000 else
1001 {
1002 /* Buf will alwys be marked as REF here to ensure IVP works */
1003 /* If AU nalRefIdc=0, REF status will be removed during endOfAU processing
1004 */
1005 ih264_buf_mgr_set_status(ps_mvcd_ctxt->s_mvc_au_buf_mgr.ps_buf_mgr_ctxt, i4_pic_buf_id,
1006 BUF_MGR_IO | BUF_MGR_REF);
1007 }
1008
1009 ps_au_mv_data = (mvc_au_mv_pred_t *) ih264_buf_mgr_get_next_free(
1010 ps_mvcd_ctxt->s_mvc_au_mv_pred_buf_mgr.ps_buf_mgr_ctxt, &i4_mv_buf_id);
1011
1012 if(ps_au_mv_data == NULL)
1013 {
1014 return ERROR_UNAVAIL_MVBUF_T;
1015 }
1016 else
1017 {
1018 /* Buf will alwys be marked as REF here to ensure IVP works */
1019 /* If AU nalRefIdc=0, REF status will be removed during endOfAU processing
1020 */
1021 ih264_buf_mgr_set_status(ps_mvcd_ctxt->s_mvc_au_mv_pred_buf_mgr.ps_buf_mgr_ctxt,
1022 i4_mv_buf_id, BUF_MGR_REF);
1023 }
1024
1025 ps_mvcd_ctxt->ps_cur_au = ps_cur_au;
1026
1027 ps_cur_au->s_sei_pic = ps_view_ctxt->ps_sei[0];
1028
1029 ps_cur_au->i4_mv_buf_id = i4_mv_buf_id;
1030 ps_cur_au->ps_au_mv_data = ps_au_mv_data;
1031 ps_cur_au->i4_poc = i4_poc;
1032 ps_cur_au->i4_avg_poc = i4_poc;
1033 ps_cur_au->i4_frame_num = u2_frame_num;
1034 ps_cur_au->i4_pic_num = u2_frame_num;
1035 ps_cur_au->u4_time_stamp = ps_view_ctxt->u4_ts;
1036 ps_cur_au->u1_picturetype = FRM_PIC;
1037 ps_cur_au->u2_disp_width = ps_view_ctxt->u2_disp_width;
1038 ps_cur_au->u2_disp_height = ps_view_ctxt->u2_disp_height;
1039
1040 memset(ps_cur_au->au4_pack_slc_typ, 0, sizeof(ps_cur_au->au4_pack_slc_typ));
1041
1042 ps_mvcd_ctxt->s_mvc_au_buf_mgr.au1_au_buf_id_to_mv_buf_id_map[i4_pic_buf_id] = i4_mv_buf_id;
1043 ps_mvcd_ctxt->s_mvc_au_buf_mgr.aps_buf_id_to_au_buf_map[i4_pic_buf_id] = ps_cur_au;
1044 ps_mvcd_ctxt->s_mvc_au_mv_pred_buf_mgr.aps_buf_id_to_mv_pred_buf_map[i4_mv_buf_id] =
1045 ps_au_mv_data;
1046
1047 ps_view_ctxt->au1_pic_buf_ref_flag[i4_pic_buf_id] = 0;
1048
1049 ps_cur_au->s_ivp_data.b_is_ivp_ref = false;
1050
1051 imvcd_dpb_init_au_bufs(ps_mvcd_ctxt->ps_dpb_mgr, ps_cur_au);
1052 }
1053
1054 if(u2_view_order_id > 0)
1055 {
1056 ps_mvcd_ctxt->ps_cur_au->as_disp_offsets[u2_view_id] =
1057 ps_mvcd_ctxt->aps_pps_id_to_subset_sps_map[ps_pps->u1_pic_parameter_set_id]
1058 ->s_disp_offsets;
1059 }
1060 else
1061 {
1062 /* Accounting for lihbavc's idiocy */
1063 ps_mvcd_ctxt->ps_cur_au->as_disp_offsets[u2_view_id].u2_left_offset =
1064 ps_view_ctxt->u2_crop_offset_y;
1065 ps_mvcd_ctxt->ps_cur_au->as_disp_offsets[u2_view_id].u2_right_offset = 0;
1066 ps_mvcd_ctxt->ps_cur_au->as_disp_offsets[u2_view_id].u2_top_offset = 0;
1067 ps_mvcd_ctxt->ps_cur_au->as_disp_offsets[u2_view_id].u2_bottom_offset = 0;
1068 }
1069
1070 for(i = 0; i < 2; i++)
1071 {
1072 ps_view_ctxt->ps_ref_pic_buf_lx[i] = imvcd_dpb_get_view_ref_pic_list(
1073 ps_mvcd_ctxt->ps_dpb_mgr, u2_view_order_id, u2_view_id, i);
1074
1075 imvcd_set_view_buf_id_to_buf_map(ps_view_ctxt);
1076 }
1077
1078 if(ps_mvcd_ctxt->u2_num_views > 1)
1079 {
1080 imvcd_dpb_init_view_bufs(ps_mvcd_ctxt->ps_dpb_mgr, u2_view_order_id, u2_view_id);
1081
1082 imvcd_dpb_init_ivp_ctxt(ps_mvcd_ctxt->ps_dpb_mgr, &ps_subset_sps->s_sps_mvc_ext,
1083 ps_mvcd_ctxt->as_nalu_mvc_ext);
1084 }
1085
1086 ps_view_ctxt->u4_pic_buf_got = 1;
1087 ps_cur_slice->u1_mbaff_frame_flag = 0;
1088
1089 ps_view_ctxt->ps_cur_mb_row = ps_view_ctxt->ps_nbr_mb_row;
1090 // Increment by 2 ,so that left mb (mbaff decrements by 2) will always be
1091 // valid
1092 ps_view_ctxt->ps_cur_mb_row += 2;
1093 ps_view_ctxt->ps_top_mb_row = ps_view_ctxt->ps_nbr_mb_row;
1094 ps_view_ctxt->ps_top_mb_row += ps_view_ctxt->u2_frm_wd_in_mbs + 2;
1095 // Increment by 2 ,so that left mb (mbaff decrements by 2) will always be
1096 // valid
1097 ps_view_ctxt->ps_top_mb_row += 2;
1098 ps_view_ctxt->u1_mb_idx = 0;
1099 ps_view_ctxt->u2_total_mbs_coded = 0;
1100 ps_view_ctxt->i4_submb_ofst = -(SUB_BLK_SIZE);
1101 ps_view_ctxt->i2_prev_slice_mbx = -1;
1102 ps_view_ctxt->i2_prev_slice_mby = 0;
1103
1104 ps_view_ctxt->u4_pred_info_idx = 0;
1105 ps_view_ctxt->u4_pred_info_pkd_idx = 0;
1106 ps_view_ctxt->ps_part = ps_view_ctxt->ps_parse_part_params;
1107
1108 ps_view_ctxt->u4_dma_buf_idx = 0;
1109
1110 ps_view_ctxt->ps_mv_cur = ps_mvcd_ctxt->ps_cur_au->ps_au_mv_data->aps_mvs[u2_view_id];
1111 ps_view_ctxt->ps_mv_top = ps_view_ctxt->ps_mv_top_p[0];
1112 ps_view_ctxt->u1_mv_top_p = 0;
1113 ps_view_ctxt->ps_mv_left = ps_mvcd_ctxt->ps_cur_au->ps_au_mv_data->aps_mvs[u2_view_id];
1114 ps_view_ctxt->ps_mv = ps_mvcd_ctxt->ps_cur_au->ps_au_mv_data->aps_mvs[u2_view_id];
1115 ps_view_ctxt->ps_mv_bank_cur = ps_mvcd_ctxt->ps_cur_au->ps_au_mv_data->aps_mvs[u2_view_id];
1116 ps_view_ctxt->pu1_col_zero_flag =
1117 ps_mvcd_ctxt->ps_cur_au->ps_au_mv_data->apu1_mode_descriptors[u2_view_id];
1118 ps_view_ctxt->u2_mv_2mb[0] = 0;
1119 ps_view_ctxt->u2_mv_2mb[1] = 0;
1120
1121 ps_view_ctxt->u1_last_pic_not_decoded = 0;
1122 ps_view_ctxt->u2_cur_slice_num_dec_thread = 0;
1123 ps_view_ctxt->u2_cur_slice_num_bs = 0;
1124
1125 ps_view_ctxt->u4_intra_pred_line_ofst = 0;
1126 ps_view_ctxt->pu1_cur_y_intra_pred_line = ps_view_ctxt->pu1_y_intra_pred_line;
1127 ps_view_ctxt->pu1_cur_u_intra_pred_line = ps_view_ctxt->pu1_u_intra_pred_line;
1128 ps_view_ctxt->pu1_cur_v_intra_pred_line = ps_view_ctxt->pu1_v_intra_pred_line;
1129 ps_view_ctxt->pu1_cur_y_intra_pred_line_base = ps_view_ctxt->pu1_y_intra_pred_line;
1130 ps_view_ctxt->pu1_cur_u_intra_pred_line_base = ps_view_ctxt->pu1_u_intra_pred_line;
1131 ps_view_ctxt->pu1_cur_v_intra_pred_line_base = ps_view_ctxt->pu1_v_intra_pred_line;
1132 ps_view_ctxt->pu1_prev_y_intra_pred_line =
1133 ps_view_ctxt->pu1_y_intra_pred_line + (ps_view_ctxt->u2_frm_wd_in_mbs * MB_SIZE);
1134 ps_view_ctxt->pu1_prev_u_intra_pred_line =
1135 ps_view_ctxt->pu1_u_intra_pred_line +
1136 ps_view_ctxt->u2_frm_wd_in_mbs * BLK8x8SIZE * YUV420SP_FACTOR;
1137 ps_view_ctxt->pu1_prev_v_intra_pred_line =
1138 ps_view_ctxt->pu1_v_intra_pred_line + ps_view_ctxt->u2_frm_wd_in_mbs * BLK8x8SIZE;
1139
1140 ps_view_ctxt->ps_deblk_mbn = ps_view_ctxt->ps_deblk_pic;
1141
1142 ps_view_ctxt->pf_compute_bs = ih264d_compute_bs_non_mbaff;
1143 ps_view_ctxt->u1_cur_mb_fld_dec_flag = ps_cur_slice->u1_field_pic_flag;
1144
1145 if(0 == u2_view_order_id)
1146 {
1147 imvcd_assign_pic_num(ps_mvcd_ctxt->ps_dpb_mgr, ps_sps->u2_u4_max_pic_num_minus1 + 1,
1148 ps_mvcd_ctxt->ps_cur_au->i4_frame_num,
1149 ps_sps->u1_gaps_in_frame_num_value_allowed_flag);
1150
1151 ps_view_ctxt->s_tran_addrecon.u2_mv_top_left_inc = (ps_view_ctxt->u1_recon_mb_grp << 2) - 1;
1152 ps_view_ctxt->s_tran_addrecon.u2_mv_left_inc = (ps_view_ctxt->u1_recon_mb_grp - 1) << 4;
1153 }
1154
1155 if((ps_sps->u1_profile_idc == HIGH_PROFILE_IDC) ||
1156 (ps_sps->u1_profile_idc == MULTIVIEW_HIGH_PROFILE_IDC))
1157 {
1158 if((ps_sps->i4_seq_scaling_matrix_present_flag) ||
1159 (ps_pps->i4_pic_scaling_matrix_present_flag))
1160 {
1161 i4_error_code = ih264d_form_scaling_matrix_picture(ps_sps, ps_pps, ps_view_ctxt);
1162 ps_view_ctxt->s_high_profile.u1_scaling_present = 1;
1163 }
1164 else
1165 {
1166 i4_error_code = ih264d_form_default_scaling_matrix(ps_view_ctxt);
1167 }
1168
1169 if(ps_pps->i4_transform_8x8_mode_flag)
1170 {
1171 ps_view_ctxt->s_high_profile.u1_transform8x8_present = 1;
1172 }
1173 }
1174 else
1175 {
1176 i4_error_code = ih264d_form_default_scaling_matrix(ps_view_ctxt);
1177 }
1178
1179 if(i4_error_code != OK)
1180 {
1181 return i4_error_code;
1182 }
1183
1184 ps_view_ctxt->s_high_profile.u1_direct_8x8_inference_flag =
1185 ps_sps->u1_direct_8x8_inference_flag;
1186 ps_view_ctxt->s_high_profile.s_cavlc_ctxt = ps_view_ctxt->s_cavlc_ctxt;
1187
1188 ps_view_ctxt->i1_recon_in_thread3_flag = 1;
1189
1190 ps_view_ctxt->ps_cur_pic = &ps_view_ctxt->s_cur_pic;
1191 imvcd_convert_au_buf_to_view_buf(ps_mvcd_ctxt->ps_cur_au, &ps_view_ctxt->s_cur_pic,
1192 u2_view_order_id, u2_view_id);
1193
1194 ih264d_init_deblk_tfr_ctxt(ps_view_ctxt, &ps_view_ctxt->s_pad_mgr,
1195 &ps_view_ctxt->s_tran_addrecon, ps_view_ctxt->u2_frm_wd_in_mbs, 0);
1196
1197 ps_view_ctxt->ps_frame_buf_ip_recon = &ps_view_ctxt->s_tran_addrecon;
1198
1199 if(ps_view_ctxt->u1_separate_parse)
1200 {
1201 ps_view_ctxt->s_tran_addrecon_parse = ps_view_ctxt->s_tran_addrecon;
1202
1203 if((ps_view_ctxt->u4_num_cores >= 3) && ps_view_ctxt->i1_recon_in_thread3_flag)
1204 {
1205 ps_view_ctxt->s_tran_iprecon = ps_view_ctxt->s_tran_addrecon;
1206 ps_view_ctxt->ps_frame_buf_ip_recon = &ps_view_ctxt->s_tran_iprecon;
1207 }
1208 }
1209
1210 ps_view_ctxt->ps_cur_deblk_mb = ps_view_ctxt->ps_deblk_pic;
1211 ps_view_ctxt->u4_cur_deblk_mb_num = 0;
1212
1213 ps_view_ctxt->u4_deblk_mb_x = 0;
1214 ps_view_ctxt->u4_deblk_mb_y = 0;
1215 ps_view_ctxt->pu4_wt_ofsts = ps_view_ctxt->pu4_wts_ofsts_mat;
1216
1217 ps_view_ctxt->u4_first_slice_in_pic = 0;
1218
1219 return OK;
1220 }
1221
imvcd_corrupted_slice_handler(mvc_dec_ctxt_t * ps_mvcd_ctxt)1222 static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
1223 {
1224 dec_mb_info_t *ps_cur_mb_info;
1225 parse_pmbarams_t *ps_parse_mb_data;
1226 deblk_mb_t *ps_cur_deblk_mb;
1227 parse_part_params_t *ps_part_info;
1228
1229 UWORD32 u4_num_mbs_next;
1230 bool b_is_end_of_row;
1231 bool b_is_slice_end;
1232 bool b_tfr_n_mb;
1233 bool b_decode_nmb;
1234 UWORD8 u1_inter_mb_type;
1235 UWORD8 u1_deblk_mb_type;
1236 UWORD16 i2_cur_mb_addr;
1237 UWORD32 u4_mb_skip_run;
1238 WORD32 i, j;
1239
1240 dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;
1241 dec_slice_params_t *ps_slice = ps_view_ctxt->ps_cur_slice;
1242 nalu_mvc_ext_t *ps_cur_nalu_mvc_ext = imvcd_get_cur_nalu_mvc_ext(ps_mvcd_ctxt);
1243
1244 UWORD32 u4_num_mbs = 0;
1245 UWORD32 u4_mb_idx = ps_view_ctxt->u1_mb_idx;
1246 UWORD32 u4_remaining_mbs =
1247 (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1) - ps_view_ctxt->u2_total_mbs_coded;
1248
1249 if(ps_view_ctxt->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
1250 {
1251 imvcd_free_ref_and_io_bufs(&ps_mvcd_ctxt->s_mvc_au_buf_mgr,
1252 &ps_mvcd_ctxt->s_mvc_au_mv_pred_buf_mgr,
1253 ps_mvcd_ctxt->ps_cur_au->i4_pic_buf_id);
1254
1255 return OK;
1256 }
1257
1258 if((ISLICE == ps_slice->u1_slice_type) || (0 == ps_view_ctxt->u2_total_mbs_coded))
1259 {
1260 yuv_buf_props_t *ps_view_buf =
1261 &ps_mvcd_ctxt->ps_cur_au->as_view_buffers[ps_cur_nalu_mvc_ext->u2_view_id];
1262
1263 for(i = 0; i < NUM_SP_COMPONENTS; i++)
1264 {
1265 buffer_container_t *ps_component_buf = &ps_view_buf->as_component_bufs[i];
1266
1267 bool b_is_chroma = ((COMPONENT_TYPES_T) i) != Y;
1268 UWORD16 u2_height = ps_view_buf->u2_height >> b_is_chroma;
1269 UWORD16 u2_width = ps_view_buf->u2_width;
1270
1271 for(j = 0; j < u2_height; j++)
1272 {
1273 UWORD8 *pu1_data =
1274 ((UWORD8 *) ps_component_buf->pv_data) + j * ps_component_buf->i4_data_stride;
1275
1276 memset(pu1_data, 128, u2_width * sizeof(pu1_data[0]));
1277 }
1278 }
1279
1280 memset(ps_view_ctxt->apv_buf_id_pic_buf_map, 0,
1281 sizeof(ps_view_ctxt->apv_buf_id_pic_buf_map));
1282
1283 ps_view_ctxt->apv_buf_id_pic_buf_map[ps_mvcd_ctxt->ps_cur_au->i4_pic_buf_id] =
1284 &ps_view_ctxt->s_cur_pic;
1285 ps_view_ctxt->ps_ref_pic_buf_lx[0] = &ps_view_ctxt->ps_cur_pic;
1286 (ps_view_ctxt->ppv_map_ref_idx_to_poc + FRM_LIST_L0)[0] =
1287 ps_view_ctxt->ps_cur_pic->pu1_buf1;
1288 (ps_view_ctxt->ppv_map_ref_idx_to_poc + FRM_LIST_L1)[0] = NULL;
1289 }
1290
1291 ps_view_ctxt->ps_dpb_cmds->u1_long_term_reference_flag = 0;
1292
1293 if(ps_view_ctxt->u2_total_mbs_coded > 0)
1294 {
1295 ps_view_ctxt->u2_total_mbs_coded -=
1296 ps_view_ctxt->u2_total_mbs_coded % ps_view_ctxt->ps_cur_sps->u2_frm_wd_in_mbs;
1297 u4_remaining_mbs =
1298 (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1) - ps_view_ctxt->u2_total_mbs_coded;
1299
1300 while(ps_view_ctxt->u4_dec_thread_created &&
1301 (ps_view_ctxt->cur_dec_mb_num < ps_view_ctxt->u2_total_mbs_coded))
1302 {
1303 NOP(1 << 10);
1304 }
1305
1306 while(ps_view_ctxt->u4_bs_deblk_thread_created &&
1307 (ps_view_ctxt->cur_recon_mb_num < ps_view_ctxt->u2_total_mbs_coded))
1308 {
1309 NOP(1 << 10);
1310 }
1311
1312 while(ps_view_ctxt->u4_bs_deblk_thread_created &&
1313 (ps_view_ctxt->u4_cur_deblk_mb_num < ps_view_ctxt->u2_total_mbs_coded))
1314 {
1315 NOP(1 << 10);
1316 }
1317
1318 ps_view_ctxt->ps_nmb_info = ps_view_ctxt->ps_frm_mb_info + ps_view_ctxt->u2_total_mbs_coded;
1319 ps_view_ctxt->ps_deblk_mbn = ps_view_ctxt->ps_cur_deblk_mb =
1320 ps_view_ctxt->ps_deblk_pic + ps_view_ctxt->u2_total_mbs_coded;
1321 }
1322
1323 u4_num_mbs = ps_view_ctxt->u4_num_mbs_cur_nmb = 0;
1324
1325 if(ps_view_ctxt->u1_separate_parse)
1326 {
1327 ps_cur_mb_info = ps_view_ctxt->ps_nmb_info;
1328 }
1329 else
1330 {
1331 ps_cur_mb_info = ps_view_ctxt->ps_nmb_info + ps_view_ctxt->u4_num_mbs_prev_nmb - 1;
1332 }
1333
1334 ps_view_ctxt->u2_mby = ps_cur_mb_info->u2_mby;
1335 ps_view_ctxt->u2_mbx = ps_cur_mb_info->u2_mbx;
1336
1337 ps_view_ctxt->u1_mb_ngbr_availablity = ps_cur_mb_info->u1_mb_ngbr_availablity;
1338
1339 if(ps_view_ctxt->u2_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1))
1340 {
1341 ps_view_ctxt->u1_pic_decode_done = 1;
1342
1343 return OK;
1344 }
1345
1346 /******************************************************/
1347 /* Initializations to new slice */
1348 /******************************************************/
1349 ps_view_ctxt->ps_parse_cur_slice->ppv_map_ref_idx_to_poc =
1350 (volatile void **) ps_view_ctxt->pv_map_ref_idx_to_poc_buf;
1351 ps_slice->i1_slice_alpha_c0_offset = 0;
1352 ps_slice->i1_slice_beta_offset = 0;
1353 ps_slice->u2_first_mb_in_slice = ps_view_ctxt->u2_total_mbs_coded;
1354 ps_view_ctxt->ps_parse_cur_slice->u4_first_mb_in_slice = ps_view_ctxt->u2_total_mbs_coded;
1355 ps_view_ctxt->ps_parse_cur_slice->u2_log2Y_crwd = ps_slice->u2_log2Y_crwd;
1356
1357 if(ps_view_ctxt->u1_separate_parse)
1358 {
1359 ps_view_ctxt->ps_parse_cur_slice->pv_tu_coeff_data_start =
1360 ps_view_ctxt->pv_parse_tu_coeff_data;
1361 }
1362 else
1363 {
1364 ps_view_ctxt->pv_proc_tu_coeff_data = ps_view_ctxt->pv_parse_tu_coeff_data;
1365 }
1366
1367 /******************************************************/
1368 /* Initializations specific to P slice */
1369 /******************************************************/
1370 u1_inter_mb_type = P_MB;
1371 u1_deblk_mb_type = D_INTER_MB;
1372
1373 ps_slice->u1_slice_type = P_SLICE;
1374 ps_view_ctxt->ps_parse_cur_slice->slice_type = P_SLICE;
1375 ps_view_ctxt->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
1376 ps_view_ctxt->ps_part = ps_view_ctxt->ps_parse_part_params;
1377 ps_view_ctxt->u2_mbx =
1378 MOD(ps_view_ctxt->u2_total_mbs_coded - 1, ps_view_ctxt->u2_frm_wd_in_mbs);
1379 ps_view_ctxt->u2_mby =
1380 DIV(ps_view_ctxt->u2_total_mbs_coded - 1, ps_view_ctxt->u2_frm_wd_in_mbs);
1381
1382 /******************************************************/
1383 /* Parsing / decoding the slice */
1384 /******************************************************/
1385 ps_view_ctxt->u1_qp = ps_slice->u1_slice_qp;
1386 ih264d_update_qp(ps_view_ctxt, 0);
1387 u4_mb_idx = ps_view_ctxt->u1_mb_idx;
1388 ps_parse_mb_data = ps_view_ctxt->ps_parse_mb_data;
1389 u4_num_mbs = u4_mb_idx;
1390
1391 b_is_slice_end = false;
1392 b_tfr_n_mb = false;
1393 b_decode_nmb = false;
1394 i2_cur_mb_addr = ps_view_ctxt->u2_total_mbs_coded;
1395 u4_mb_skip_run = u4_remaining_mbs;
1396
1397 while(!b_is_slice_end)
1398 {
1399 if(i2_cur_mb_addr > ps_view_ctxt->ps_cur_sps->u2_max_mb_addr)
1400 {
1401 break;
1402 }
1403
1404 ps_cur_mb_info = ps_view_ctxt->ps_nmb_info + u4_num_mbs;
1405 ps_view_ctxt->u4_num_mbs_cur_nmb = u4_num_mbs;
1406
1407 ps_cur_mb_info->u1_Mux = 0;
1408 ps_cur_mb_info->u1_end_of_slice = 0;
1409
1410 ps_view_ctxt->u4_num_pmbair = u4_num_mbs;
1411 ps_cur_deblk_mb = ps_view_ctxt->ps_deblk_mbn + u4_num_mbs;
1412
1413 ps_parse_mb_data->u1_num_part = 1;
1414 ps_parse_mb_data->u1_isI_mb = 0;
1415
1416 /**************************************************************/
1417 /* Get the required information for decoding of MB */
1418 /**************************************************************/
1419 /* mb_x, mb_y, neighbor availablity, */
1420 ih264d_get_mb_info_cavlc_nonmbaff(ps_view_ctxt, i2_cur_mb_addr, ps_cur_mb_info,
1421 u4_mb_skip_run);
1422
1423 if(ps_view_ctxt->u4_app_disable_deblk_frm == 0)
1424 {
1425 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
1426 ps_view_ctxt->u1_mb_ngbr_availablity,
1427 ps_view_ctxt->u1_cur_mb_fld_dec_flag);
1428 }
1429
1430 ps_view_ctxt->i1_prev_mb_qp_delta = 0;
1431 ps_view_ctxt->u1_sub_mb_num = 0;
1432 ps_cur_mb_info->u1_mb_type = MB_SKIP;
1433 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
1434 ps_cur_mb_info->u1_cbp = 0;
1435
1436 /* Storing Skip partition info */
1437 ps_part_info = ps_view_ctxt->ps_part;
1438 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
1439 ps_part_info->u1_sub_mb_num = 0;
1440 ps_view_ctxt->ps_part++;
1441
1442 /* Update Nnzs */
1443 ih264d_update_nnz_for_skipmb(ps_view_ctxt, ps_cur_mb_info, CAVLC);
1444
1445 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1446 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1447
1448 u4_mb_skip_run--;
1449
1450 ps_cur_deblk_mb->u1_mb_qp = ps_view_ctxt->u1_qp;
1451 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
1452
1453 i2_cur_mb_addr++;
1454 u4_num_mbs++;
1455 ps_parse_mb_data++;
1456
1457 /****************************************************************/
1458 /* Check for End Of Row and other flags that determine when to */
1459 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1460 /* N-Mb */
1461 /****************************************************************/
1462 u4_num_mbs_next = ps_view_ctxt->ps_cur_sps->u2_frm_wd_in_mbs - 1 - ps_view_ctxt->u2_mbx;
1463 b_is_end_of_row = (0 == u4_num_mbs_next);
1464 b_is_slice_end = !u4_mb_skip_run;
1465 ps_cur_mb_info->u1_end_of_slice = !u4_mb_skip_run;
1466 b_tfr_n_mb =
1467 (u4_num_mbs == ps_view_ctxt->u1_recon_mb_grp) || b_is_end_of_row || b_is_slice_end;
1468 b_decode_nmb = b_tfr_n_mb || b_is_slice_end;
1469
1470 if(b_decode_nmb)
1471 {
1472 ps_view_ctxt->pf_mvpred_ref_tfr_nby2mb(ps_view_ctxt, u4_mb_idx, u4_num_mbs);
1473
1474 ps_parse_mb_data = ps_view_ctxt->ps_parse_mb_data;
1475 ps_view_ctxt->ps_part = ps_view_ctxt->ps_parse_part_params;
1476
1477 if(ps_view_ctxt->u1_separate_parse)
1478 {
1479 ih264d_parse_tfr_nmb(ps_view_ctxt, u4_mb_idx, u4_num_mbs, u4_num_mbs_next,
1480 b_tfr_n_mb, b_is_end_of_row);
1481
1482 ps_view_ctxt->ps_nmb_info += u4_num_mbs;
1483 }
1484 else
1485 {
1486 ih264d_decode_recon_tfr_nmb(ps_view_ctxt, u4_mb_idx, u4_num_mbs, u4_num_mbs_next,
1487 b_tfr_n_mb, b_is_end_of_row);
1488 }
1489
1490 ps_view_ctxt->u2_total_mbs_coded += u4_num_mbs;
1491
1492 if(b_tfr_n_mb)
1493 {
1494 u4_num_mbs = 0;
1495 }
1496
1497 u4_mb_idx = u4_num_mbs;
1498 ps_view_ctxt->u1_mb_idx = u4_num_mbs;
1499 }
1500 }
1501
1502 ps_view_ctxt->u4_num_mbs_cur_nmb = 0;
1503 ps_view_ctxt->i2_prev_slice_mbx = ps_view_ctxt->u2_mbx;
1504 ps_view_ctxt->i2_prev_slice_mby = ps_view_ctxt->u2_mby;
1505
1506 if(ps_view_ctxt->u2_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1))
1507 {
1508 ps_view_ctxt->u1_pic_decode_done = 1;
1509 }
1510
1511 return 0;
1512 }
1513
imvcd_parse_pslice(mvc_dec_ctxt_t * ps_mvcd_ctxt)1514 static WORD32 imvcd_parse_pslice(mvc_dec_ctxt_t *ps_mvcd_ctxt)
1515 {
1516 UWORD8 u1_num_ref_idx_l0, u1_num_ref_idx_l1;
1517 WORD32 i4_error_code;
1518 WORD32 i;
1519
1520 dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;
1521 nalu_mvc_ext_t *ps_cur_nalu_mvc_ext = imvcd_get_cur_nalu_mvc_ext(ps_mvcd_ctxt);
1522 dec_pic_params_t *ps_pps = ps_view_ctxt->ps_cur_pps;
1523 dec_slice_params_t *ps_slice = ps_view_ctxt->ps_cur_slice;
1524 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
1525
1526 ps_view_ctxt->s_default_mv_pred = imvcd_get_default_mv_pred();
1527
1528 i4_error_code = imvcd_set_ref_idx_override_flag(ps_view_ctxt);
1529
1530 if(OK != i4_error_code)
1531 {
1532 return i4_error_code;
1533 }
1534
1535 if(ps_slice->u1_num_ref_idx_active_override_flag)
1536 {
1537 i4_error_code = imvcd_set_num_ref_idx_active(ps_view_ctxt, &u1_num_ref_idx_l0);
1538
1539 if(OK != i4_error_code)
1540 {
1541 return i4_error_code;
1542 }
1543 }
1544 else
1545 {
1546 u1_num_ref_idx_l0 = ps_view_ctxt->ps_cur_pps->u1_num_ref_idx_lx_active[0];
1547 }
1548
1549 u1_num_ref_idx_l1 = 0;
1550
1551 ps_slice->u1_num_ref_idx_lx_active[0] = u1_num_ref_idx_l0;
1552 ps_slice->u1_num_ref_idx_lx_active[1] = u1_num_ref_idx_l1;
1553 ps_view_ctxt->u1_num_ref_idx_lx_active_prev = ps_slice->u1_num_ref_idx_lx_active[0];
1554
1555 i4_error_code =
1556 imvcd_init_ref_pic_list(ps_mvcd_ctxt->ps_dpb_mgr, ps_cur_nalu_mvc_ext,
1557 ps_mvcd_ctxt->ps_cur_au, ps_mvcd_ctxt->u2_num_views_decoded);
1558
1559 if(OK != i4_error_code)
1560 {
1561 return i4_error_code;
1562 }
1563
1564 i4_error_code = imvcd_set_ref_pic_list_mod_data(ps_mvcd_ctxt);
1565
1566 if(OK != i4_error_code)
1567 {
1568 return i4_error_code;
1569 }
1570
1571 i4_error_code = imvcd_dpb_reorder_ref_pic_list(
1572 ps_mvcd_ctxt->ps_dpb_mgr, ps_cur_nalu_mvc_ext, ps_mvcd_ctxt->ps_cur_au,
1573 imvcd_get_cur_ref_pic_list_mod_data(ps_mvcd_ctxt), ps_mvcd_ctxt->u2_num_views_decoded);
1574
1575 if(OK != i4_error_code)
1576 {
1577 return i4_error_code;
1578 }
1579
1580 ps_view_ctxt->ps_ref_pic_buf_lx[0] = imvcd_dpb_get_view_ref_pic_list(
1581 ps_mvcd_ctxt->ps_dpb_mgr, ps_mvcd_ctxt->u2_num_views_decoded,
1582 ps_cur_nalu_mvc_ext->u2_view_id, 0);
1583
1584 for(i = 0; i < u1_num_ref_idx_l0; i++)
1585 {
1586 if(NULL == ps_view_ctxt->ps_ref_pic_buf_lx[0][i]->pu1_buf1)
1587 {
1588 return ERROR_FEATURE_UNAVAIL;
1589 }
1590 }
1591
1592 imvcd_set_view_buf_id_to_buf_map(ps_view_ctxt);
1593
1594 imvcd_init_ref_idx_to_ref_buf_map(ps_mvcd_ctxt);
1595
1596 if(ps_pps->u1_wted_pred_flag)
1597 {
1598 i4_error_code = ih264d_parse_pred_weight_table(ps_slice, ps_bitstrm);
1599
1600 if(i4_error_code != OK)
1601 {
1602 return i4_error_code;
1603 }
1604
1605 ih264d_form_pred_weight_matrix(ps_view_ctxt);
1606 }
1607 else
1608 {
1609 ps_view_ctxt->ps_cur_slice->u2_log2Y_crwd = 0;
1610 }
1611
1612 ps_view_ctxt->pu4_wt_ofsts = ps_view_ctxt->pu4_wts_ofsts_mat;
1613 ps_view_ctxt->ps_parse_cur_slice->u2_log2Y_crwd = ps_view_ctxt->ps_cur_slice->u2_log2Y_crwd;
1614
1615 if(ps_slice->u1_nal_ref_idc != 0)
1616 {
1617 if(!ps_view_ctxt->ps_dpb_cmds->u1_dpb_commands_read)
1618 {
1619 WORD32 i4_bit_offset = ih264d_read_mmco_commands(ps_view_ctxt);
1620
1621 if(i4_bit_offset < 0)
1622 {
1623 return ERROR_DBP_MANAGER_T;
1624 }
1625
1626 ps_view_ctxt->u4_bitoffset = i4_bit_offset;
1627 }
1628 else
1629 {
1630 ps_bitstrm->u4_ofst += ps_view_ctxt->u4_bitoffset;
1631 }
1632 }
1633
1634 if(ps_pps->u1_entropy_coding_mode == CABAC)
1635 {
1636 i4_error_code = imvcd_set_cabac_init_idc(ps_view_ctxt);
1637
1638 if(i4_error_code != OK)
1639 {
1640 return i4_error_code;
1641 }
1642 }
1643
1644 i4_error_code = imvcd_set_slice_qp(ps_view_ctxt);
1645
1646 if(i4_error_code != OK)
1647 {
1648 return i4_error_code;
1649 }
1650
1651 i4_error_code = imvcd_set_slice_deblk_params(ps_view_ctxt);
1652
1653 if(i4_error_code != OK)
1654 {
1655 return i4_error_code;
1656 }
1657
1658 ps_view_ctxt->u1_slice_header_done = 1;
1659
1660 if(ps_pps->u1_entropy_coding_mode)
1661 {
1662 ps_view_ctxt->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cabac;
1663 ps_view_ctxt->pf_parse_inter_mb = ih264d_parse_pmb_cabac;
1664 ps_view_ctxt->pf_get_mb_info = ih264d_get_mb_info_cabac_nonmbaff;
1665
1666 ih264d_init_cabac_contexts(P_SLICE, ps_view_ctxt);
1667 }
1668 else
1669 {
1670 ps_view_ctxt->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cavlc;
1671 ps_view_ctxt->pf_parse_inter_mb = ih264d_parse_pmb_cavlc;
1672 ps_view_ctxt->pf_get_mb_info = ih264d_get_mb_info_cavlc_nonmbaff;
1673 }
1674
1675 ps_view_ctxt->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
1676
1677 ps_view_ctxt->u1_B = 0;
1678
1679 i4_error_code =
1680 ps_view_ctxt->pf_parse_inter_slice(ps_view_ctxt, ps_slice, ps_slice->u2_first_mb_in_slice);
1681
1682 return i4_error_code;
1683 }
1684
imvcd_parse_bslice(mvc_dec_ctxt_t * ps_mvcd_ctxt)1685 static WORD32 imvcd_parse_bslice(mvc_dec_ctxt_t *ps_mvcd_ctxt)
1686 {
1687 UWORD8 u1_num_ref_idx_l0, u1_num_ref_idx_l1;
1688 WORD32 i4_error_code;
1689 WORD32 i, j;
1690
1691 dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;
1692 nalu_mvc_ext_t *ps_cur_nalu_mvc_ext = imvcd_get_cur_nalu_mvc_ext(ps_mvcd_ctxt);
1693 dec_pic_params_t *ps_pps = ps_view_ctxt->ps_cur_pps;
1694 dec_slice_params_t *ps_slice = ps_view_ctxt->ps_cur_slice;
1695 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
1696
1697 ps_view_ctxt->s_default_mv_pred = imvcd_get_default_mv_pred();
1698
1699 i4_error_code = imvcd_set_ref_idx_override_flag(ps_view_ctxt);
1700
1701 if(OK != i4_error_code)
1702 {
1703 return i4_error_code;
1704 }
1705
1706 if(ps_slice->u1_num_ref_idx_active_override_flag)
1707 {
1708 i4_error_code = imvcd_set_num_ref_idx_active(ps_view_ctxt, &u1_num_ref_idx_l0);
1709
1710 if(OK != i4_error_code)
1711 {
1712 return i4_error_code;
1713 }
1714
1715 i4_error_code = imvcd_set_num_ref_idx_active(ps_view_ctxt, &u1_num_ref_idx_l1);
1716
1717 if(OK != i4_error_code)
1718 {
1719 return i4_error_code;
1720 }
1721 }
1722 else
1723 {
1724 u1_num_ref_idx_l0 = ps_view_ctxt->ps_cur_pps->u1_num_ref_idx_lx_active[0];
1725 u1_num_ref_idx_l1 = ps_view_ctxt->ps_cur_pps->u1_num_ref_idx_lx_active[1];
1726 }
1727
1728 if((0 == u1_num_ref_idx_l0) || (0 == u1_num_ref_idx_l1))
1729 {
1730 return ERROR_FEATURE_UNAVAIL;
1731 }
1732
1733 ps_slice->u1_num_ref_idx_lx_active[0] = u1_num_ref_idx_l0;
1734 ps_slice->u1_num_ref_idx_lx_active[1] = u1_num_ref_idx_l1;
1735 ps_view_ctxt->u1_num_ref_idx_lx_active_prev =
1736 ps_view_ctxt->ps_cur_slice->u1_num_ref_idx_lx_active[0];
1737
1738 i4_error_code =
1739 imvcd_init_ref_pic_list(ps_mvcd_ctxt->ps_dpb_mgr, ps_cur_nalu_mvc_ext,
1740 ps_mvcd_ctxt->ps_cur_au, ps_mvcd_ctxt->u2_num_views_decoded);
1741
1742 if(OK != i4_error_code)
1743 {
1744 return i4_error_code;
1745 }
1746
1747 i4_error_code = imvcd_set_ref_pic_list_mod_data(ps_mvcd_ctxt);
1748
1749 if(OK != i4_error_code)
1750 {
1751 return i4_error_code;
1752 }
1753
1754 i4_error_code = imvcd_dpb_reorder_ref_pic_list(
1755 ps_mvcd_ctxt->ps_dpb_mgr, ps_cur_nalu_mvc_ext, ps_mvcd_ctxt->ps_cur_au,
1756 imvcd_get_cur_ref_pic_list_mod_data(ps_mvcd_ctxt), ps_mvcd_ctxt->u2_num_views_decoded);
1757
1758 if(OK != i4_error_code)
1759 {
1760 return i4_error_code;
1761 }
1762
1763 for(i = 0; i < 2; i++)
1764 {
1765 ps_view_ctxt->ps_ref_pic_buf_lx[i] = imvcd_dpb_get_view_ref_pic_list(
1766 ps_mvcd_ctxt->ps_dpb_mgr, ps_mvcd_ctxt->u2_num_views_decoded,
1767 ps_cur_nalu_mvc_ext->u2_view_id, i);
1768
1769 for(j = 0; j < ps_slice->u1_num_ref_idx_lx_active[i]; j++)
1770 {
1771 if(NULL == ps_view_ctxt->ps_ref_pic_buf_lx[i][j]->pu1_buf1)
1772 {
1773 return ERROR_FEATURE_UNAVAIL;
1774 }
1775 }
1776 }
1777
1778 imvcd_set_view_buf_id_to_buf_map(ps_view_ctxt);
1779
1780 imvcd_init_ref_idx_to_ref_buf_map(ps_mvcd_ctxt);
1781
1782 if(ps_pps->u1_wted_bipred_idc == 1)
1783 {
1784 i4_error_code = ih264d_parse_pred_weight_table(ps_slice, ps_bitstrm);
1785
1786 if(i4_error_code != OK)
1787 {
1788 return i4_error_code;
1789 }
1790
1791 ih264d_form_pred_weight_matrix(ps_view_ctxt);
1792
1793 ps_view_ctxt->pu4_wt_ofsts = ps_view_ctxt->pu4_wts_ofsts_mat;
1794 }
1795 else if(ps_pps->u1_wted_bipred_idc == 2)
1796 {
1797 /* Implicit Weighted prediction */
1798 ps_slice->u2_log2Y_crwd = 0x0505;
1799 ps_view_ctxt->pu4_wt_ofsts = ps_view_ctxt->pu4_wts_ofsts_mat;
1800
1801 ih264d_get_implicit_weights(ps_view_ctxt);
1802 }
1803 else
1804 {
1805 ps_view_ctxt->ps_cur_slice->u2_log2Y_crwd = 0;
1806 }
1807
1808 ps_view_ctxt->ps_parse_cur_slice->u2_log2Y_crwd = ps_view_ctxt->ps_cur_slice->u2_log2Y_crwd;
1809
1810 if(ps_slice->u1_nal_ref_idc != 0)
1811 {
1812 if(!ps_view_ctxt->ps_dpb_cmds->u1_dpb_commands_read)
1813 {
1814 WORD32 i4_bit_offset = ih264d_read_mmco_commands(ps_view_ctxt);
1815
1816 if(i4_bit_offset < 0)
1817 {
1818 return ERROR_DBP_MANAGER_T;
1819 }
1820
1821 ps_view_ctxt->u4_bitoffset = i4_bit_offset;
1822 }
1823 else
1824 {
1825 ps_bitstrm->u4_ofst += ps_view_ctxt->u4_bitoffset;
1826 }
1827 }
1828
1829 if(ps_pps->u1_entropy_coding_mode == CABAC)
1830 {
1831 i4_error_code = imvcd_set_cabac_init_idc(ps_view_ctxt);
1832
1833 if(i4_error_code != OK)
1834 {
1835 return i4_error_code;
1836 }
1837 }
1838
1839 i4_error_code = imvcd_set_slice_qp(ps_view_ctxt);
1840
1841 if(i4_error_code != OK)
1842 {
1843 return i4_error_code;
1844 }
1845
1846 i4_error_code = imvcd_set_slice_deblk_params(ps_view_ctxt);
1847
1848 if(i4_error_code != OK)
1849 {
1850 return i4_error_code;
1851 }
1852
1853 ps_view_ctxt->u1_slice_header_done = 1;
1854
1855 if(ps_pps->u1_entropy_coding_mode)
1856 {
1857 ps_view_ctxt->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cabac;
1858 ps_view_ctxt->pf_parse_inter_mb = ih264d_parse_bmb_cabac;
1859 ps_view_ctxt->pf_get_mb_info = ih264d_get_mb_info_cabac_nonmbaff;
1860
1861 ih264d_init_cabac_contexts(B_SLICE, ps_view_ctxt);
1862 }
1863 else
1864 {
1865 ps_view_ctxt->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cavlc;
1866 ps_view_ctxt->pf_parse_inter_mb = ih264d_parse_bmb_cavlc;
1867 ps_view_ctxt->pf_get_mb_info = ih264d_get_mb_info_cavlc_nonmbaff;
1868 }
1869
1870 i4_error_code = ih264d_cal_col_pic(ps_view_ctxt);
1871
1872 if(i4_error_code != OK)
1873 {
1874 return i4_error_code;
1875 }
1876
1877 ps_view_ctxt->u1_B = 1;
1878
1879 ps_view_ctxt->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_bmb;
1880
1881 i4_error_code =
1882 ps_view_ctxt->pf_parse_inter_slice(ps_view_ctxt, ps_slice, ps_slice->u2_first_mb_in_slice);
1883
1884 return i4_error_code;
1885 }
1886
imvcd_parse_islice(mvc_dec_ctxt_t * ps_mvcd_ctxt)1887 static WORD32 imvcd_parse_islice(mvc_dec_ctxt_t *ps_mvcd_ctxt)
1888 {
1889 WORD32 i4_error_code;
1890
1891 dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;
1892
1893 i4_error_code =
1894 ih264d_parse_islice(ps_view_ctxt, ps_view_ctxt->ps_cur_slice->u2_first_mb_in_slice);
1895
1896 return i4_error_code;
1897 }
1898
imvcd_finish_slice_decode(mvc_dec_ctxt_t * ps_mvcd_ctxt)1899 static WORD32 imvcd_finish_slice_decode(mvc_dec_ctxt_t *ps_mvcd_ctxt)
1900 {
1901 WORD32 i;
1902
1903 dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;
1904 dec_err_status_t *ps_err = ps_view_ctxt->ps_dec_err_status;
1905
1906 UWORD16 u2_view_order_id = ps_mvcd_ctxt->u2_num_views_decoded;
1907 UWORD16 u2_num_views = ps_mvcd_ctxt->u2_num_views;
1908
1909 imvcd_dpb_reset_ivp_ctxt(ps_mvcd_ctxt->ps_dpb_mgr);
1910
1911 /* End of Picture detection */
1912 if(ps_view_ctxt->u2_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1))
1913 {
1914 ps_view_ctxt->u1_pic_decode_done = 1;
1915 }
1916 else
1917 {
1918 imvcd_corrupted_slice_handler(ps_mvcd_ctxt);
1919
1920 return ERROR_CORRUPTED_SLICE;
1921 }
1922
1923 if((ps_view_ctxt->u1_slice_header_done) && (u2_view_order_id == (u2_num_views - 1)))
1924 {
1925 ps_view_ctxt->u1_first_slice_in_stream = 0;
1926 }
1927
1928 if((ps_mvcd_ctxt->au1_nal_ref_idc[u2_view_order_id] != 0) && (0 == u2_view_order_id))
1929 {
1930 if(!ps_view_ctxt->ps_dpb_cmds->u1_dpb_commands_read)
1931 {
1932 ps_view_ctxt->ps_dpb_cmds[0] = ps_view_ctxt->s_dpb_cmds_scratch;
1933 }
1934 }
1935
1936 /* storing last Mb X and MbY of the slice */
1937 ps_view_ctxt->i2_prev_slice_mbx = ps_view_ctxt->u2_mbx;
1938 ps_view_ctxt->i2_prev_slice_mby = ps_view_ctxt->u2_mby;
1939
1940 if((ps_err->u1_err_flag & REJECT_PB_PICS) && (ps_err->u1_cur_pic_type == PIC_TYPE_I))
1941 {
1942 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
1943 }
1944
1945 /* Accounting for idiocy in 'ih264d_parse_sps' */
1946 if(u2_view_order_id > 0)
1947 {
1948 for(i = 0; i < MAX_NUM_SEQ_PARAMS; i++)
1949 {
1950 if(ps_view_ctxt->ps_sps->u1_is_valid)
1951 {
1952 ps_view_ctxt->ps_cur_sps = ps_view_ctxt->ps_sps;
1953
1954 break;
1955 }
1956 }
1957 }
1958
1959 return OK;
1960 }
1961
imvcd_parse_decode_slice(mvc_dec_ctxt_t * ps_mvcd_ctxt)1962 WORD32 imvcd_parse_decode_slice(mvc_dec_ctxt_t *ps_mvcd_ctxt)
1963 {
1964 dec_pic_params_t *ps_pps;
1965 dec_seq_params_t *ps_sps;
1966 dec_slice_params_t *ps_cur_slice;
1967
1968 WORD32 i4_error_code;
1969 UWORD8 u1_pps_id;
1970 UWORD8 u1_pic_order_cnt_type;
1971
1972 dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;
1973 nalu_mvc_ext_t *ps_nalu_mvc_ext = imvcd_get_cur_nalu_mvc_ext(ps_mvcd_ctxt);
1974 dec_bit_stream_t *ps_bitstrm = ps_view_ctxt->ps_bitstrm;
1975 pocstruct_t s_tmp_poc = {0};
1976 dec_err_status_t *ps_err = ps_view_ctxt->ps_dec_err_status;
1977
1978 WORD32 ai4_delta_poc[2] = {0};
1979 WORD32 i4_poc = 0;
1980 UWORD32 u4_idr_pic_id = 0;
1981 UWORD16 u2_view_id = ps_nalu_mvc_ext->u2_view_id;
1982 UWORD16 u2_view_order_id = ps_mvcd_ctxt->u2_num_views_decoded;
1983 bool b_is_idr_slice = imvcd_is_idr_au(ps_mvcd_ctxt);
1984 UWORD16 u2_num_views = ps_mvcd_ctxt->u2_num_views;
1985 UWORD8 u1_redundant_pic_cnt = 0;
1986 const UWORD8 u1_field_pic_flag = 0;
1987 const UWORD8 u1_bottom_field_flag = 0;
1988
1989 ps_view_ctxt->ps_cur_slice = ps_cur_slice = &ps_mvcd_ctxt->as_slices[u2_view_id];
1990 ps_view_ctxt->ps_dpb_cmds->u1_dpb_commands_read_slc = 0;
1991
1992 ps_cur_slice->u1_nal_unit_type = ps_mvcd_ctxt->ae_nalu_id[u2_view_order_id];
1993 ps_cur_slice->u1_nal_ref_idc = ps_mvcd_ctxt->au1_nal_ref_idc[u2_view_order_id];
1994
1995 i4_error_code = imvcd_set_first_mb_in_slice(ps_view_ctxt);
1996
1997 if(OK != i4_error_code)
1998 {
1999 return i4_error_code;
2000 }
2001
2002 i4_error_code = imvcd_set_slice_type(ps_view_ctxt);
2003
2004 if(OK != i4_error_code)
2005 {
2006 return i4_error_code;
2007 }
2008
2009 i4_error_code = imvcd_set_cur_pps(ps_view_ctxt, &u1_pps_id);
2010
2011 if(OK != i4_error_code)
2012 {
2013 return i4_error_code;
2014 }
2015
2016 ps_pps = ps_view_ctxt->ps_cur_pps;
2017 ps_sps = ps_view_ctxt->ps_cur_sps;
2018
2019 i4_error_code = imvcd_set_frame_num(ps_view_ctxt, ps_sps->u1_bits_in_frm_num);
2020
2021 if(OK != i4_error_code)
2022 {
2023 return i4_error_code;
2024 }
2025
2026 if(!ps_view_ctxt->u1_first_slice_in_stream && ps_view_ctxt->u4_first_slice_in_pic)
2027 {
2028 ps_view_ctxt->u2_mbx = 0xffff;
2029 ps_view_ctxt->u2_mby = 0;
2030 ps_view_ctxt->u2_total_mbs_coded = 0;
2031
2032 if(0 == u2_view_order_id)
2033 {
2034 if(b_is_idr_slice || ps_cur_slice->u1_mmco_equalto5)
2035 {
2036 ps_view_ctxt->u2_prev_ref_frame_num = 0;
2037 }
2038
2039 if(ps_view_ctxt->ps_cur_sps->u1_gaps_in_frame_num_value_allowed_flag)
2040 {
2041 i4_error_code = imvcd_decode_gaps_in_frame_num(ps_mvcd_ctxt);
2042
2043 if(OK != i4_error_code)
2044 {
2045 return i4_error_code;
2046 }
2047 }
2048
2049 if(!b_is_idr_slice && ps_cur_slice->u1_nal_ref_idc)
2050 {
2051 ps_view_ctxt->u2_prev_ref_frame_num = ps_cur_slice->u2_frame_num;
2052 }
2053
2054 imvcd_pocstruct_init(ps_view_ctxt);
2055 }
2056 }
2057
2058 if(b_is_idr_slice)
2059 {
2060 i4_error_code = imvcd_set_idr_pic_id(ps_view_ctxt, &u4_idr_pic_id);
2061
2062 if(OK != i4_error_code)
2063 {
2064 return i4_error_code;
2065 }
2066
2067 /* 'ih264d_read_mmco_commands' asssumes AVC semantics */
2068 ps_view_ctxt->u1_nal_unit_type = SLICE_IDR;
2069 }
2070 else
2071 {
2072 ps_view_ctxt->u1_nal_unit_type = SLICE_NON_IDR;
2073 }
2074
2075 u1_pic_order_cnt_type = ps_sps->u1_pic_order_cnt_type;
2076
2077 if(0 == u1_pic_order_cnt_type)
2078 {
2079 i4_error_code = imvcd_set_poc_lsb(ps_view_ctxt, &s_tmp_poc.i4_pic_order_cnt_lsb,
2080 ps_sps->i4_max_pic_order_cntLsb,
2081 ps_sps->u1_log2_max_pic_order_cnt_lsb_minus);
2082
2083 if(OK != i4_error_code)
2084 {
2085 return i4_error_code;
2086 }
2087
2088 if(ps_pps->u1_pic_order_present_flag)
2089 {
2090 i4_error_code =
2091 imvcd_set_delta_poc(ps_view_ctxt, &s_tmp_poc.i4_delta_pic_order_cnt_bottom);
2092
2093 if(OK != i4_error_code)
2094 {
2095 return i4_error_code;
2096 }
2097 }
2098 }
2099
2100 if((1 == u1_pic_order_cnt_type) && !ps_sps->u1_delta_pic_order_always_zero_flag)
2101 {
2102 i4_error_code = imvcd_set_delta_poc(ps_view_ctxt, &s_tmp_poc.i4_delta_pic_order_cnt[0]);
2103
2104 if(OK != i4_error_code)
2105 {
2106 return i4_error_code;
2107 }
2108
2109 if(ps_pps->u1_pic_order_present_flag)
2110 {
2111 i4_error_code = imvcd_set_delta_poc(ps_view_ctxt, &s_tmp_poc.i4_delta_pic_order_cnt[1]);
2112
2113 if(OK != i4_error_code)
2114 {
2115 return i4_error_code;
2116 }
2117 }
2118 }
2119
2120 if(ps_pps->u1_redundant_pic_cnt_present_flag)
2121 {
2122 i4_error_code = imvcd_set_redundant_pic_cnt(ps_view_ctxt, &u1_redundant_pic_cnt);
2123
2124 if(OK != i4_error_code)
2125 {
2126 return i4_error_code;
2127 }
2128 }
2129
2130 ps_view_ctxt->ps_dec_err_status->u1_err_flag &= MASK_REJECT_CUR_PIC;
2131
2132 ps_view_ctxt->u1_slice_header_done = 0;
2133
2134 if(ps_view_ctxt->u4_first_slice_in_pic)
2135 {
2136 i4_error_code = ih264d_decode_pic_order_cnt(
2137 b_is_idr_slice, ps_cur_slice->u2_frame_num, &ps_view_ctxt->s_prev_pic_poc, &s_tmp_poc,
2138 ps_cur_slice, ps_pps, ps_mvcd_ctxt->au1_nal_ref_idc[u2_view_order_id],
2139 u1_bottom_field_flag, u1_field_pic_flag, &i4_poc);
2140
2141 if(i4_error_code != OK)
2142 {
2143 return i4_error_code;
2144 }
2145
2146 /* Display seq no calculations */
2147 if(i4_poc >= ps_view_ctxt->i4_max_poc)
2148 {
2149 ps_view_ctxt->i4_max_poc = i4_poc;
2150 }
2151
2152 /* IDR Picture or POC wrap around */
2153 if(i4_poc == 0)
2154 {
2155 imvcd_modulate_max_disp_seq(ps_view_ctxt);
2156 }
2157 }
2158
2159 if((0 == i4_poc) && (ps_mvcd_ctxt->ae_nalu_id[u2_view_order_id] == SLICE_IDR) &&
2160 (ps_cur_slice->u1_slice_type != ISLICE))
2161 {
2162 return ERROR_INV_SLICE_HDR_T;
2163 }
2164
2165 /*--------------------------------------------------------------------*/
2166 /* Copy the values read from the bitstream to the slice header and then*/
2167 /* If the slice is first slice in picture, then do Start of Picture */
2168 /* processing. */
2169 /*--------------------------------------------------------------------*/
2170 ps_cur_slice->i4_delta_pic_order_cnt[0] = ai4_delta_poc[0];
2171 ps_cur_slice->i4_delta_pic_order_cnt[1] = ai4_delta_poc[1];
2172 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
2173 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
2174 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
2175 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
2176 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
2177 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
2178 ps_cur_slice->i4_poc = i4_poc;
2179
2180 ps_cur_slice->u1_direct_8x8_inference_flag = ps_sps->u1_direct_8x8_inference_flag;
2181
2182 if(IV_SUCCESS != imvcd_view_error_checks(ps_mvcd_ctxt))
2183 {
2184 return ERROR_INV_SLICE_HDR_T;
2185 }
2186
2187 if(ps_cur_slice->u1_slice_type == B_SLICE)
2188 {
2189 i4_error_code = imvcd_set_direct_spatial_mv_pred_flag(ps_view_ctxt);
2190
2191 if(OK != i4_error_code)
2192 {
2193 return i4_error_code;
2194 }
2195
2196 if(ps_cur_slice->u1_direct_spatial_mv_pred_flag)
2197 {
2198 ps_cur_slice->pf_decodeDirect = ih264d_decode_spatial_direct;
2199 }
2200 else
2201 {
2202 ps_cur_slice->pf_decodeDirect = ih264d_decode_temporal_direct;
2203 }
2204
2205 ps_view_ctxt->pf_mvpred = ih264d_mvpred_nonmbaffB;
2206 }
2207 else
2208 {
2209 ps_view_ctxt->pf_mvpred = ih264d_mvpred_nonmbaff;
2210 }
2211
2212 if(ps_view_ctxt->u4_first_slice_in_pic)
2213 {
2214 if(0 == ps_cur_slice->u2_first_mb_in_slice)
2215 {
2216 i4_error_code = imvcd_pic_init(ps_mvcd_ctxt, &s_tmp_poc, i4_poc, b_is_idr_slice);
2217
2218 if(i4_error_code != OK)
2219 {
2220 return i4_error_code;
2221 }
2222 }
2223 else
2224 {
2225 return ERROR_INV_SLICE_HDR_T;
2226 }
2227
2228 ps_view_ctxt->u4_output_present = 0;
2229
2230 if(u2_view_order_id == (u2_num_views - 1))
2231 {
2232 if(IV_SUCCESS == imvcd_get_next_display_au_buf(ps_mvcd_ctxt))
2233 {
2234 ps_view_ctxt->u4_output_present = 1;
2235 }
2236 }
2237
2238 if(!imvcd_dpb_is_diff_poc_valid(ps_mvcd_ctxt->ps_dpb_mgr, ps_cur_slice->i4_poc))
2239 {
2240 return ERROR_INV_SLICE_HDR_T;
2241 }
2242
2243 if(ps_view_ctxt->u1_separate_parse == 1)
2244 {
2245 if(!ps_view_ctxt->u4_dec_thread_created)
2246 {
2247 ithread_create(ps_view_ctxt->pv_dec_thread_handle, NULL,
2248 ih264d_decode_picture_thread, ps_view_ctxt);
2249
2250 ps_view_ctxt->u4_dec_thread_created = 1;
2251 }
2252
2253 if((3 == ps_view_ctxt->u4_num_cores) &&
2254 (!ps_view_ctxt->u4_app_disable_deblk_frm ||
2255 ps_view_ctxt->i1_recon_in_thread3_flag) &&
2256 !ps_view_ctxt->u4_bs_deblk_thread_created)
2257 {
2258 ps_view_ctxt->u4_start_recon_deblk = 0;
2259
2260 ithread_create(ps_view_ctxt->pv_bs_deblk_thread_handle, NULL,
2261 ih264d_recon_deblk_thread, ps_view_ctxt);
2262
2263 ps_view_ctxt->u4_bs_deblk_thread_created = 1;
2264 }
2265 }
2266 }
2267
2268 if((ps_cur_slice->u1_slice_type != B_SLICE) &&
2269 (ps_view_ctxt->ps_cur_pps->u1_wted_pred_flag == 0))
2270 {
2271 ps_view_ctxt->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
2272 ps_view_ctxt->p_motion_compensate = ih264d_motion_compensate_bp;
2273 }
2274 else
2275 {
2276 ps_view_ctxt->p_form_mb_part_info = ih264d_form_mb_part_info_mp;
2277 ps_view_ctxt->p_motion_compensate = ih264d_motion_compensate_mp;
2278 }
2279
2280 if(ps_err->u4_frm_sei_sync == ps_cur_slice->u2_frame_num)
2281 {
2282 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
2283 ps_err->u4_frm_sei_sync = SYNC_FRM_DEFAULT;
2284 }
2285
2286 ps_err->u4_cur_frm = ps_cur_slice->u2_frame_num;
2287
2288 ps_view_ctxt->i4_submb_ofst = -SUB_BLK_SIZE;
2289
2290 ps_view_ctxt->u2_cur_mb_addr = 0;
2291 ps_view_ctxt->ps_deblk_mbn = ps_view_ctxt->ps_deblk_pic;
2292 ps_view_ctxt->ps_mv_cur = ps_mvcd_ctxt->ps_cur_au->ps_au_mv_data->aps_mvs[u2_view_id];
2293
2294 ps_view_ctxt->s_tran_addrecon.pu1_dest_y =
2295 ps_mvcd_ctxt->ps_cur_au->as_view_buffers[u2_view_id].as_component_bufs[Y].pv_data;
2296 ps_view_ctxt->s_tran_addrecon.pu1_dest_u =
2297 ps_mvcd_ctxt->ps_cur_au->as_view_buffers[u2_view_id].as_component_bufs[UV].pv_data;
2298 ps_view_ctxt->s_tran_addrecon.pu1_dest_v = NULL;
2299
2300 ps_view_ctxt->s_tran_addrecon.pu1_mb_y =
2301 ps_mvcd_ctxt->ps_cur_au->as_view_buffers[u2_view_id].as_component_bufs[Y].pv_data;
2302 ps_view_ctxt->s_tran_addrecon.pu1_mb_u =
2303 ps_mvcd_ctxt->ps_cur_au->as_view_buffers[u2_view_id].as_component_bufs[UV].pv_data;
2304 ps_view_ctxt->s_tran_addrecon.pu1_mb_v = NULL;
2305
2306 ps_view_ctxt->ps_part = ps_view_ctxt->ps_parse_part_params;
2307
2308 ps_view_ctxt->u2_mbx = (MOD(ps_cur_slice->u2_first_mb_in_slice - 1, ps_sps->u2_frm_wd_in_mbs));
2309 ps_view_ctxt->u2_mby = (DIV(ps_cur_slice->u2_first_mb_in_slice - 1, ps_sps->u2_frm_wd_in_mbs));
2310 ps_view_ctxt->i2_prev_slice_mbx = ps_view_ctxt->u2_mbx;
2311 ps_view_ctxt->i2_prev_slice_mby = ps_view_ctxt->u2_mby;
2312
2313 /* RBSP stop bit is used for CABAC decoding*/
2314 ps_bitstrm->u4_max_ofst += ps_view_ctxt->ps_cur_pps->u1_entropy_coding_mode;
2315
2316 ps_view_ctxt->u1_B = (ps_cur_slice->u1_slice_type == B_SLICE);
2317 ps_view_ctxt->u4_next_mb_skip = 0;
2318
2319 ps_view_ctxt->ps_parse_cur_slice->u4_first_mb_in_slice = ps_cur_slice->u2_first_mb_in_slice;
2320 ps_view_ctxt->ps_parse_cur_slice->slice_type = ps_cur_slice->u1_slice_type;
2321
2322 ps_view_ctxt->u4_start_recon_deblk = 1;
2323
2324 ps_view_ctxt->ps_parse_cur_slice->ppv_map_ref_idx_to_poc =
2325 ps_view_ctxt->pv_map_ref_idx_to_poc_buf;
2326
2327 if(ps_view_ctxt->u1_separate_parse)
2328 {
2329 ps_view_ctxt->ps_parse_cur_slice->pv_tu_coeff_data_start =
2330 ps_view_ctxt->pv_parse_tu_coeff_data;
2331 }
2332 else
2333 {
2334 ps_view_ctxt->pv_proc_tu_coeff_data = ps_view_ctxt->pv_parse_tu_coeff_data;
2335 }
2336
2337 if(0 == u2_view_order_id)
2338 {
2339 i4_error_code = imvcd_dpb_st_lt_deduplicator(ps_mvcd_ctxt->ps_dpb_mgr);
2340
2341 if(i4_error_code < 0)
2342 {
2343 i4_error_code = ERROR_DBP_MANAGER_T;
2344 }
2345 }
2346
2347 if(ps_cur_slice->u1_slice_type == I_SLICE)
2348 {
2349 ps_mvcd_ctxt->ps_cur_au->au4_pack_slc_typ[u2_view_order_id] |= I_SLC_BIT;
2350
2351 i4_error_code = imvcd_parse_islice(ps_mvcd_ctxt);
2352
2353 ps_view_ctxt->u1_pr_sl_type = ps_cur_slice->u1_slice_type;
2354
2355 if(ps_view_ctxt->i4_pic_type != B_SLICE && ps_view_ctxt->i4_pic_type != P_SLICE)
2356 {
2357 ps_view_ctxt->i4_pic_type = I_SLICE;
2358 }
2359 }
2360 else if(ps_cur_slice->u1_slice_type == P_SLICE)
2361 {
2362 ps_mvcd_ctxt->ps_cur_au->au4_pack_slc_typ[u2_view_order_id] |= P_SLC_BIT;
2363
2364 i4_error_code = imvcd_parse_pslice(ps_mvcd_ctxt);
2365
2366 ps_view_ctxt->u1_pr_sl_type = ps_cur_slice->u1_slice_type;
2367
2368 if(ps_view_ctxt->i4_pic_type != B_SLICE)
2369 {
2370 ps_view_ctxt->i4_pic_type = P_SLICE;
2371 }
2372 }
2373 else if(ps_cur_slice->u1_slice_type == B_SLICE)
2374 {
2375 ps_mvcd_ctxt->ps_cur_au->au4_pack_slc_typ[u2_view_order_id] |= B_SLC_BIT;
2376
2377 i4_error_code = imvcd_parse_bslice(ps_mvcd_ctxt);
2378
2379 ps_view_ctxt->u1_pr_sl_type = ps_cur_slice->u1_slice_type;
2380
2381 ps_view_ctxt->i4_pic_type = B_SLICE;
2382 }
2383 else
2384 {
2385 i4_error_code = ERROR_INV_SLC_TYPE_T;
2386 }
2387
2388 i4_error_code = imvcd_finish_slice_decode(ps_mvcd_ctxt);
2389
2390 return i4_error_code;
2391 }
2392