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