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 /* Although the fag end of both the NALU and the bitstream buffer */
857 /* is being parsed, not all FGC SEI symbols would have been */
858 /* decoded semantically. The code below detects this condition */
859 if((ps_bitstrm->u4_ofst + 8 + 8) >= ps_bitstrm->u4_max_ofst)
860 {
861 return ERROR_INV_SEI_FGC_PARAMS;
862 }
863
864 ps_sei->s_sei_fgc_params.au1_intensity_interval_lower_bound[c][i] =
865 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 8);
866
867 ps_sei->s_sei_fgc_params.au1_intensity_interval_upper_bound[c][i] =
868 (UWORD8) ih264d_get_bits_h264(ps_bitstrm, 8);
869
870 for(j = 0; j <= ps_sei->s_sei_fgc_params.au1_num_model_values_minus1[c]; j++)
871 {
872 ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] =
873 (WORD32) ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
874 if(0 == ps_sei->s_sei_fgc_params.u1_film_grain_model_id)
875 {
876 if((1 == j) || (2 == j))
877 {
878 if((ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] < 0) ||
879 (ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] > 16))
880 return ERROR_INV_SEI_FGC_PARAMS;
881 }
882 else if((3 == j) || (4 == j))
883 {
884 if((ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] < 0) ||
885 (ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] >
886 ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j - 2]))
887 return ERROR_INV_SEI_FGC_PARAMS;
888 }
889 else
890 {
891 WORD32 max_lim = (c == 0) ? (1 << i4_luma_bitdepth) - 1
892 : (1 << i4_chroma_bitdepth) - 1;
893
894 if((ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] < 0) ||
895 (ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] >
896 max_lim))
897 {
898 return ERROR_INV_SEI_FGC_PARAMS;
899 }
900 }
901 }
902 else
903 {
904 WORD32 max_lim = (c == 0) ? (1 << (i4_luma_bitdepth - 1))
905 : (1 << (i4_chroma_bitdepth - 1));
906
907 if((ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] <
908 -max_lim) ||
909 (ps_sei->s_sei_fgc_params.ai4_comp_model_value[c][i][j] >= max_lim))
910 {
911 return ERROR_INV_SEI_FGC_PARAMS;
912 }
913 }
914 }
915 }
916 }
917 }
918
919 ps_sei->s_sei_fgc_params.u4_film_grain_characteristics_repetition_period =
920 (UWORD32) ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
921
922 if(ps_sei->s_sei_fgc_params.u4_film_grain_characteristics_repetition_period < 0 ||
923 ps_sei->s_sei_fgc_params.u4_film_grain_characteristics_repetition_period > 16384)
924 {
925 return ERROR_INV_SEI_FGC_PARAMS;
926 }
927
928 ps_sei->u1_sei_fgc_params_present_flag = 1;
929 }
930
931 return (OK);
932 }
933
934 /*****************************************************************************/
935 /* */
936 /* Function Name : ih264d_parse_sei_payload */
937 /* */
938 /* Description : This function parses SEI pay loads. Currently it's */
939 /* implemented partially. */
940 /* Inputs : ps_bitstrm Bitstream */
941 /* ui4_payload_type SEI payload type */
942 /* ui4_payload_size SEI payload i4_size */
943 /* Globals : None */
944 /* Processing : Parses SEI payloads units and stores the info */
945 /* Outputs : None */
946 /* Return : status for successful parsing, else -1 */
947 /* */
948 /* Issues : Not implemented fully */
949 /* */
950 /* Revision History: */
951 /* */
952 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
953 /* 06 05 2002 NS Draft */
954 /* */
955 /*****************************************************************************/
956
ih264d_parse_sei_payload(dec_bit_stream_t * ps_bitstrm,UWORD32 ui4_payload_type,UWORD32 ui4_payload_size,dec_struct_t * ps_dec)957 WORD32 ih264d_parse_sei_payload(dec_bit_stream_t *ps_bitstrm,
958 UWORD32 ui4_payload_type,
959 UWORD32 ui4_payload_size,
960 dec_struct_t *ps_dec)
961 {
962 sei *ps_sei;
963 WORD32 i4_status = 0;
964 ps_sei = (sei *)ps_dec->ps_sei_parse;
965
966 if(ui4_payload_size == 0)
967 return -1;
968 if(NULL == ps_bitstrm)
969 {
970 return NOT_OK;
971 }
972
973 switch(ui4_payload_type)
974 {
975 case SEI_BUF_PERIOD:
976
977 i4_status = ih264d_parse_buffering_period(&ps_sei->s_buf_period,
978 ps_bitstrm, ps_dec);
979 break;
980 case SEI_PIC_TIMING:
981 if(NULL == ps_dec->ps_cur_sps)
982 i4_status = ih264d_flush_bits_h264(ps_bitstrm, (ui4_payload_size << 3));
983 else
984 i4_status = ih264d_parse_pic_timing(ps_bitstrm, ps_dec,
985 ui4_payload_size);
986 break;
987 case SEI_RECOVERY_PT:
988 i4_status = ih264d_parse_recovery_point(ps_bitstrm, ps_dec,
989 ui4_payload_size);
990 break;
991 case SEI_MASTERING_DISP_COL_VOL:
992
993 i4_status = ih264d_parse_mdcv(ps_bitstrm, ps_dec,
994 ui4_payload_size);
995 break;
996 case SEI_CONTENT_LIGHT_LEVEL_DATA:
997
998 i4_status = ih264d_parse_cll(ps_bitstrm, ps_dec,
999 ui4_payload_size);
1000 break;
1001 case SEI_AMBIENT_VIEWING_ENVIRONMENT:
1002
1003 i4_status = ih264d_parse_ave(ps_bitstrm, ps_dec,
1004 ui4_payload_size);
1005 break;
1006 case SEI_CONTENT_COLOR_VOLUME:
1007
1008 i4_status = ih264d_parse_ccv(ps_bitstrm, ps_dec,
1009 ui4_payload_size);
1010 break;
1011 case SEI_SHUTTER_INTERVAL_INFO:
1012
1013 i4_status = ih264d_parse_sii(ps_bitstrm, ps_dec, ui4_payload_size);
1014 break;
1015
1016 case SEI_FILM_GRAIN_CHARACTERISTICS:
1017 i4_status = ih264d_parse_fgc(ps_bitstrm, ps_dec, ui4_payload_size);
1018
1019 break;
1020 default:
1021 i4_status = ih264d_flush_bits_h264(ps_bitstrm, (ui4_payload_size << 3));
1022 break;
1023 }
1024 return (i4_status);
1025 }
1026
1027 /*****************************************************************************/
1028 /* */
1029 /* Function Name : ih264d_parse_sei_message */
1030 /* */
1031 /* Description : This function is parses and decode SEI. Currently it's */
1032 /* not implemented fully. */
1033 /* Inputs : ps_dec Decoder parameters */
1034 /* ps_bitstrm Bitstream */
1035 /* Globals : None */
1036 /* Processing : Parses SEI NAL units and stores the info */
1037 /* Outputs : None */
1038 /* Returns : None */
1039 /* */
1040 /* Issues : Not implemented fully */
1041 /* */
1042 /* Revision History: */
1043 /* */
1044 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1045 /* 06 05 2002 NS Draft */
1046 /* */
1047 /*****************************************************************************/
1048
ih264d_parse_sei_message(dec_struct_t * ps_dec,dec_bit_stream_t * ps_bitstrm)1049 WORD32 ih264d_parse_sei_message(dec_struct_t *ps_dec,
1050 dec_bit_stream_t *ps_bitstrm)
1051 {
1052 UWORD32 ui4_payload_type, ui4_payload_size;
1053 UWORD32 u4_bits;
1054 WORD32 i4_status = 0;
1055
1056 do
1057 {
1058 ui4_payload_type = 0;
1059
1060 if(!CHECK_BITS_SUFFICIENT(ps_bitstrm, 8))
1061 {
1062 return ERROR_EOB_GETBITS_T;
1063 }
1064 u4_bits = ih264d_get_bits_h264(ps_bitstrm, 8);
1065 while(0xff == u4_bits && CHECK_BITS_SUFFICIENT(ps_bitstrm, 8))
1066 {
1067 u4_bits = ih264d_get_bits_h264(ps_bitstrm, 8);
1068 ui4_payload_type += 255;
1069 }
1070 ui4_payload_type += u4_bits;
1071
1072 ui4_payload_size = 0;
1073 if(!CHECK_BITS_SUFFICIENT(ps_bitstrm, 8))
1074 {
1075 return ERROR_EOB_GETBITS_T;
1076 }
1077 u4_bits = ih264d_get_bits_h264(ps_bitstrm, 8);
1078 while(0xff == u4_bits && CHECK_BITS_SUFFICIENT(ps_bitstrm, 8))
1079 {
1080 u4_bits = ih264d_get_bits_h264(ps_bitstrm, 8);
1081 ui4_payload_size += 255;
1082 }
1083 ui4_payload_size += u4_bits;
1084
1085 if(!CHECK_BITS_SUFFICIENT(ps_bitstrm, (ui4_payload_size << 3)))
1086 {
1087 return ERROR_EOB_GETBITS_T;
1088 }
1089 i4_status = ih264d_parse_sei_payload(ps_bitstrm, ui4_payload_type,
1090 ui4_payload_size, ps_dec);
1091 if(i4_status != OK)
1092 return i4_status;
1093
1094 if(ih264d_check_byte_aligned(ps_bitstrm) == 0)
1095 {
1096 u4_bits = ih264d_get_bit_h264(ps_bitstrm);
1097 if(0 == u4_bits)
1098 {
1099 H264_DEC_DEBUG_PRINT("\nError in parsing SEI message");
1100 }
1101 while(0 == ih264d_check_byte_aligned(ps_bitstrm)
1102 && CHECK_BITS_SUFFICIENT(ps_bitstrm, 1))
1103 {
1104 u4_bits = ih264d_get_bit_h264(ps_bitstrm);
1105 if(u4_bits)
1106 {
1107 H264_DEC_DEBUG_PRINT("\nError in parsing SEI message");
1108 }
1109 }
1110 }
1111 }
1112 while(MORE_RBSP_DATA(ps_bitstrm));
1113 return (i4_status);
1114 }
1115
1116 /*****************************************************************************/
1117 /* */
1118 /* Function Name : ih264d_export_sei_mdcv_params */
1119 /* */
1120 /* Description : This function populates SEI mdcv message in */
1121 /* output structure */
1122 /* Inputs : ps_sei_mdcv_op pointer to sei mdcv o\p struct */
1123 /* : ps_sei pointer to decoded sei params */
1124 /* Outputs : */
1125 /* Returns : returns 0 for success; -1 for failure */
1126 /* */
1127 /* Issues : none */
1128 /* */
1129 /* Revision History: */
1130 /* */
1131 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1132 /* */
1133 /* */
1134 /*****************************************************************************/
ih264d_export_sei_mdcv_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1135 WORD32 ih264d_export_sei_mdcv_params(ivd_sei_decode_op_t *ps_sei_decode_op,
1136 sei *ps_sei, sei *ps_sei_export)
1137 {
1138 if((ps_sei_export == NULL) || (ps_sei == NULL))
1139 {
1140 return NOT_OK;
1141 }
1142
1143 ps_sei_export->u1_sei_mdcv_params_present_flag = ps_sei->u1_sei_mdcv_params_present_flag;
1144 ps_sei_decode_op->u1_sei_mdcv_params_present_flag = ps_sei->u1_sei_mdcv_params_present_flag;
1145
1146 if(0 == ps_sei_export->u1_sei_mdcv_params_present_flag)
1147 {
1148 memset(&ps_sei_export->s_sei_mdcv_params, 0, sizeof(sei_mdcv_params_t));
1149 }
1150 else
1151 {
1152 memcpy(&ps_sei_export->s_sei_mdcv_params, &ps_sei->s_sei_mdcv_params,
1153 sizeof(sei_mdcv_params_t));
1154 }
1155
1156 return (OK);
1157 }
1158
1159 /*****************************************************************************/
1160 /* */
1161 /* Function Name : ih264d_export_sei_cll_params */
1162 /* */
1163 /* Description : This function populates SEI cll message in */
1164 /* output structure */
1165 /* Inputs : ps_sei_cll_op pointer to sei cll o\p struct */
1166 /* : ps_sei pointer to decoded sei params */
1167 /* Outputs : */
1168 /* Returns : returns 0 for success; -1 for failure */
1169 /* */
1170 /* Issues : none */
1171 /* */
1172 /* Revision History: */
1173 /* */
1174 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1175 /* */
1176 /* */
1177 /*****************************************************************************/
ih264d_export_sei_cll_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1178 WORD32 ih264d_export_sei_cll_params(ivd_sei_decode_op_t *ps_sei_decode_op,
1179 sei *ps_sei, sei *ps_sei_export)
1180 {
1181 if((ps_sei_export == NULL) || (ps_sei == NULL))
1182 {
1183 return NOT_OK;
1184 }
1185
1186 ps_sei_export->u1_sei_cll_params_present_flag = ps_sei->u1_sei_cll_params_present_flag;
1187 ps_sei_decode_op->u1_sei_cll_params_present_flag = ps_sei->u1_sei_cll_params_present_flag;
1188
1189 if(0 == ps_sei_export->u1_sei_cll_params_present_flag)
1190 {
1191 memset(&ps_sei_export->s_sei_cll_params, 0, sizeof(sei_cll_params_t));
1192 }
1193 else
1194 {
1195 memcpy(&ps_sei_export->s_sei_cll_params, &ps_sei->s_sei_cll_params,
1196 sizeof(sei_cll_params_t));
1197 }
1198 return (OK);
1199 }
1200
1201 /*****************************************************************************/
1202 /* */
1203 /* Function Name : ih264d_export_sei_ave_params */
1204 /* */
1205 /* Description : This function populates SEI ave message in */
1206 /* output structure */
1207 /* Inputs : ps_sei_ave_op pointer to sei ave o\p struct */
1208 /* : ps_sei pointer to decoded sei params */
1209 /* Outputs : */
1210 /* Returns : returns 0 for success; -1 for failure */
1211 /* */
1212 /* Issues : none */
1213 /* */
1214 /* Revision History: */
1215 /* */
1216 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1217 /* */
1218 /* */
1219 /*****************************************************************************/
ih264d_export_sei_ave_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1220 WORD32 ih264d_export_sei_ave_params(ivd_sei_decode_op_t *ps_sei_decode_op,
1221 sei *ps_sei, sei *ps_sei_export)
1222 {
1223 if((ps_sei_export == NULL) || (ps_sei == NULL))
1224 {
1225 return NOT_OK;
1226 }
1227
1228 ps_sei_export->u1_sei_ave_params_present_flag = ps_sei->u1_sei_ave_params_present_flag;
1229 ps_sei_decode_op->u1_sei_ave_params_present_flag = ps_sei->u1_sei_ave_params_present_flag;
1230
1231 if(0 == ps_sei_export->u1_sei_ave_params_present_flag)
1232 {
1233 memset(&ps_sei_export->s_sei_ave_params, 0, sizeof(sei_ave_params_t));
1234 }
1235 else
1236 {
1237 memcpy(&ps_sei_export->s_sei_ave_params, &ps_sei->s_sei_ave_params,
1238 sizeof(sei_ave_params_t));
1239 }
1240
1241 return (OK);
1242 }
1243
1244 /*****************************************************************************/
1245 /* */
1246 /* Function Name : ih264d_export_sei_ccv_params */
1247 /* */
1248 /* Description : This function populates SEI ccv message in */
1249 /* output structure */
1250 /* Inputs : ps_sei_ccv_op pointer to sei ccv o\p struct */
1251 /* : ps_sei pointer to decoded sei params */
1252 /* Outputs : */
1253 /* Returns : returns 0 for success; -1 for failure */
1254 /* */
1255 /* Issues : none */
1256 /* */
1257 /* Revision History: */
1258 /* */
1259 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1260 /* */
1261 /* */
1262 /*****************************************************************************/
ih264d_export_sei_ccv_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1263 WORD32 ih264d_export_sei_ccv_params(ivd_sei_decode_op_t *ps_sei_decode_op,
1264 sei *ps_sei, sei *ps_sei_export)
1265 {
1266 if((ps_sei_export == NULL) || (ps_sei == NULL))
1267 {
1268 return NOT_OK;
1269 }
1270
1271 ps_sei_export->u1_sei_ccv_params_present_flag = ps_sei->u1_sei_ccv_params_present_flag;
1272 ps_sei_decode_op->u1_sei_ccv_params_present_flag = ps_sei->u1_sei_ccv_params_present_flag;
1273
1274 if(0 == ps_sei_export->u1_sei_ccv_params_present_flag)
1275 {
1276 memset(&ps_sei_export->s_sei_ccv_params, 0, sizeof(sei_ccv_params_t));
1277 }
1278 else
1279 {
1280 memcpy(&ps_sei_export->s_sei_ccv_params, &ps_sei->s_sei_ccv_params,
1281 sizeof(sei_ccv_params_t));
1282 }
1283 return (OK);
1284 }
1285
1286 /*****************************************************************************/
1287 /* */
1288 /* Function Name : ih264d_export_sei_sii_params */
1289 /* */
1290 /* Description : This function populates SEI sii message in */
1291 /* output structure */
1292 /* Inputs : ps_sei_sii_op pointer to sei sii o\p struct */
1293 /* : ps_sei pointer to decoded sei params */
1294 /* Outputs : */
1295 /* Returns : returns 0 for success; -1 for failure */
1296 /* */
1297 /* Issues : none */
1298 /* */
1299 /* Revision History: */
1300 /* */
1301 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1302 /* */
1303 /* */
1304 /*****************************************************************************/
ih264d_export_sei_sii_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1305 WORD32 ih264d_export_sei_sii_params(ivd_sei_decode_op_t *ps_sei_decode_op, sei *ps_sei,
1306 sei *ps_sei_export)
1307 {
1308 if((ps_sei_export == NULL) || (ps_sei == NULL))
1309 {
1310 return NOT_OK;
1311 }
1312
1313 ps_sei_export->u1_sei_sii_params_present_flag = ps_sei->u1_sei_sii_params_present_flag;
1314 ps_sei_decode_op->u1_sei_sii_params_present_flag = ps_sei->u1_sei_sii_params_present_flag;
1315
1316 if(0 == ps_sei_export->u1_sei_sii_params_present_flag)
1317 {
1318 memset(&ps_sei_export->s_sei_sii_params, 0, sizeof(sei_sii_params_t));
1319 }
1320 else
1321 {
1322 memcpy(&ps_sei_export->s_sei_sii_params, &ps_sei->s_sei_sii_params,
1323 sizeof(sei_sii_params_t));
1324 }
1325 return (OK);
1326 }
1327
1328 /*****************************************************************************/
1329 /* */
1330 /* Function Name : ih264d_export_sei_fgc_params */
1331 /* */
1332 /* Description : This function populates SEI film grain params in */
1333 /* output structure */
1334 /* Inputs : ps_sei_fgc_op pointer to sei fgc o\p struct */
1335 /* : ps_sei pointer to decoded sei params */
1336 /* Outputs : */
1337 /* Returns : returns 0 for success; -1 for failure */
1338 /* */
1339 /* Issues : none */
1340 /* */
1341 /* Revision History: */
1342 /* */
1343 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1344 /* */
1345 /* */
1346 /*****************************************************************************/
ih264d_export_sei_fgc_params(ivd_sei_decode_op_t * ps_sei_decode_op,sei * ps_sei,sei * ps_sei_export)1347 WORD32 ih264d_export_sei_fgc_params(ivd_sei_decode_op_t *ps_sei_decode_op, sei *ps_sei,
1348 sei *ps_sei_export)
1349 {
1350 if((ps_sei_export == NULL) || (ps_sei == NULL))
1351 {
1352 return NOT_OK;
1353 }
1354
1355 ps_sei_export->u1_sei_fgc_params_present_flag = ps_sei->u1_sei_fgc_params_present_flag;
1356 ps_sei_decode_op->u1_sei_fgc_params_present_flag = ps_sei->u1_sei_fgc_params_present_flag;
1357
1358 if(0 == ps_sei_export->u1_sei_fgc_params_present_flag)
1359 {
1360 memset(&ps_sei_export->s_sei_fgc_params, 0, sizeof(sei_fgc_params_t));
1361 }
1362 else
1363 {
1364 memcpy(&ps_sei_export->s_sei_fgc_params, &ps_sei->s_sei_fgc_params,
1365 sizeof(sei_fgc_params_t));
1366 }
1367
1368 return (OK);
1369 }
1370