1 /******************************************************************************
2 *
3 * Copyright (C) 2015 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19 */
20
21 /*****************************************************************************/
22 /* */
23 /* File Name : ih264d_sei.c */
24 /* */
25 /* Description : This file contains routines to parse SEI NAL's */
26 /* */
27 /* List of Functions : <List the functions defined in this file> */
28 /* */
29 /* Issues / Problems : None */
30 /* */
31 /* Revision History : */
32 /* */
33 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
34 /* 25 05 2005 NS Draft */
35 /* */
36 /*****************************************************************************/
37
38 #include <string.h>
39
40 #include "ih264_typedefs.h"
41 #include "ih264_macros.h"
42 #include "ih264_platform_macros.h"
43 #include "ih264d_bitstrm.h"
44 #include "ih264d_structs.h"
45 #include "ih264d_error_handler.h"
46 #include "ih264d_vui.h"
47 #include "ih264d_parse_cavlc.h"
48 #include "ih264d_defs.h"
49
50 /*****************************************************************************/
51 /* */
52 /* Function Name : ih264d_parse_buffering_period */
53 /* */
54 /* Description : This function parses SEI message buffering_period */
55 /* Inputs : ps_buf_prd pointer to struct buf_period_t */
56 /* ps_bitstrm Bitstream */
57 /* Globals : None */
58 /* Processing : Parses SEI payload buffering period. */
59 /* Outputs : None */
60 /* Return : 0 for successfull parsing, else error message */
61 /* */
62 /* Issues : Not implemented fully */
63 /* */
64 /* Revision History: */
65 /* */
66 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
67 /* 06 05 2002 NS Draft */
68 /* */
69 /*****************************************************************************/
70
ih264d_parse_buffering_period(buf_period_t * ps_buf_prd,dec_bit_stream_t * ps_bitstrm,dec_struct_t * ps_dec)71 WORD32 ih264d_parse_buffering_period(buf_period_t *ps_buf_prd,
72 dec_bit_stream_t *ps_bitstrm,
73 dec_struct_t *ps_dec)
74 {
75 UWORD8 u1_seq_parameter_set_id;
76 dec_seq_params_t *ps_seq;
77 UWORD8 u1_nal_hrd_present, u1_vcl_hrd_present;
78 UWORD32 i;
79 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
80 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
81 UNUSED(ps_buf_prd);
82 u1_seq_parameter_set_id = ih264d_uev(pu4_bitstrm_ofst,
83 pu4_bitstrm_buf);
84 if(u1_seq_parameter_set_id >= MAX_NUM_SEQ_PARAMS)
85 return ERROR_INVALID_SEQ_PARAM;
86 ps_seq = &ps_dec->ps_sps[u1_seq_parameter_set_id];
87 if(TRUE != ps_seq->u1_is_valid)
88 return ERROR_INVALID_SEQ_PARAM;
89
90 ps_dec->ps_sei->u1_seq_param_set_id = u1_seq_parameter_set_id;
91 ps_dec->ps_cur_sps = ps_seq;
92 if(FALSE == ps_seq->u1_is_valid)
93 return ERROR_INVALID_SEQ_PARAM;
94 if(1 == ps_seq->u1_vui_parameters_present_flag)
95 {
96 u1_nal_hrd_present = ps_seq->s_vui.u1_nal_hrd_params_present;
97 if(u1_nal_hrd_present)
98 {
99 for(i = 0; i < ps_seq->s_vui.s_nal_hrd.u4_cpb_cnt; i++)
100 {
101 ih264d_get_bits_h264(
102 ps_bitstrm,
103 ps_seq->s_vui.s_nal_hrd.u1_initial_cpb_removal_delay);
104 ih264d_get_bits_h264(
105 ps_bitstrm,
106 ps_seq->s_vui.s_nal_hrd.u1_initial_cpb_removal_delay);
107 }
108 }
109
110 u1_vcl_hrd_present = ps_seq->s_vui.u1_vcl_hrd_params_present;
111 if(u1_vcl_hrd_present)
112 {
113 for(i = 0; i < ps_seq->s_vui.s_vcl_hrd.u4_cpb_cnt; i++)
114 {
115 ih264d_get_bits_h264(
116 ps_bitstrm,
117 ps_seq->s_vui.s_vcl_hrd.u1_initial_cpb_removal_delay);
118 ih264d_get_bits_h264(
119 ps_bitstrm,
120 ps_seq->s_vui.s_vcl_hrd.u1_initial_cpb_removal_delay);
121 }
122 }
123 }
124 return (OK);
125 }
126
127 /*****************************************************************************/
128 /* */
129 /* Function Name : ih264d_parse_pic_timing */
130 /* */
131 /* Description : This function parses SEI message pic_timing */
132 /* Inputs : ps_bitstrm Bitstream */
133 /* ps_dec Poniter decoder context */
134 /* ui4_payload_size pay load i4_size */
135 /* Globals : None */
136 /* Processing : Parses SEI payload picture timing */
137 /* Outputs : None */
138 /* Return : 0 */
139 /* */
140 /* Issues : Not implemented fully */
141 /* */
142 /* Revision History: */
143 /* */
144 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
145 /* 06 05 2002 NS Draft */
146 /* */
147 /*****************************************************************************/
ih264d_parse_pic_timing(dec_bit_stream_t * ps_bitstrm,dec_struct_t * ps_dec,UWORD32 ui4_payload_size)148 WORD32 ih264d_parse_pic_timing(dec_bit_stream_t *ps_bitstrm,
149 dec_struct_t *ps_dec,
150 UWORD32 ui4_payload_size)
151 {
152 sei *ps_sei;
153 vui_t *ps_vu4;
154 UWORD8 u1_cpb_dpb_present;
155 UWORD8 u1_pic_struct_present_flag;
156 UWORD32 u4_start_offset, u4_bits_consumed;
157 UWORD8 u1_cpb_removal_delay_length, u1_dpb_output_delay_length;
158
159 ps_sei = (sei *)ps_dec->ps_sei;
160 ps_vu4 = &ps_dec->ps_cur_sps->s_vui;
161
162 u1_cpb_dpb_present = ps_vu4->u1_vcl_hrd_params_present
163 + ps_vu4->u1_nal_hrd_params_present;
164
165 if(ps_vu4->u1_vcl_hrd_params_present)
166 {
167 u1_cpb_removal_delay_length =
168 ps_vu4->s_vcl_hrd.u1_cpb_removal_delay_length;
169 u1_dpb_output_delay_length =
170 ps_vu4->s_vcl_hrd.u1_dpb_output_delay_length;
171 }
172 else if(ps_vu4->u1_nal_hrd_params_present)
173 {
174 u1_cpb_removal_delay_length =
175 ps_vu4->s_nal_hrd.u1_cpb_removal_delay_length;
176 u1_dpb_output_delay_length =
177 ps_vu4->s_nal_hrd.u1_dpb_output_delay_length;
178 }
179 else
180 {
181 u1_cpb_removal_delay_length = 24;
182 u1_dpb_output_delay_length = 24;
183
184 }
185
186 u4_start_offset = ps_bitstrm->u4_ofst;
187 if(u1_cpb_dpb_present)
188 {
189 ih264d_get_bits_h264(ps_bitstrm, u1_cpb_removal_delay_length);
190 ih264d_get_bits_h264(ps_bitstrm, u1_dpb_output_delay_length);
191 }
192
193 u1_pic_struct_present_flag = ps_vu4->u1_pic_struct_present_flag;
194 if(u1_pic_struct_present_flag)
195 {
196 ps_sei->u1_pic_struct = ih264d_get_bits_h264(ps_bitstrm, 4);
197 ps_dec->u1_pic_struct_copy = ps_sei->u1_pic_struct;
198 ps_sei->u1_is_valid = 1;
199 }
200 u4_bits_consumed = ps_bitstrm->u4_ofst - u4_start_offset;
201
202 if((ui4_payload_size << 3) < u4_bits_consumed)
203 return ERROR_CORRUPTED_SLICE;
204
205 ih264d_flush_bits_h264(ps_bitstrm,
206 (ui4_payload_size << 3) - u4_bits_consumed);
207
208 return (OK);
209 }
210
211 /*****************************************************************************/
212 /* */
213 /* Function Name : ih264d_parse_recovery_point */
214 /* */
215 /* Description : This function parses SEI message recovery point */
216 /* Inputs : ps_bitstrm Bitstream */
217 /* ps_dec Poniter decoder context */
218 /* ui4_payload_size pay load i4_size */
219 /* Globals : None */
220 /* Processing : Parses SEI payload picture timing */
221 /* Outputs : None */
222 /* Return : 0 */
223 /* */
224 /* Issues : Not implemented fully */
225 /* */
226 /* Revision History: */
227 /* */
228 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
229 /* 06 05 2002 NS Draft */
230 /* */
231 /*****************************************************************************/
ih264d_parse_recovery_point(dec_bit_stream_t * ps_bitstrm,dec_struct_t * ps_dec,UWORD32 ui4_payload_size)232 WORD32 ih264d_parse_recovery_point(dec_bit_stream_t *ps_bitstrm,
233 dec_struct_t *ps_dec,
234 UWORD32 ui4_payload_size)
235 {
236 sei *ps_sei = ps_dec->ps_sei;
237 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
238 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
239 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
240 UNUSED(ui4_payload_size);
241 ps_sei->u2_recovery_frame_cnt = ih264d_uev(pu4_bitstrm_ofst,
242 pu4_bitstrm_buf);
243 ps_err->u4_frm_sei_sync = ps_err->u4_cur_frm
244 + ps_sei->u2_recovery_frame_cnt;
245 ps_sei->u1_exact_match_flag = ih264d_get_bit_h264(ps_bitstrm);
246 ps_sei->u1_broken_link_flag = ih264d_get_bit_h264(ps_bitstrm);
247 ps_sei->u1_changing_slice_grp_idc = ih264d_get_bits_h264(ps_bitstrm, 2);
248
249 return (OK);
250 }
251
252 /*****************************************************************************/
253 /* */
254 /* Function Name : ih264d_parse_mdcv */
255 /* */
256 /* Description : This function parses SEI message mdcv */
257 /* Inputs : ps_bitstrm Bitstream */
258 /* ps_dec Poniter decoder context */
259 /* ui4_payload_size pay load i4_size */
260 /* Globals : None */
261 /* Processing : */
262 /* Outputs : None */
263 /* Return : 0 for successfull parsing, else -1 */
264 /* */
265 /* Issues : */
266 /* */
267 /* Revision History: */
268 /* */
269 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
270 /* Draft */
271 /* */
272 /*****************************************************************************/
ih264d_parse_mdcv(dec_bit_stream_t * ps_bitstrm,dec_struct_t * ps_dec,UWORD32 ui4_payload_size)273 WORD32 ih264d_parse_mdcv(dec_bit_stream_t *ps_bitstrm,
274 dec_struct_t *ps_dec,
275 UWORD32 ui4_payload_size)
276 {
277 sei *ps_sei = ps_dec->ps_sei_parse;
278 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
279 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
280 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
281 UWORD32 u4_count;
282 UNUSED(ui4_payload_size);
283
284 if((ps_dec == NULL) || (ps_sei == NULL))
285 {
286 return NOT_OK;
287 }
288
289 ps_sei->u1_sei_mdcv_params_present_flag = 1;
290
291 /* display primaries x */
292 for(u4_count = 0; u4_count < NUM_SEI_MDCV_PRIMARIES; u4_count++)
293 {
294 ps_sei->s_sei_mdcv_params.au2_display_primaries_x[u4_count] =
295 (UWORD16)ih264d_get_bits_h264(ps_bitstrm, 16);
296
297 if((ps_sei->s_sei_mdcv_params.au2_display_primaries_x[u4_count] >
298 DISPLAY_PRIMARIES_X_UPPER_LIMIT) ||
299 (ps_sei->s_sei_mdcv_params.au2_display_primaries_x[u4_count] <
300 DISPLAY_PRIMARIES_X_LOWER_LIMIT) ||
301 ((ps_sei->s_sei_mdcv_params.au2_display_primaries_x[u4_count] %
302 DISPLAY_PRIMARIES_X_DIVISION_FACTOR) != 0))
303 {
304 ps_sei->u1_sei_mdcv_params_present_flag = 0;
305 return ERROR_INV_SEI_MDCV_PARAMS;
306 }
307
308 ps_sei->s_sei_mdcv_params.au2_display_primaries_y[u4_count] =
309 (UWORD16)ih264d_get_bits_h264(ps_bitstrm, 16);
310
311 if((ps_sei->s_sei_mdcv_params.au2_display_primaries_y[u4_count] >
312 DISPLAY_PRIMARIES_Y_UPPER_LIMIT) ||
313 (ps_sei->s_sei_mdcv_params.au2_display_primaries_y[u4_count] <
314 DISPLAY_PRIMARIES_Y_LOWER_LIMIT) ||
315 ((ps_sei->s_sei_mdcv_params.au2_display_primaries_y[u4_count] %
316 DISPLAY_PRIMARIES_Y_DIVISION_FACTOR) != 0))
317 {
318 ps_sei->u1_sei_mdcv_params_present_flag = 0;
319 return ERROR_INV_SEI_MDCV_PARAMS;
320 }
321 }
322
323 /* white point x */
324 ps_sei->s_sei_mdcv_params.u2_white_point_x = (UWORD16)ih264d_get_bits_h264(ps_bitstrm, 16);
325
326 if((ps_sei->s_sei_mdcv_params.u2_white_point_x > WHITE_POINT_X_UPPER_LIMIT) ||
327 (ps_sei->s_sei_mdcv_params.u2_white_point_x < WHITE_POINT_X_LOWER_LIMIT) ||
328 ((ps_sei->s_sei_mdcv_params.u2_white_point_x % WHITE_POINT_X_DIVISION_FACTOR) != 0))
329 {
330 ps_sei->u1_sei_mdcv_params_present_flag = 0;
331 return ERROR_INV_SEI_MDCV_PARAMS;
332 }
333 /* white point y */
334 ps_sei->s_sei_mdcv_params.u2_white_point_y = (UWORD16)ih264d_get_bits_h264(ps_bitstrm, 16);
335
336 if((ps_sei->s_sei_mdcv_params.u2_white_point_y > WHITE_POINT_Y_UPPER_LIMIT) ||
337 (ps_sei->s_sei_mdcv_params.u2_white_point_y < WHITE_POINT_Y_LOWER_LIMIT) ||
338 ((ps_sei->s_sei_mdcv_params.u2_white_point_y % WHITE_POINT_Y_DIVISION_FACTOR) != 0))
339 {
340 ps_sei->u1_sei_mdcv_params_present_flag = 0;
341 return ERROR_INV_SEI_MDCV_PARAMS;
342 }
343 /* max display mastering luminance */
344 ps_sei->s_sei_mdcv_params.u4_max_display_mastering_luminance =
345 (UWORD32)ih264d_get_bits_h264(ps_bitstrm, 32);
346
347 if((ps_sei->s_sei_mdcv_params.u4_max_display_mastering_luminance >
348 MAX_DISPLAY_MASTERING_LUMINANCE_UPPER_LIMIT) ||
349 (ps_sei->s_sei_mdcv_params.u4_max_display_mastering_luminance <
350 MAX_DISPLAY_MASTERING_LUMINANCE_LOWER_LIMIT) ||
351 ((ps_sei->s_sei_mdcv_params.u4_max_display_mastering_luminance %
352 MAX_DISPLAY_MASTERING_LUMINANCE_DIVISION_FACTOR) != 0))
353 {
354 ps_sei->u1_sei_mdcv_params_present_flag = 0;
355 return ERROR_INV_SEI_MDCV_PARAMS;
356 }
357 /* min display mastering luminance */
358 ps_sei->s_sei_mdcv_params.u4_min_display_mastering_luminance =
359 (UWORD32)ih264d_get_bits_h264(ps_bitstrm, 32);
360
361 if((ps_sei->s_sei_mdcv_params.u4_min_display_mastering_luminance >
362 MIN_DISPLAY_MASTERING_LUMINANCE_UPPER_LIMIT) ||
363 (ps_sei->s_sei_mdcv_params.u4_min_display_mastering_luminance <
364 MIN_DISPLAY_MASTERING_LUMINANCE_LOWER_LIMIT))
365 {
366 ps_sei->u1_sei_mdcv_params_present_flag = 0;
367 return ERROR_INV_SEI_MDCV_PARAMS;
368 }
369 if(ps_sei->s_sei_mdcv_params.u4_max_display_mastering_luminance <=
370 ps_sei->s_sei_mdcv_params.u4_min_display_mastering_luminance)
371 {
372 ps_sei->u1_sei_mdcv_params_present_flag = 0;
373 return ERROR_INV_SEI_MDCV_PARAMS;
374 }
375 return (OK);
376 }
377
378 /*****************************************************************************/
379 /* */
380 /* Function Name : ih264d_parse_cll */
381 /* */
382 /* Description : This function parses SEI message cll */
383 /* Inputs : ps_bitstrm Bitstream */
384 /* ps_dec Poniter decoder context */
385 /* ui4_payload_size pay load i4_size */
386 /* Globals : None */
387 /* Processing : */
388 /* Outputs : None */
389 /* Return : 0 for successfull parsing, else -1 */
390 /* */
391 /* Issues : */
392 /* */
393 /* Revision History: */
394 /* */
395 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
396 /* Draft */
397 /* */
398 /*****************************************************************************/
ih264d_parse_cll(dec_bit_stream_t * ps_bitstrm,dec_struct_t * ps_dec,UWORD32 ui4_payload_size)399 WORD32 ih264d_parse_cll(dec_bit_stream_t *ps_bitstrm,
400 dec_struct_t *ps_dec,
401 UWORD32 ui4_payload_size)
402 {
403 sei *ps_sei = ps_dec->ps_sei_parse;
404 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
405 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
406 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
407 UNUSED(ui4_payload_size);
408
409 if((ps_dec == NULL) || (ps_sei == NULL))
410 {
411 return NOT_OK;
412 }
413
414 ps_sei->u1_sei_cll_params_present_flag = 1;
415
416 ps_sei->s_sei_cll_params.u2_max_content_light_level =
417 (UWORD16)ih264d_get_bits_h264(ps_bitstrm, 16);
418 ps_sei->s_sei_cll_params.u2_max_pic_average_light_level =
419 (UWORD16)ih264d_get_bits_h264(ps_bitstrm, 16);
420 /*No any sanity checks done for CLL params*/
421
422 return (OK);
423 }
424
425 /*****************************************************************************/
426 /* */
427 /* Function Name : ih264d_parse_ave */
428 /* */
429 /* Description : This function parses SEI message ave */
430 /* Inputs : ps_bitstrm Bitstream */
431 /* ps_dec Poniter decoder context */
432 /* ui4_payload_size pay load i4_size */
433 /* Globals : None */
434 /* Processing : */
435 /* Outputs : None */
436 /* Return : 0 for successfull parsing, else -1 */
437 /* */
438 /* Issues : */
439 /* */
440 /* Revision History: */
441 /* */
442 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
443 /* Draft */
444 /* */
445 /*****************************************************************************/
ih264d_parse_ave(dec_bit_stream_t * ps_bitstrm,dec_struct_t * ps_dec,UWORD32 ui4_payload_size)446 WORD32 ih264d_parse_ave(dec_bit_stream_t *ps_bitstrm,
447 dec_struct_t *ps_dec,
448 UWORD32 ui4_payload_size)
449 {
450 sei *ps_sei = ps_dec->ps_sei_parse;
451 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
452 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
453 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
454 UNUSED(ui4_payload_size);
455
456 if((ps_dec == NULL) || (ps_sei == NULL))
457 {
458 return NOT_OK;
459 }
460
461 ps_sei->u1_sei_ave_params_present_flag = 1;
462
463 ps_sei->s_sei_ave_params.u4_ambient_illuminance = (UWORD32)ih264d_get_bits_h264(ps_bitstrm, 32);
464 if(0 == ps_sei->s_sei_ave_params.u4_ambient_illuminance)
465 {
466 ps_sei->u1_sei_ave_params_present_flag = 0;
467 return ERROR_INV_SEI_AVE_PARAMS;
468 }
469
470 ps_sei->s_sei_ave_params.u2_ambient_light_x = (UWORD16)ih264d_get_bits_h264(ps_bitstrm, 16);
471 if(ps_sei->s_sei_ave_params.u2_ambient_light_x > AMBIENT_LIGHT_X_UPPER_LIMIT)
472 {
473 ps_sei->u1_sei_ave_params_present_flag = 0;
474 return ERROR_INV_SEI_AVE_PARAMS;
475 }
476
477 ps_sei->s_sei_ave_params.u2_ambient_light_y = (UWORD16)ih264d_get_bits_h264(ps_bitstrm, 16);
478 if(ps_sei->s_sei_ave_params.u2_ambient_light_y > AMBIENT_LIGHT_Y_UPPER_LIMIT)
479 {
480 ps_sei->u1_sei_ave_params_present_flag = 0;
481 return ERROR_INV_SEI_AVE_PARAMS;
482 }
483 return (OK);
484 }
485
486 /*****************************************************************************/
487 /* */
488 /* Function Name : ih264d_parse_ccv */
489 /* */
490 /* Description : This function parses SEI message ccv */
491 /* Inputs : ps_bitstrm Bitstream */
492 /* ps_dec Poniter decoder context */
493 /* ui4_payload_size pay load i4_size */
494 /* Globals : None */
495 /* Processing : */
496 /* Outputs : None */
497 /* Return : 0 for successfull parsing, else -1 */
498 /* */
499 /* Issues : */
500 /* */
501 /* Revision History: */
502 /* */
503 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
504 /* Draft */
505 /* */
506 /*****************************************************************************/
ih264d_parse_ccv(dec_bit_stream_t * ps_bitstrm,dec_struct_t * ps_dec,UWORD32 ui4_payload_size)507 WORD32 ih264d_parse_ccv(dec_bit_stream_t *ps_bitstrm,
508 dec_struct_t *ps_dec,
509 UWORD32 ui4_payload_size)
510 {
511 sei *ps_sei = ps_dec->ps_sei_parse;
512 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
513 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
514 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
515 UWORD32 u4_count;
516 UNUSED(ui4_payload_size);
517
518 if((ps_dec == NULL) || (ps_sei == NULL))
519 {
520 return NOT_OK;
521 }
522
523 ps_sei->u1_sei_ccv_params_present_flag = 0;
524
525 ps_sei->s_sei_ccv_params.u1_ccv_cancel_flag = (UWORD8)ih264d_get_bit_h264(ps_bitstrm);
526
527 if(ps_sei->s_sei_ccv_params.u1_ccv_cancel_flag > 1)
528 {
529 return ERROR_INV_SEI_CCV_PARAMS;
530 }
531 if(0 == ps_sei->s_sei_ccv_params.u1_ccv_cancel_flag)
532 {
533 ps_sei->s_sei_ccv_params.u1_ccv_persistence_flag =
534 (UWORD8)ih264d_get_bit_h264(ps_bitstrm);
535 if(ps_sei->s_sei_ccv_params.u1_ccv_persistence_flag > 1)
536 {
537 return ERROR_INV_SEI_CCV_PARAMS;
538 }
539 ps_sei->s_sei_ccv_params.u1_ccv_primaries_present_flag =
540 (UWORD8)ih264d_get_bit_h264(ps_bitstrm);
541 if(ps_sei->s_sei_ccv_params.u1_ccv_primaries_present_flag > 1)
542 {
543 return ERROR_INV_SEI_CCV_PARAMS;
544 }
545 ps_sei->s_sei_ccv_params.u1_ccv_min_luminance_value_present_flag =
546 (UWORD8)ih264d_get_bit_h264(ps_bitstrm);
547 if(ps_sei->s_sei_ccv_params.u1_ccv_min_luminance_value_present_flag > 1)
548 {
549 return ERROR_INV_SEI_CCV_PARAMS;
550 }
551 ps_sei->s_sei_ccv_params.u1_ccv_max_luminance_value_present_flag =
552 (UWORD8)ih264d_get_bit_h264(ps_bitstrm);
553 if(ps_sei->s_sei_ccv_params.u1_ccv_max_luminance_value_present_flag > 1)
554 {
555 return ERROR_INV_SEI_CCV_PARAMS;
556 }
557 ps_sei->s_sei_ccv_params.u1_ccv_avg_luminance_value_present_flag =
558 (UWORD8)ih264d_get_bit_h264(ps_bitstrm);
559 if(ps_sei->s_sei_ccv_params.u1_ccv_avg_luminance_value_present_flag > 1)
560 {
561 return ERROR_INV_SEI_CCV_PARAMS;
562 }
563
564 if((ps_sei->s_sei_ccv_params.u1_ccv_primaries_present_flag == 0) &&
565 (ps_sei->s_sei_ccv_params.u1_ccv_min_luminance_value_present_flag == 0) &&
566 (ps_sei->s_sei_ccv_params.u1_ccv_max_luminance_value_present_flag == 0) &&
567 (ps_sei->s_sei_ccv_params.u1_ccv_avg_luminance_value_present_flag == 0))
568 {
569 return ERROR_INV_SEI_CCV_PARAMS;
570 }
571
572 ps_sei->s_sei_ccv_params.u1_ccv_reserved_zero_2bits =
573 (UWORD8)ih264d_get_bits_h264(ps_bitstrm, 2);
574 if((ps_sei->s_sei_ccv_params.u1_ccv_reserved_zero_2bits != 0))
575 {
576 return ERROR_INV_SEI_CCV_PARAMS;
577 }
578
579 /* ccv primaries */
580 if(1 == ps_sei->s_sei_ccv_params.u1_ccv_primaries_present_flag)
581 {
582 for(u4_count = 0; u4_count < NUM_SEI_CCV_PRIMARIES; u4_count++)
583 {
584 ps_sei->s_sei_ccv_params.ai4_ccv_primaries_x[u4_count] =
585 (WORD32)ih264d_get_bits_h264(ps_bitstrm, 32);
586 if((ps_sei->s_sei_ccv_params.ai4_ccv_primaries_x[u4_count] >
587 CCV_PRIMARIES_X_UPPER_LIMIT) ||
588 (ps_sei->s_sei_ccv_params.ai4_ccv_primaries_x[u4_count] <
589 CCV_PRIMARIES_X_LOWER_LIMIT))
590 {
591 return ERROR_INV_SEI_CCV_PARAMS;
592 }
593
594 ps_sei->s_sei_ccv_params.ai4_ccv_primaries_y[u4_count] =
595 (WORD32)ih264d_get_bits_h264(ps_bitstrm, 32);
596 if((ps_sei->s_sei_ccv_params.ai4_ccv_primaries_y[u4_count] >
597 CCV_PRIMARIES_Y_UPPER_LIMIT) ||
598 (ps_sei->s_sei_ccv_params.ai4_ccv_primaries_y[u4_count] <
599 CCV_PRIMARIES_Y_LOWER_LIMIT))
600 {
601 return ERROR_INV_SEI_CCV_PARAMS;
602 }
603 }
604 }
605
606 if(1 == ps_sei->s_sei_ccv_params.u1_ccv_min_luminance_value_present_flag)
607 {
608 ps_sei->s_sei_ccv_params.u4_ccv_min_luminance_value =
609 (UWORD32)ih264d_get_bits_h264(ps_bitstrm, 32);
610 }
611
612 if(1 == ps_sei->s_sei_ccv_params.u1_ccv_max_luminance_value_present_flag)
613 {
614 ps_sei->s_sei_ccv_params.u4_ccv_max_luminance_value =
615 (UWORD32)ih264d_get_bits_h264(ps_bitstrm, 32);
616 if((1 == ps_sei->s_sei_ccv_params.u1_ccv_min_luminance_value_present_flag) &&
617 (ps_sei->s_sei_ccv_params.u4_ccv_max_luminance_value <
618 ps_sei->s_sei_ccv_params.u4_ccv_min_luminance_value))
619 {
620 return ERROR_INV_SEI_CCV_PARAMS;
621 }
622 }
623 if(1 == ps_sei->s_sei_ccv_params.u1_ccv_avg_luminance_value_present_flag)
624 {
625 ps_sei->s_sei_ccv_params.u4_ccv_avg_luminance_value =
626 (UWORD32)ih264d_get_bits_h264(ps_bitstrm, 32);
627 if((1 == ps_sei->s_sei_ccv_params.u1_ccv_min_luminance_value_present_flag) &&
628 (ps_sei->s_sei_ccv_params.u4_ccv_avg_luminance_value <
629 ps_sei->s_sei_ccv_params.u4_ccv_min_luminance_value))
630 {
631 return ERROR_INV_SEI_CCV_PARAMS;
632 }
633 if((1 == ps_sei->s_sei_ccv_params.u1_ccv_max_luminance_value_present_flag) &&
634 (ps_sei->s_sei_ccv_params.u4_ccv_max_luminance_value <
635 ps_sei->s_sei_ccv_params.u4_ccv_avg_luminance_value))
636 {
637 return ERROR_INV_SEI_CCV_PARAMS;
638 }
639 }
640 }
641 ps_sei->u1_sei_ccv_params_present_flag = 1;
642 return (OK);
643 }
644
645 /*****************************************************************************/
646 /* */
647 /* Function Name : ih264d_parse_sii */
648 /* */
649 /* Description : This function parses SEI message sii */
650 /* Inputs : ps_bitstrm Bitstream */
651 /* ps_dec Poniter decoder context */
652 /* ui4_payload_size pay load i4_size */
653 /* Globals : None */
654 /* Processing : */
655 /* Outputs : None */
656 /* Return : 0 for successfull parsing, else -1 */
657 /* */
658 /* Issues : */
659 /* */
660 /* Revision History: */
661 /* */
662 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
663 /* Draft */
664 /* */
665 /*****************************************************************************/
ih264d_parse_sii(dec_bit_stream_t * ps_bitstrm,dec_struct_t * ps_dec,UWORD32 ui4_payload_size)666 WORD32 ih264d_parse_sii(dec_bit_stream_t *ps_bitstrm, dec_struct_t *ps_dec,
667 UWORD32 ui4_payload_size)
668 {
669 sei *ps_sei;
670 dec_err_status_t *ps_err;
671 int i;
672 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
673 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
674 UNUSED(ui4_payload_size);
675
676 if(ps_dec == NULL)
677 {
678 return NOT_OK;
679 }
680 ps_sei = ps_dec->ps_sei_parse;
681
682 if(ps_sei == NULL)
683 {
684 return NOT_OK;
685 }
686 ps_err = ps_dec->ps_dec_err_status;
687
688 ps_sei->u1_sei_sii_params_present_flag = 0;
689 memset(&ps_sei->s_sei_sii_params, 0, sizeof(ps_sei->s_sei_sii_params));
690
691 ps_sei->s_sei_sii_params.u4_sii_sub_layer_idx = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
692
693 if(0 == ps_sei->s_sei_sii_params.u4_sii_sub_layer_idx)
694 {
695 ps_sei->s_sei_sii_params.u1_shutter_interval_info_present_flag =
696 (UWORD8) ih264d_get_bit_h264(ps_bitstrm);
697
698 if(1 == ps_sei->s_sei_sii_params.u1_shutter_interval_info_present_flag)
699 {
700 ps_sei->s_sei_sii_params.u4_sii_time_scale =
701 (UWORD32) ih264d_get_bits_h264(ps_bitstrm, 32);
702
703 ps_sei->s_sei_sii_params.u1_fixed_shutter_interval_within_cvs_flag =
704 (UWORD8) ih264d_get_bit_h264(ps_bitstrm);
705
706 if(1 == ps_sei->s_sei_sii_params.u1_fixed_shutter_interval_within_cvs_flag)
707 {
708 ps_sei->s_sei_sii_params.u4_sii_num_units_in_shutter_interval =
709 (UWORD32) ih264d_get_bits_h264(ps_bitstrm, 32);
710 }
711 else
712 {
713 ps_sei->s_sei_sii_params.u1_sii_max_sub_layers_minus1 =
714 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 3);
715 for(i = 0; i <= ps_sei->s_sei_sii_params.u1_sii_max_sub_layers_minus1; i++)
716 {
717 ps_sei->s_sei_sii_params.au4_sub_layer_num_units_in_shutter_interval[i] =
718 (UWORD32) ih264d_get_bits_h264(ps_bitstrm, 32);
719 }
720 }
721 }
722 }
723
724 if((ps_sei->s_sei_sii_params.u4_sii_sub_layer_idx >
725 ps_sei->s_sei_sii_params.u1_sii_max_sub_layers_minus1) &&
726 (ps_sei->s_sei_sii_params.u1_fixed_shutter_interval_within_cvs_flag == 0))
727 {
728 return ERROR_INV_SEI_SII_PARAMS;
729 }
730
731 ps_sei->u1_sei_sii_params_present_flag = 1;
732 return (OK);
733 }
734
735 /*****************************************************************************/
736 /* */
737 /* Function Name : ih264d_parse_fgc */
738 /* */
739 /* Description : This function parses SEI message film grain charcaristics*/
740 /* Inputs : ps_bitstrm Bitstream */
741 /* ps_dec Poniter decoder context */
742 /* ui4_payload_size pay load i4_size */
743 /* Globals : None */
744 /* Processing : */
745 /* Outputs : None */
746 /* Return : 0 for successfull parsing, else -1 */
747 /* */
748 /* Issues : */
749 /* */
750 /* Revision History: */
751 /* */
752 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
753 /* Draft */
754 /* */
755 /*****************************************************************************/
ih264d_parse_fgc(dec_bit_stream_t * ps_bitstrm,dec_struct_t * ps_dec,UWORD32 ui4_payload_size)756 WORD32 ih264d_parse_fgc(dec_bit_stream_t *ps_bitstrm, dec_struct_t *ps_dec,
757 UWORD32 ui4_payload_size)
758 {
759 sei *ps_sei = ps_dec->ps_sei_parse;
760 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
761 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
762 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
763 UWORD32 u4_count;
764 WORD32 i4_luma_bitdepth, i4_chroma_bitdepth;
765 UWORD32 c, i, j;
766 UNUSED(ui4_payload_size);
767
768 if((ps_dec == NULL) || (ps_sei == NULL))
769 {
770 return NOT_OK;
771 }
772
773 ps_sei->u1_sei_fgc_params_present_flag = 0;
774
775 ps_sei->s_sei_fgc_params.u1_film_grain_characteristics_cancel_flag =
776 (UWORD8) ih264d_get_bit_h264(ps_bitstrm);
777
778 if(0 == ps_sei->s_sei_fgc_params.u1_film_grain_characteristics_cancel_flag)
779 {
780 ps_sei->s_sei_fgc_params.u1_film_grain_model_id =
781 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 2);
782 if(ps_sei->s_sei_fgc_params.u1_film_grain_model_id > 1)
783 {
784 return ERROR_INV_SEI_FGC_PARAMS;
785 }
786 ps_sei->s_sei_fgc_params.u1_separate_colour_description_present_flag =
787 (UWORD8) ih264d_get_bit_h264(ps_bitstrm);
788
789 if(ps_sei->s_sei_fgc_params.u1_separate_colour_description_present_flag)
790 {
791 ps_sei->s_sei_fgc_params.u1_film_grain_bit_depth_luma_minus8 =
792 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 3);
793
794 i4_luma_bitdepth = ps_sei->s_sei_fgc_params.u1_film_grain_bit_depth_luma_minus8 + 8;
795
796 ps_sei->s_sei_fgc_params.u1_film_grain_bit_depth_chroma_minus8 =
797 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 3);
798
799 i4_chroma_bitdepth = ps_sei->s_sei_fgc_params.u1_film_grain_bit_depth_chroma_minus8 + 8;
800
801 ps_sei->s_sei_fgc_params.u1_film_grain_full_range_flag =
802 (UWORD8) ih264d_get_bit_h264(ps_bitstrm);
803
804 ps_sei->s_sei_fgc_params.u1_film_grain_colour_primaries =
805 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 8);
806
807 ps_sei->s_sei_fgc_params.u1_film_grain_transfer_characteristics =
808 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 8);
809
810 ps_sei->s_sei_fgc_params.u1_film_grain_matrix_coefficients =
811 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 8);
812 }
813 else
814 {
815 if(ps_dec->ps_cur_sps == NULL)
816 {
817 return NOT_OK;
818 }
819 i4_luma_bitdepth = ps_dec->ps_cur_sps->i4_bit_depth_luma_minus8 + 8;
820 i4_chroma_bitdepth = ps_dec->ps_cur_sps->i4_bit_depth_chroma_minus8 + 8;
821 }
822 ps_sei->s_sei_fgc_params.u1_blending_mode_id = (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 2);
823
824 if(ps_sei->s_sei_fgc_params.u1_blending_mode_id > 1)
825 {
826 return ERROR_INV_SEI_FGC_PARAMS;
827 }
828
829 ps_sei->s_sei_fgc_params.u1_log2_scale_factor =
830 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 4);
831
832 for(c = 0; c < SEI_FGC_NUM_COLOUR_COMPONENTS; c++)
833 {
834 ps_sei->s_sei_fgc_params.au1_comp_model_present_flag[c] =
835 (UWORD8) ih264d_get_bit_h264(ps_bitstrm);
836 }
837
838 for(c = 0; c < SEI_FGC_NUM_COLOUR_COMPONENTS; c++)
839 {
840 if(ps_sei->s_sei_fgc_params.au1_comp_model_present_flag[c])
841 {
842 ps_sei->s_sei_fgc_params.au1_num_intensity_intervals_minus1[c] =
843 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 8);
844
845 ps_sei->s_sei_fgc_params.au1_num_model_values_minus1[c] =
846 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 3);
847
848 if(ps_sei->s_sei_fgc_params.au1_num_model_values_minus1[c] >
849 (SEI_FGC_MAX_NUM_MODEL_VALUES - 1))
850 {
851 return ERROR_INV_SEI_FGC_PARAMS;
852 }
853
854 for(i = 0; i <= ps_sei->s_sei_fgc_params.au1_num_intensity_intervals_minus1[c]; i++)
855 {
856 ps_sei->s_sei_fgc_params.au1_intensity_interval_lower_bound[c][i] =
857 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 8);
858
859 ps_sei->s_sei_fgc_params.au1_intensity_interval_upper_bound[c][i] =
860 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 8);
861
862 for(j = 0; j <= ps_sei->s_sei_fgc_params.au1_num_model_values_minus1[c]; j++)
863 {
864 ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] =
865 (WORD32) ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
866 if(0 == ps_sei->s_sei_fgc_params.u1_film_grain_model_id)
867 {
868 if((1 == j) || (2 == j))
869 {
870 if((ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] < 0) ||
871 (ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] > 16))
872 return ERROR_INV_SEI_FGC_PARAMS;
873 }
874 else if((3 == j) || (4 == j))
875 {
876 if((ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] < 0) ||
877 (ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] >
878 ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j - 2]))
879 return ERROR_INV_SEI_FGC_PARAMS;
880 }
881 else
882 {
883 WORD32 max_lim = (c == 0) ? (1 << i4_luma_bitdepth) - 1
884 : (1 << i4_chroma_bitdepth) - 1;
885
886 if((ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] < 0) ||
887 (ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] >
888 max_lim))
889 {
890 return ERROR_INV_SEI_FGC_PARAMS;
891 }
892 }
893 }
894 else
895 {
896 WORD32 max_lim = (c == 0) ? (1 << (i4_luma_bitdepth - 1))
897 : (1 << (i4_chroma_bitdepth - 1));
898
899 if((ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] <
900 -max_lim) ||
901 (ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] >= max_lim))
902 {
903 return ERROR_INV_SEI_FGC_PARAMS;
904 }
905 }
906 }
907 }
908 }
909 }
910
911 ps_sei->s_sei_fgc_params.u4_film_grain_characteristics_repetition_period =
912 (UWORD32) ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
913
914 if(ps_sei->s_sei_fgc_params.u4_film_grain_characteristics_repetition_period < 0 ||
915 ps_sei->s_sei_fgc_params.u4_film_grain_characteristics_repetition_period > 16384)
916 {
917 return ERROR_INV_SEI_FGC_PARAMS;
918 }
919
920 ps_sei->u1_sei_fgc_params_present_flag = 1;
921 }
922
923 return (OK);
924 }
925
926 /*****************************************************************************/
927 /* */
928 /* Function Name : ih264d_parse_sei_payload */
929 /* */
930 /* Description : This function parses SEI pay loads. Currently it's */
931 /* implemented partially. */
932 /* Inputs : ps_bitstrm Bitstream */
933 /* ui4_payload_type SEI payload type */
934 /* ui4_payload_size SEI payload i4_size */
935 /* Globals : None */
936 /* Processing : Parses SEI payloads units and stores the info */
937 /* Outputs : None */
938 /* Return : status for successful parsing, else -1 */
939 /* */
940 /* Issues : Not implemented fully */
941 /* */
942 /* Revision History: */
943 /* */
944 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
945 /* 06 05 2002 NS Draft */
946 /* */
947 /*****************************************************************************/
948
ih264d_parse_sei_payload(dec_bit_stream_t * ps_bitstrm,UWORD32 ui4_payload_type,UWORD32 ui4_payload_size,dec_struct_t * ps_dec)949 WORD32 ih264d_parse_sei_payload(dec_bit_stream_t *ps_bitstrm,
950 UWORD32 ui4_payload_type,
951 UWORD32 ui4_payload_size,
952 dec_struct_t *ps_dec)
953 {
954 sei *ps_sei;
955 WORD32 i4_status = 0;
956 ps_sei = (sei *)ps_dec->ps_sei_parse;
957
958 if(ui4_payload_size == 0)
959 return -1;
960 if(NULL == ps_bitstrm)
961 {
962 return NOT_OK;
963 }
964
965 switch(ui4_payload_type)
966 {
967 case SEI_BUF_PERIOD:
968
969 i4_status = ih264d_parse_buffering_period(&ps_sei->s_buf_period,
970 ps_bitstrm, ps_dec);
971 break;
972 case SEI_PIC_TIMING:
973 if(NULL == ps_dec->ps_cur_sps)
974 i4_status = ih264d_flush_bits_h264(ps_bitstrm, (ui4_payload_size << 3));
975 else
976 i4_status = ih264d_parse_pic_timing(ps_bitstrm, ps_dec,
977 ui4_payload_size);
978 break;
979 case SEI_RECOVERY_PT:
980 i4_status = ih264d_parse_recovery_point(ps_bitstrm, ps_dec,
981 ui4_payload_size);
982 break;
983 case SEI_MASTERING_DISP_COL_VOL:
984
985 i4_status = ih264d_parse_mdcv(ps_bitstrm, ps_dec,
986 ui4_payload_size);
987 break;
988 case SEI_CONTENT_LIGHT_LEVEL_DATA:
989
990 i4_status = ih264d_parse_cll(ps_bitstrm, ps_dec,
991 ui4_payload_size);
992 break;
993 case SEI_AMBIENT_VIEWING_ENVIRONMENT:
994
995 i4_status = ih264d_parse_ave(ps_bitstrm, ps_dec,
996 ui4_payload_size);
997 break;
998 case SEI_CONTENT_COLOR_VOLUME:
999
1000 i4_status = ih264d_parse_ccv(ps_bitstrm, ps_dec,
1001 ui4_payload_size);
1002 break;
1003 case SEI_SHUTTER_INTERVAL_INFO:
1004
1005 i4_status = ih264d_parse_sii(ps_bitstrm, ps_dec, ui4_payload_size);
1006 break;
1007
1008 case SEI_FILM_GRAIN_CHARACTERISTICS:
1009 i4_status = ih264d_parse_fgc(ps_bitstrm, ps_dec, ui4_payload_size);
1010
1011 break;
1012 default:
1013 i4_status = ih264d_flush_bits_h264(ps_bitstrm, (ui4_payload_size << 3));
1014 break;
1015 }
1016 return (i4_status);
1017 }
1018
1019 /*****************************************************************************/
1020 /* */
1021 /* Function Name : ih264d_parse_sei_message */
1022 /* */
1023 /* Description : This function is parses and decode SEI. Currently it's */
1024 /* not implemented fully. */
1025 /* Inputs : ps_dec Decoder parameters */
1026 /* ps_bitstrm Bitstream */
1027 /* Globals : None */
1028 /* Processing : Parses SEI NAL units and stores the info */
1029 /* Outputs : None */
1030 /* Returns : None */
1031 /* */
1032 /* Issues : Not implemented fully */
1033 /* */
1034 /* Revision History: */
1035 /* */
1036 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1037 /* 06 05 2002 NS Draft */
1038 /* */
1039 /*****************************************************************************/
1040
ih264d_parse_sei_message(dec_struct_t * ps_dec,dec_bit_stream_t * ps_bitstrm)1041 WORD32 ih264d_parse_sei_message(dec_struct_t *ps_dec,
1042 dec_bit_stream_t *ps_bitstrm)
1043 {
1044 UWORD32 ui4_payload_type, ui4_payload_size;
1045 UWORD32 u4_bits;
1046 WORD32 i4_status = 0;
1047
1048 do
1049 {
1050 ui4_payload_type = 0;
1051
1052 if(!CHECK_BITS_SUFFICIENT(ps_bitstrm, 8))
1053 {
1054 return ERROR_EOB_GETBITS_T;
1055 }
1056 u4_bits = ih264d_get_bits_h264(ps_bitstrm, 8);
1057 while(0xff == u4_bits && CHECK_BITS_SUFFICIENT(ps_bitstrm, 8))
1058 {
1059 u4_bits = ih264d_get_bits_h264(ps_bitstrm, 8);
1060 ui4_payload_type += 255;
1061 }
1062 ui4_payload_type += u4_bits;
1063
1064 ui4_payload_size = 0;
1065 if(!CHECK_BITS_SUFFICIENT(ps_bitstrm, 8))
1066 {
1067 return ERROR_EOB_GETBITS_T;
1068 }
1069 u4_bits = ih264d_get_bits_h264(ps_bitstrm, 8);
1070 while(0xff == u4_bits && CHECK_BITS_SUFFICIENT(ps_bitstrm, 8))
1071 {
1072 u4_bits = ih264d_get_bits_h264(ps_bitstrm, 8);
1073 ui4_payload_size += 255;
1074 }
1075 ui4_payload_size += u4_bits;
1076
1077 if(!CHECK_BITS_SUFFICIENT(ps_bitstrm, (ui4_payload_size << 3)))
1078 {
1079 return ERROR_EOB_GETBITS_T;
1080 }
1081 i4_status = ih264d_parse_sei_payload(ps_bitstrm, ui4_payload_type,
1082 ui4_payload_size, ps_dec);
1083 if(i4_status != OK)
1084 return i4_status;
1085
1086 if(ih264d_check_byte_aligned(ps_bitstrm) == 0)
1087 {
1088 u4_bits = ih264d_get_bit_h264(ps_bitstrm);
1089 if(0 == u4_bits)
1090 {
1091 H264_DEC_DEBUG_PRINT("\nError in parsing SEI message");
1092 }
1093 while(0 == ih264d_check_byte_aligned(ps_bitstrm)
1094 && CHECK_BITS_SUFFICIENT(ps_bitstrm, 1))
1095 {
1096 u4_bits = ih264d_get_bit_h264(ps_bitstrm);
1097 if(u4_bits)
1098 {
1099 H264_DEC_DEBUG_PRINT("\nError in parsing SEI message");
1100 }
1101 }
1102 }
1103 }
1104 while(MORE_RBSP_DATA(ps_bitstrm));
1105 return (i4_status);
1106 }
1107
1108 /*****************************************************************************/
1109 /* */
1110 /* Function Name : ih264d_export_sei_mdcv_params */
1111 /* */
1112 /* Description : This function populates SEI mdcv message in */
1113 /* output structure */
1114 /* Inputs : ps_sei_mdcv_op pointer to sei mdcv o\p struct */
1115 /* : ps_sei pointer to decoded sei params */
1116 /* Outputs : */
1117 /* Returns : returns 0 for success; -1 for failure */
1118 /* */
1119 /* Issues : none */
1120 /* */
1121 /* Revision History: */
1122 /* */
1123 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1124 /* */
1125 /* */
1126 /*****************************************************************************/
ih264d_export_sei_mdcv_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1127 WORD32 ih264d_export_sei_mdcv_params(ivd_sei_decode_op_t *ps_sei_decode_op,
1128 sei *ps_sei, sei *ps_sei_export)
1129 {
1130 if((ps_sei_export == NULL) || (ps_sei == NULL))
1131 {
1132 return NOT_OK;
1133 }
1134
1135 ps_sei_export->u1_sei_mdcv_params_present_flag = ps_sei->u1_sei_mdcv_params_present_flag;
1136 ps_sei_decode_op->u1_sei_mdcv_params_present_flag = ps_sei->u1_sei_mdcv_params_present_flag;
1137
1138 if(0 == ps_sei_export->u1_sei_mdcv_params_present_flag)
1139 {
1140 memset(&ps_sei_export->s_sei_mdcv_params, 0, sizeof(sei_mdcv_params_t));
1141 }
1142 else
1143 {
1144 memcpy(&ps_sei_export->s_sei_mdcv_params, &ps_sei->s_sei_mdcv_params,
1145 sizeof(sei_mdcv_params_t));
1146 }
1147
1148 return (OK);
1149 }
1150
1151 /*****************************************************************************/
1152 /* */
1153 /* Function Name : ih264d_export_sei_cll_params */
1154 /* */
1155 /* Description : This function populates SEI cll message in */
1156 /* output structure */
1157 /* Inputs : ps_sei_cll_op pointer to sei cll o\p struct */
1158 /* : ps_sei pointer to decoded sei params */
1159 /* Outputs : */
1160 /* Returns : returns 0 for success; -1 for failure */
1161 /* */
1162 /* Issues : none */
1163 /* */
1164 /* Revision History: */
1165 /* */
1166 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1167 /* */
1168 /* */
1169 /*****************************************************************************/
ih264d_export_sei_cll_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1170 WORD32 ih264d_export_sei_cll_params(ivd_sei_decode_op_t *ps_sei_decode_op,
1171 sei *ps_sei, sei *ps_sei_export)
1172 {
1173 if((ps_sei_export == NULL) || (ps_sei == NULL))
1174 {
1175 return NOT_OK;
1176 }
1177
1178 ps_sei_export->u1_sei_cll_params_present_flag = ps_sei->u1_sei_cll_params_present_flag;
1179 ps_sei_decode_op->u1_sei_cll_params_present_flag = ps_sei->u1_sei_cll_params_present_flag;
1180
1181 if(0 == ps_sei_export->u1_sei_cll_params_present_flag)
1182 {
1183 memset(&ps_sei_export->s_sei_cll_params, 0, sizeof(sei_cll_params_t));
1184 }
1185 else
1186 {
1187 memcpy(&ps_sei_export->s_sei_cll_params, &ps_sei->s_sei_cll_params,
1188 sizeof(sei_cll_params_t));
1189 }
1190 return (OK);
1191 }
1192
1193 /*****************************************************************************/
1194 /* */
1195 /* Function Name : ih264d_export_sei_ave_params */
1196 /* */
1197 /* Description : This function populates SEI ave message in */
1198 /* output structure */
1199 /* Inputs : ps_sei_ave_op pointer to sei ave o\p struct */
1200 /* : ps_sei pointer to decoded sei params */
1201 /* Outputs : */
1202 /* Returns : returns 0 for success; -1 for failure */
1203 /* */
1204 /* Issues : none */
1205 /* */
1206 /* Revision History: */
1207 /* */
1208 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1209 /* */
1210 /* */
1211 /*****************************************************************************/
ih264d_export_sei_ave_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1212 WORD32 ih264d_export_sei_ave_params(ivd_sei_decode_op_t *ps_sei_decode_op,
1213 sei *ps_sei, sei *ps_sei_export)
1214 {
1215 if((ps_sei_export == NULL) || (ps_sei == NULL))
1216 {
1217 return NOT_OK;
1218 }
1219
1220 ps_sei_export->u1_sei_ave_params_present_flag = ps_sei->u1_sei_ave_params_present_flag;
1221 ps_sei_decode_op->u1_sei_ave_params_present_flag = ps_sei->u1_sei_ave_params_present_flag;
1222
1223 if(0 == ps_sei_export->u1_sei_ave_params_present_flag)
1224 {
1225 memset(&ps_sei_export->s_sei_ave_params, 0, sizeof(sei_ave_params_t));
1226 }
1227 else
1228 {
1229 memcpy(&ps_sei_export->s_sei_ave_params, &ps_sei->s_sei_ave_params,
1230 sizeof(sei_ave_params_t));
1231 }
1232
1233 return (OK);
1234 }
1235
1236 /*****************************************************************************/
1237 /* */
1238 /* Function Name : ih264d_export_sei_ccv_params */
1239 /* */
1240 /* Description : This function populates SEI ccv message in */
1241 /* output structure */
1242 /* Inputs : ps_sei_ccv_op pointer to sei ccv o\p struct */
1243 /* : ps_sei pointer to decoded sei params */
1244 /* Outputs : */
1245 /* Returns : returns 0 for success; -1 for failure */
1246 /* */
1247 /* Issues : none */
1248 /* */
1249 /* Revision History: */
1250 /* */
1251 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1252 /* */
1253 /* */
1254 /*****************************************************************************/
ih264d_export_sei_ccv_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1255 WORD32 ih264d_export_sei_ccv_params(ivd_sei_decode_op_t *ps_sei_decode_op,
1256 sei *ps_sei, sei *ps_sei_export)
1257 {
1258 if((ps_sei_export == NULL) || (ps_sei == NULL))
1259 {
1260 return NOT_OK;
1261 }
1262
1263 ps_sei_export->u1_sei_ccv_params_present_flag = ps_sei->u1_sei_ccv_params_present_flag;
1264 ps_sei_decode_op->u1_sei_ccv_params_present_flag = ps_sei->u1_sei_ccv_params_present_flag;
1265
1266 if(0 == ps_sei_export->u1_sei_ccv_params_present_flag)
1267 {
1268 memset(&ps_sei_export->s_sei_ccv_params, 0, sizeof(sei_ccv_params_t));
1269 }
1270 else
1271 {
1272 memcpy(&ps_sei_export->s_sei_ccv_params, &ps_sei->s_sei_ccv_params,
1273 sizeof(sei_ccv_params_t));
1274 }
1275 return (OK);
1276 }
1277
1278 /*****************************************************************************/
1279 /* */
1280 /* Function Name : ih264d_export_sei_sii_params */
1281 /* */
1282 /* Description : This function populates SEI sii message in */
1283 /* output structure */
1284 /* Inputs : ps_sei_sii_op pointer to sei sii o\p struct */
1285 /* : ps_sei pointer to decoded sei params */
1286 /* Outputs : */
1287 /* Returns : returns 0 for success; -1 for failure */
1288 /* */
1289 /* Issues : none */
1290 /* */
1291 /* Revision History: */
1292 /* */
1293 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1294 /* */
1295 /* */
1296 /*****************************************************************************/
ih264d_export_sei_sii_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1297 WORD32 ih264d_export_sei_sii_params(ivd_sei_decode_op_t *ps_sei_decode_op, sei *ps_sei,
1298 sei *ps_sei_export)
1299 {
1300 if((ps_sei_export == NULL) || (ps_sei == NULL))
1301 {
1302 return NOT_OK;
1303 }
1304
1305 ps_sei_export->u1_sei_sii_params_present_flag = ps_sei->u1_sei_sii_params_present_flag;
1306 ps_sei_decode_op->u1_sei_sii_params_present_flag = ps_sei->u1_sei_sii_params_present_flag;
1307
1308 if(0 == ps_sei_export->u1_sei_sii_params_present_flag)
1309 {
1310 memset(&ps_sei_export->s_sei_sii_params, 0, sizeof(sei_sii_params_t));
1311 }
1312 else
1313 {
1314 memcpy(&ps_sei_export->s_sei_sii_params, &ps_sei->s_sei_sii_params,
1315 sizeof(sei_sii_params_t));
1316 }
1317 return (OK);
1318 }
1319
1320 /*****************************************************************************/
1321 /* */
1322 /* Function Name : ih264d_export_sei_fgc_params */
1323 /* */
1324 /* Description : This function populates SEI film grain params in */
1325 /* output structure */
1326 /* Inputs : ps_sei_fgc_op pointer to sei fgc o\p struct */
1327 /* : ps_sei pointer to decoded sei params */
1328 /* Outputs : */
1329 /* Returns : returns 0 for success; -1 for failure */
1330 /* */
1331 /* Issues : none */
1332 /* */
1333 /* Revision History: */
1334 /* */
1335 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1336 /* */
1337 /* */
1338 /*****************************************************************************/
ih264d_export_sei_fgc_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1339 WORD32 ih264d_export_sei_fgc_params(ivd_sei_decode_op_t *ps_sei_decode_op, sei *ps_sei,
1340 sei *ps_sei_export)
1341 {
1342 if((ps_sei_export == NULL) || (ps_sei == NULL))
1343 {
1344 return NOT_OK;
1345 }
1346
1347 ps_sei_export->u1_sei_fgc_params_present_flag = ps_sei->u1_sei_fgc_params_present_flag;
1348 ps_sei_decode_op->u1_sei_fgc_params_present_flag = ps_sei->u1_sei_fgc_params_present_flag;
1349
1350 if(0 == ps_sei_export->u1_sei_fgc_params_present_flag)
1351 {
1352 memset(&ps_sei_export->s_sei_fgc_params, 0, sizeof(sei_fgc_params_t));
1353 }
1354 else
1355 {
1356 memcpy(&ps_sei_export->s_sei_fgc_params, &ps_sei->s_sei_fgc_params,
1357 sizeof(sei_fgc_params_t));
1358 }
1359
1360 return (OK);
1361 }
1362