1 /*
2 *
3 * Copyright 2015 Rockchip Electronics Co. LTD
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 #define MODULE_TAG "h264d_sei"
19
20 #include <stdio.h>
21 #include <string.h>
22
23 #include "h264d_global.h"
24 #include "h264d_sps.h"
25 #include "h264d_sei.h"
26 #include "h2645d_sei.h"
27
interpret_picture_timing_info(BitReadCtx_t * p_bitctx,H264_SEI_t * sei_msg,H264dVideoCtx_t * p_videoctx)28 static MPP_RET interpret_picture_timing_info(
29 BitReadCtx_t *p_bitctx,
30 H264_SEI_t *sei_msg,
31 H264dVideoCtx_t *p_videoctx)
32 {
33 RK_S32 cpb_removal_delay_length = 0;
34 RK_S32 dpb_output_delay_length = 0;
35 RK_S32 time_offset_length = 0;
36 RK_S32 cpb_dpb_delays_present_flag = 0;
37 RK_U32 i = 0;
38 H264_SEI_PIC_TIMING_t *pic_timing = NULL;
39 RK_U32 num_clock_ts[9] = {1, 1, 1, 2, 2, 3, 3, 2, 3};
40 struct h264_vui_t *vui_seq_parameters = NULL;
41 RK_U32 seq_parameter_set_id = sei_msg->seq_parameter_set_id;
42
43 if (seq_parameter_set_id >= MAXSPS || !p_videoctx->spsSet[seq_parameter_set_id]) {
44 H264D_ERR("seq_parameter_set_id %d may be invalid\n", seq_parameter_set_id);
45 goto __BITREAD_ERR;
46 }
47 vui_seq_parameters = &(p_videoctx->spsSet[sei_msg->seq_parameter_set_id]->vui_seq_parameters);
48 pic_timing = &(sei_msg->pic_timing);
49
50 if (vui_seq_parameters->nal_hrd_parameters_present_flag) {
51 cpb_removal_delay_length =
52 vui_seq_parameters->nal_hrd_parameters.cpb_removal_delay_length_minus1;
53 dpb_output_delay_length =
54 vui_seq_parameters->nal_hrd_parameters.dpb_output_delay_length_minus1;
55 time_offset_length =
56 vui_seq_parameters->nal_hrd_parameters.time_offset_length;
57 cpb_dpb_delays_present_flag = 1;
58 } else if (vui_seq_parameters->vcl_hrd_parameters_present_flag) {
59 cpb_removal_delay_length =
60 vui_seq_parameters->vcl_hrd_parameters.cpb_removal_delay_length_minus1;
61 dpb_output_delay_length =
62 vui_seq_parameters->vcl_hrd_parameters.dpb_output_delay_length_minus1;
63 time_offset_length =
64 vui_seq_parameters->vcl_hrd_parameters.time_offset_length;
65 cpb_dpb_delays_present_flag = 1;
66 }
67
68 if (cpb_dpb_delays_present_flag) {
69 READ_BITS(p_bitctx, cpb_removal_delay_length, &pic_timing->cpb_removal_delay);
70 READ_BITS(p_bitctx, dpb_output_delay_length, &pic_timing->dpb_output_delay);
71 }
72
73 if (vui_seq_parameters->pic_struct_present_flag) {
74 READ_BITS(p_bitctx, 4, &pic_timing->pic_struct);
75 if (pic_timing->pic_struct > 8 || pic_timing->pic_struct < 0) {
76 goto __BITREAD_ERR;
77 }
78
79 for (i = 0; i < num_clock_ts[pic_timing->pic_struct]; i++) {
80 READ_BITS(p_bitctx, 1, &pic_timing->clock_timestamp_flag[i]);
81
82 if (pic_timing->clock_timestamp_flag[i]) {
83 READ_BITS(p_bitctx, 2, &pic_timing->ct_type[i]);
84 READ_BITS(p_bitctx, 1, &pic_timing->nuit_field_based_flag[i]);
85
86 READ_BITS(p_bitctx, 5, &pic_timing->counting_type[i]);
87 if (pic_timing->counting_type[i] > 6
88 || pic_timing->counting_type[i] < 0) {
89 goto __BITREAD_ERR;
90 }
91
92 READ_BITS(p_bitctx, 1, &pic_timing->full_timestamp_flag[i]);
93 READ_BITS(p_bitctx, 1, &pic_timing->discontinuity_flag[i]);
94 READ_BITS(p_bitctx, 1, &pic_timing->cnt_dropped_flag[i]);
95
96 READ_BITS(p_bitctx, 8, &pic_timing->n_frames[i]);
97
98 if (pic_timing->full_timestamp_flag[i]) {
99 READ_BITS(p_bitctx, 6, &pic_timing->seconds_value[i]);
100 if (pic_timing->seconds_value[i] > 59) {
101 goto __BITREAD_ERR;
102 }
103
104 READ_BITS(p_bitctx, 6, &pic_timing->minutes_value[i]);
105 if (pic_timing->minutes_value[i] > 59) {
106 goto __BITREAD_ERR;
107 }
108
109 READ_BITS(p_bitctx, 5, &pic_timing->hours_value[i]);
110 if (pic_timing->hours_value[i] > 23) {
111 goto __BITREAD_ERR;
112 }
113 } else {
114 READ_BITS(p_bitctx, 1, &pic_timing->seconds_flag[i]);
115 if (pic_timing->seconds_flag[i]) {
116 READ_BITS(p_bitctx, 6, &pic_timing->seconds_value[i]);
117 if (pic_timing->seconds_value[i] > 59) {
118 goto __BITREAD_ERR;
119 }
120
121 READ_BITS(p_bitctx, 1, &pic_timing->minutes_flag[i]);
122 if (pic_timing->minutes_flag[i]) {
123 READ_BITS(p_bitctx, 6, &pic_timing->minutes_value[i]);
124 if (pic_timing->minutes_value[i] > 59) {
125 goto __BITREAD_ERR;
126 }
127
128 READ_BITS(p_bitctx, 1, &pic_timing->hours_flag[i]);
129 if (pic_timing->hours_flag[i]) {
130 READ_BITS(p_bitctx, 5, &pic_timing->hours_value[i]);
131 if (pic_timing->hours_value[i] > 23) {
132 goto __BITREAD_ERR;
133 }
134 }
135 }
136 }
137 }
138 if (time_offset_length) {
139 RK_S32 tmp;
140 READ_BITS(p_bitctx, time_offset_length, &tmp);
141 /* following "converts" timeOffsetLength-bit signed
142 * integer into i32 */
143 /*lint -save -e701 -e702 */
144 tmp <<= (32 - time_offset_length);
145 tmp >>= (32 - time_offset_length);
146 /*lint -restore */
147 pic_timing->time_offset[i] = tmp;
148 } else
149 pic_timing->time_offset[i] = 0;
150 }
151 }
152 }
153
154 return MPP_OK;
155 __BITREAD_ERR:
156 return MPP_ERR_STREAM;
157 }
158
interpret_buffering_period_info(BitReadCtx_t * p_bitctx,H264_SEI_t * sei_msg,H264dVideoCtx_t * p_videoctx)159 static MPP_RET interpret_buffering_period_info(
160 BitReadCtx_t *p_bitctx,
161 H264_SEI_t *sei_msg,
162 H264dVideoCtx_t *p_videoctx)
163 {
164 MPP_RET ret = MPP_ERR_UNKNOW;
165 RK_U32 i = 0;
166 RK_U32 seq_parameter_set_id = sei_msg->seq_parameter_set_id;
167 struct h264_vui_t *vui_seq_parameters = NULL;
168
169 READ_UE(p_bitctx, &seq_parameter_set_id);
170
171 if (seq_parameter_set_id >= MAXSPS || !p_videoctx->spsSet[seq_parameter_set_id]) {
172 H264D_ERR("seq_parameter_set_id %d may be invalid\n", seq_parameter_set_id);
173 goto __BITREAD_ERR;
174 }
175
176 sei_msg->seq_parameter_set_id = seq_parameter_set_id;
177 vui_seq_parameters = &(p_videoctx->spsSet[sei_msg->seq_parameter_set_id]->vui_seq_parameters);
178
179 if (vui_seq_parameters->nal_hrd_parameters_present_flag) {
180 for (i = 0; i < vui_seq_parameters->nal_hrd_parameters.cpb_cnt_minus1; i++) {
181 SKIP_BITS(p_bitctx,
182 vui_seq_parameters->nal_hrd_parameters.initial_cpb_removal_delay_length_minus1); //initial_cpb_removal_delay
183 SKIP_BITS(p_bitctx,
184 vui_seq_parameters->nal_hrd_parameters.initial_cpb_removal_delay_length_minus1); //initial_cpb_removal_delay_offset
185 }
186 }
187
188 if (vui_seq_parameters->vcl_hrd_parameters_present_flag) {
189 for (i = 0; i < vui_seq_parameters->vcl_hrd_parameters.cpb_cnt_minus1; i++) {
190 SKIP_BITS(p_bitctx,
191 vui_seq_parameters->vcl_hrd_parameters.initial_cpb_removal_delay_length_minus1); //initial_cpb_removal_delay
192 SKIP_BITS(p_bitctx,
193 vui_seq_parameters->vcl_hrd_parameters.initial_cpb_removal_delay_length_minus1); //initial_cpb_removal_delay_offset
194 }
195 }
196
197 return ret = MPP_OK;
198 __BITREAD_ERR:
199 ret = p_bitctx->ret;
200 return ret;
201
202 }
203
interpret_recovery_point(BitReadCtx_t * p_bitctx,H264dVideoCtx_t * p_videoctx)204 static MPP_RET interpret_recovery_point(BitReadCtx_t *p_bitctx, H264dVideoCtx_t *p_videoctx)
205 {
206 RK_S32 recovery_frame_cnt = 0;
207
208 READ_UE(p_bitctx, &recovery_frame_cnt);
209
210 if (recovery_frame_cnt >= (1 << 16) || recovery_frame_cnt < 0) {
211 H264D_DBG(H264D_DBG_SEI, "recovery_frame_cnt %d, is out of range %d",
212 recovery_frame_cnt, p_videoctx->max_frame_num);
213 return MPP_ERR_STREAM;
214 }
215
216 memset(&p_videoctx->recovery, 0, sizeof(RecoveryPoint));
217
218 p_videoctx->recovery.valid_flag = 1;
219 p_videoctx->recovery.recovery_frame_cnt = recovery_frame_cnt;
220 H264D_DBG(H264D_DBG_SEI, "Recovery point: frame_cnt %d", p_videoctx->recovery.recovery_frame_cnt);
221 return MPP_OK;
222 __BITREAD_ERR:
223 return p_bitctx->ret;
224 }
225
226 /*!
227 ***********************************************************************
228 * \brief
229 * parse SEI information
230 ***********************************************************************
231 */
232 //extern "C"
process_sei(H264_SLICE_t * currSlice)233 MPP_RET process_sei(H264_SLICE_t *currSlice)
234 {
235 RK_S32 tmp_byte = 0;
236 MPP_RET ret = MPP_ERR_UNKNOW;
237 H264_SEI_t *sei_msg = NULL;
238 BitReadCtx_t *p_bitctx = &currSlice->p_Cur->bitctx;
239 BitReadCtx_t payload_bitctx;
240 RK_S32 i = 0;
241
242 if (!currSlice->p_Cur->sei)
243 currSlice->p_Cur->sei = mpp_calloc(H264_SEI_t, 1);
244
245 sei_msg = currSlice->p_Cur->sei;
246 sei_msg->mvc_scalable_nesting_flag = 0; //init to false
247 sei_msg->p_Dec = currSlice->p_Dec;
248 do {
249 tmp_byte = 0xFF;
250 sei_msg->type = 0;
251 while (tmp_byte == 0xFF) {
252 READ_BITS(p_bitctx, 8, &tmp_byte);
253 sei_msg->type += tmp_byte;
254 }
255
256 tmp_byte = 0xFF;
257 sei_msg->payload_size = 0;
258 while (tmp_byte == 0xFF) {
259 READ_BITS(p_bitctx, 8, &tmp_byte);
260 sei_msg->payload_size += tmp_byte;
261 }
262
263 H264D_DBG(H264D_DBG_SEI, "SEI type %d, payload size: %d\n", sei_msg->type, sei_msg->payload_size);
264
265 memset(&payload_bitctx, 0, sizeof(payload_bitctx));
266 mpp_set_bitread_ctx(&payload_bitctx, p_bitctx->data_, sei_msg->payload_size);
267
268 switch (sei_msg->type) {
269 case H264_SEI_BUFFERING_PERIOD:
270 FUN_CHECK(ret = interpret_buffering_period_info(&payload_bitctx, sei_msg, currSlice->p_Vid));
271 break;
272 case H264_SEI_PIC_TIMING:
273 FUN_CHECK(interpret_picture_timing_info(&payload_bitctx, sei_msg, currSlice->p_Vid));
274 break;
275 case H264_SEI_USER_DATA_UNREGISTERED:
276 FUN_CHECK(check_encoder_sei_info(&payload_bitctx, sei_msg->payload_size, &currSlice->p_Vid->deny_flag));
277
278 if (currSlice->p_Vid->deny_flag)
279 H264D_DBG(H264D_DBG_SEI, "Bitstream is encoded by special encoder.");
280 break;
281 case H264_SEI_RECOVERY_POINT:
282 FUN_CHECK(interpret_recovery_point(&payload_bitctx, currSlice->p_Vid));
283 break;
284 default:
285 H264D_DBG(H264D_DBG_SEI, "Skip parsing SEI type %d\n", sei_msg->type);
286 break;
287 }
288
289 H264D_DBG(H264D_DBG_SEI, "After parsing SEI %d, bits left int cur byte %d, bits_used %d, bytes left %d",
290 sei_msg->type, payload_bitctx.num_remaining_bits_in_curr_byte_, payload_bitctx.used_bits,
291 payload_bitctx.bytes_left_);
292
293 for (i = 0; i < sei_msg->payload_size; i++)
294 SKIP_BITS(p_bitctx, 8);
295 } while (mpp_has_more_rbsp_data(p_bitctx)); // more_rbsp_data() msg[offset] != 0x80
296
297 return ret = MPP_OK;
298 __BITREAD_ERR:
299 __FAILED:
300 return ret;
301 }
302