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_parse"
19
20 #include <string.h>
21 #include <stdlib.h>
22
23 #include "mpp_mem.h"
24 #include "mpp_packet_impl.h"
25 #include "hal_dec_task.h"
26
27 #include "h264d_global.h"
28 #include "h264d_parse.h"
29 #include "h264d_slice.h"
30 #include "h264d_sps.h"
31 #include "h264d_pps.h"
32 #include "h264d_sei.h"
33 #include "h264d_init.h"
34 #include "h264d_fill.h"
35
36 #define HEAD_SYNTAX_MAX_SIZE (12800)
37 #define NALU_TYPE_NORMAL_LENGTH (1)
38 #define NALU_TYPE_EXT_LENGTH (5)
39
40 static const RK_U8 g_start_precode[3] = {0, 0, 1};
41
42 typedef struct h264d_nalu_head_t {
43 RK_U16 is_frame_end;
44 RK_U16 nalu_type;
45 RK_U32 sodb_len;
46 } H264dNaluHead_t;
47
48
U16_AT(const RK_U8 * ptr)49 static RK_U16 U16_AT(const RK_U8 *ptr)
50 {
51 return ptr[0] << 8 | ptr[1];
52 }
53
U32_AT(const RK_U8 * ptr)54 static RK_U32 U32_AT(const RK_U8 *ptr)
55 {
56 return ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
57 }
58
parse_nal_size(RK_U8 nal_size,RK_U8 * data)59 static RK_U32 parse_nal_size(RK_U8 nal_size, RK_U8 *data)
60 {
61 switch (nal_size) {
62 case 1:
63 return *data;
64 case 2:
65 return U16_AT(data);
66 case 3:
67 return ((RK_U64)data[0] << 16) | U16_AT(&data[1]);
68 case 4:
69 return U32_AT(data);
70 }
71 return 0;
72 }
73
reset_slice(H264dVideoCtx_t * p_Vid)74 static void reset_slice(H264dVideoCtx_t *p_Vid)
75 {
76 RK_U32 i = 0, j = 0;
77 H264_SLICE_t *currSlice = &p_Vid->p_Cur->slice;
78
79 memset(currSlice, 0, sizeof(H264_SLICE_t));
80 //-- re-init parameters
81 currSlice->view_id = -1;
82 currSlice->p_Vid = p_Vid;
83 currSlice->p_Dec = p_Vid->p_Dec;
84 currSlice->p_Cur = p_Vid->p_Cur;
85 currSlice->p_Inp = p_Vid->p_Inp;
86 currSlice->active_sps = p_Vid->active_sps;
87 currSlice->active_pps = p_Vid->active_pps;
88 currSlice->active_subsps = p_Vid->active_subsps;
89 //--- reset listP listB
90 for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
91 currSlice->listP[i] = p_Vid->p_Cur->listP[i];
92 currSlice->listB[i] = p_Vid->p_Cur->listB[i];
93 for (j = 0; j < MAX_LIST_SIZE; j++) {
94 currSlice->listP[i][j] = NULL;
95 currSlice->listB[i][j] = NULL;
96 }
97 currSlice->listXsizeP[i] = 0;
98 currSlice->listXsizeB[i] = 0;
99 }
100 reset_cur_slice(p_Vid->p_Cur, currSlice);
101 }
102
realloc_buffer(RK_U8 ** buf,RK_U32 * max_size,RK_U32 add_size)103 static MPP_RET realloc_buffer(RK_U8 **buf, RK_U32 *max_size, RK_U32 add_size)
104 {
105 MPP_RET ret = MPP_ERR_UNKNOW;
106 if ((*buf) == NULL) {
107 H264D_ERR("[realloc_buffer] pointer is null, %p \n", (*buf));
108 ret = MPP_ERR_MALLOC;
109 goto __FAILED;
110 }
111
112 add_size = MPP_ALIGN(add_size, 16);
113
114 (*buf) = mpp_realloc((*buf), RK_U8, ((*max_size) + add_size));
115 if ((*buf) == NULL) {
116 H264D_ERR("[realloc_buffer] ERROR: max_size=%d, add_size=%d \n", (*max_size), add_size);
117 ret = MPP_ERR_MALLOC;
118 goto __FAILED;
119 }
120 (*max_size) += add_size;
121
122 return ret = MPP_OK;
123 __FAILED:
124 return ret;
125 }
126
reset_nalu(H264dCurStream_t * p_strm)127 static void reset_nalu(H264dCurStream_t *p_strm)
128 {
129 if (p_strm->endcode_found) {
130 p_strm->startcode_found = p_strm->endcode_found;
131 p_strm->nalu_len = 0;
132 p_strm->nalu_type = H264_NALU_TYPE_NULL;
133 p_strm->endcode_found = 0;
134 }
135 }
136
find_prefix_code(RK_U8 * p_data,H264dCurStream_t * p_strm)137 static void find_prefix_code(RK_U8 *p_data, H264dCurStream_t *p_strm)
138 {
139 (void)p_data;
140
141 if ((p_strm->prefixdata & 0x00FFFFFF) == 0x00000001) {
142 if (p_strm->startcode_found) {
143 p_strm->endcode_found = 1;
144 } else {
145 p_strm->startcode_found = 1;
146 }
147 }
148 }
149
parser_nalu_header(H264_SLICE_t * currSlice)150 static MPP_RET parser_nalu_header(H264_SLICE_t *currSlice)
151 {
152 MPP_RET ret = MPP_ERR_UNKNOW;
153
154 H264dCurCtx_t *p_Cur = currSlice->p_Cur;
155 BitReadCtx_t *p_bitctx = &p_Cur->bitctx;
156 H264_Nalu_t *cur_nal = &p_Cur->nalu;
157
158 mpp_set_bitread_ctx(p_bitctx, cur_nal->sodb_buf, cur_nal->sodb_len);
159 mpp_set_bitread_pseudo_code_type(p_bitctx, PSEUDO_CODE_H264_H265);
160
161 READ_BITS(p_bitctx, 1, &cur_nal->forbidden_bit);
162 ASSERT(cur_nal->forbidden_bit == 0);
163 {
164 RK_S32 *ptmp = NULL;
165 ptmp = (RK_S32 *)&cur_nal->nal_reference_idc;
166 READ_BITS(p_bitctx, 2, ptmp); //!< nal_ref_idc
167 ptmp = (RK_S32 *)&cur_nal->nalu_type;
168 READ_BITS(p_bitctx, 5, ptmp); //!< nalu_type
169 }
170 cur_nal->ualu_header_bytes = 1;
171 currSlice->svc_extension_flag = -1; //!< initialize to -1
172 if (cur_nal->nalu_type == H264_NALU_TYPE_PREFIX
173 || cur_nal->nalu_type == H264_NALU_TYPE_SLC_EXT) {
174 READ_ONEBIT(p_bitctx, &currSlice->svc_extension_flag);
175 if (currSlice->svc_extension_flag) {
176 currSlice->svcExt.valid = 1;
177 p_Cur->p_Dec->svc_valid = 1;
178 READ_ONEBIT(p_bitctx, &currSlice->svcExt.idr_flag);
179 READ_BITS(p_bitctx, 6, &currSlice->svcExt.priority_id);
180 READ_ONEBIT(p_bitctx, &currSlice->svcExt.no_inter_layer_pred_flag);
181 READ_BITS(p_bitctx, 3, &currSlice->svcExt.dependency_id);
182 READ_BITS(p_bitctx, 4, &currSlice->svcExt.quality_id);
183 READ_BITS(p_bitctx, 3, &currSlice->svcExt.temporal_id);
184 READ_ONEBIT(p_bitctx, &currSlice->svcExt.use_ref_base_pic_flag);
185 READ_ONEBIT(p_bitctx, &currSlice->svcExt.discardable_flag);
186 READ_ONEBIT(p_bitctx, &currSlice->svcExt.output_flag);
187
188 ASSERT(currSlice->svcExt.no_inter_layer_pred_flag == 1);
189 ASSERT(currSlice->svcExt.dependency_id == 0);
190 ASSERT(currSlice->svcExt.quality_id == 0);
191 ASSERT(currSlice->svcExt.use_ref_base_pic_flag == 0);
192 } else { //!< MVC
193 currSlice->mvcExt.valid = 1;
194 p_Cur->p_Dec->mvc_valid = 1;
195 READ_ONEBIT(p_bitctx, &currSlice->mvcExt.non_idr_flag);
196 READ_BITS(p_bitctx, 6, &currSlice->mvcExt.priority_id);
197 READ_BITS(p_bitctx, 10, &currSlice->mvcExt.view_id);
198 READ_BITS(p_bitctx, 3, &currSlice->mvcExt.temporal_id);
199 READ_ONEBIT(p_bitctx, &currSlice->mvcExt.anchor_pic_flag);
200 READ_ONEBIT(p_bitctx, &currSlice->mvcExt.inter_view_flag);
201 READ_ONEBIT(p_bitctx, &currSlice->mvcExt.reserved_one_bit);
202 ASSERT(currSlice->mvcExt.reserved_one_bit == 1);
203 currSlice->mvcExt.iPrefixNALU = (cur_nal->nalu_type == H264_NALU_TYPE_PREFIX) ? 1 : 0;
204 //!< combine H264_NALU_TYPE_SLC_EXT into H264_NALU_TYPE_SLICE
205 if (cur_nal->nalu_type == H264_NALU_TYPE_SLC_EXT) {
206 cur_nal->nalu_type = H264_NALU_TYPE_SLICE;
207 }
208 }
209 cur_nal->ualu_header_bytes += 3;
210 }
211 /* Move forward the bitread offset */
212 mpp_set_bitread_ctx(p_bitctx,
213 cur_nal->sodb_buf + cur_nal->ualu_header_bytes,
214 cur_nal->sodb_len - cur_nal->ualu_header_bytes);
215 mpp_set_bitread_pseudo_code_type(p_bitctx, PSEUDO_CODE_H264_H265);
216 p_Cur->p_Dec->nalu_ret = StartofNalu;
217
218 return ret = MPP_OK;
219 __BITREAD_ERR:
220 p_Cur->p_Dec->nalu_ret = ReadNaluError;
221 return ret = p_bitctx->ret;
222 }
223
parser_one_nalu(H264_SLICE_t * currSlice)224 static MPP_RET parser_one_nalu(H264_SLICE_t *currSlice)
225 {
226 MPP_RET ret = MPP_ERR_UNKNOW;
227
228 FUN_CHECK(ret = parser_nalu_header(currSlice));
229
230 if (currSlice->p_Vid->deny_flag &&
231 currSlice->p_Cur->nalu.nalu_type != H264_NALU_TYPE_SPS) {
232 currSlice->p_Dec->nalu_ret = NaluNotSupport;
233 return MPP_OK;
234 }
235
236 //!< nalu_parse
237 switch (currSlice->p_Cur->nalu.nalu_type) {
238 case H264_NALU_TYPE_SLICE:
239 case H264_NALU_TYPE_IDR:
240 H264D_DBG(H264D_DBG_PARSE_NALU, "nalu_type=SLICE.");
241 FUN_CHECK(ret = process_slice(currSlice));
242 currSlice->p_Dec->nalu_ret = StartOfPicture;
243 if (currSlice->layer_id && !currSlice->p_Dec->cfg->base.enable_mvc)
244 currSlice->p_Dec->nalu_ret = MvcDisAble;
245 break;
246 case H264_NALU_TYPE_SPS:
247 H264D_DBG(H264D_DBG_PARSE_NALU, "nalu_type=SPS");
248 FUN_CHECK(ret = process_sps(currSlice));
249 currSlice->p_Dec->nalu_ret = NALU_SPS;
250 currSlice->p_Vid->deny_flag = 0;
251 break;
252 case H264_NALU_TYPE_PPS:
253 H264D_DBG(H264D_DBG_PARSE_NALU, "nalu_type=PPS");
254 if (process_pps(currSlice) < 0)
255 H264D_WARNNING("Function error(%d).\n", __LINE__);
256 currSlice->p_Dec->nalu_ret = NALU_PPS;
257 break;
258 case H264_NALU_TYPE_SUB_SPS:
259 H264D_DBG(H264D_DBG_PARSE_NALU, "nalu_type=SUB_SPS");
260 if (process_subsps(currSlice) < 0)
261 H264D_WARNNING("Function error(%d).\n", __LINE__);
262 currSlice->p_Dec->nalu_ret = NALU_SubSPS;
263 break;
264 case H264_NALU_TYPE_SEI:
265 H264D_DBG(H264D_DBG_PARSE_NALU, "nalu_type=SEI");
266 ret = process_sei(currSlice);
267 currSlice->p_Dec->nalu_ret = NALU_SEI;
268 break;
269 case H264_NALU_TYPE_SLC_EXT:
270 H264D_DBG(H264D_DBG_PARSE_NALU, "Found H264_NALU_TYPE_SLC_EXT.");
271 currSlice->p_Dec->nalu_ret = SkipNALU;
272 break;
273 case H264_NALU_TYPE_PREFIX:
274 H264D_DBG(H264D_DBG_PARSE_NALU, "Found H264_NALU_TYPE_PREFIX.");
275 process_prefix(currSlice);
276 break;
277 case H264_NALU_TYPE_AUD:
278 H264D_DBG(H264D_DBG_PARSE_NALU, "Found H264_NALU_TYPE_AUD.");
279 currSlice->p_Dec->nalu_ret = SkipNALU;
280 break;
281 case H264_NALU_TYPE_EOSEQ:
282 H264D_DBG(H264D_DBG_PARSE_NALU, "Found H264_NALU_TYPE_EOSEQ.");
283 currSlice->p_Dec->nalu_ret = SkipNALU;
284 break;
285 case H264_NALU_TYPE_EOSTREAM:
286 H264D_DBG(H264D_DBG_PARSE_NALU, "Found H264_NALU_TYPE_EOSTREAM.");
287 currSlice->p_Dec->nalu_ret = SkipNALU;
288 break;
289 case H264_NALU_TYPE_FILL:
290 H264D_DBG(H264D_DBG_PARSE_NALU, "Found H264_NALU_TYPE_FILL.");
291 currSlice->p_Dec->nalu_ret = SkipNALU;
292 break;
293 case H264_NALU_TYPE_VDRD:
294 H264D_DBG(H264D_DBG_PARSE_NALU, "Found H264_NALU_TYPE_VDRD.");
295 currSlice->p_Dec->nalu_ret = SkipNALU;
296 break;
297 case H264_NALU_TYPE_DPA:
298 case H264_NALU_TYPE_DPB:
299 case H264_NALU_TYPE_DPC:
300 H264D_DBG(H264D_DBG_PARSE_NALU,
301 "Found H264_NALU_TYPE_DPA DPB DPC, and not supported.");
302 currSlice->p_Dec->nalu_ret = NaluNotSupport;
303 break;
304 default:
305 currSlice->p_Dec->nalu_ret = SkipNALU;
306 break;
307 }
308
309 return ret = MPP_OK;
310 __FAILED:
311 H264D_DBG(H264D_DBG_PARSE_NALU, "parser_one_nalu error.");
312 currSlice->p_Dec->nalu_ret = ReadNaluError;
313 return ret;
314 }
315
add_empty_nalu(H264dCurStream_t * p_strm)316 static MPP_RET add_empty_nalu(H264dCurStream_t *p_strm)
317 {
318 MPP_RET ret = MPP_ERR_UNKNOW;
319 RK_U8 *p_des = NULL;
320 RK_U32 add_size = sizeof(H264dNaluHead_t);
321
322 if ((p_strm->head_offset + add_size) >= p_strm->head_max_size) {
323 FUN_CHECK(ret = realloc_buffer(&p_strm->head_buf, &p_strm->head_max_size, HEAD_BUF_ADD_SIZE));
324 }
325 p_des = &p_strm->head_buf[p_strm->head_offset];
326 ((H264dNaluHead_t *)p_des)->is_frame_end = 1;
327 ((H264dNaluHead_t *)p_des)->nalu_type = 0;
328 ((H264dNaluHead_t *)p_des)->sodb_len = 0;
329 p_strm->head_offset += add_size;
330
331 return ret = MPP_OK;
332 __FAILED:
333 return ret;
334 }
335
store_cur_nalu(H264dCurCtx_t * p_Cur,H264dCurStream_t * p_strm,H264dDxvaCtx_t * dxva_ctx)336 static MPP_RET store_cur_nalu(H264dCurCtx_t *p_Cur, H264dCurStream_t *p_strm, H264dDxvaCtx_t *dxva_ctx)
337 {
338 MPP_RET ret = MPP_ERR_UNKNOW;
339 RK_U8 *p_des = NULL;
340
341 //!< fill head buffer
342 if ( (p_strm->nalu_type == H264_NALU_TYPE_SLICE)
343 || (p_strm->nalu_type == H264_NALU_TYPE_IDR)
344 || (p_strm->nalu_type == H264_NALU_TYPE_SPS)
345 || (p_strm->nalu_type == H264_NALU_TYPE_PPS)
346 || (p_strm->nalu_type == H264_NALU_TYPE_SUB_SPS)
347 || (p_strm->nalu_type == H264_NALU_TYPE_SEI)
348 || (p_strm->nalu_type == H264_NALU_TYPE_PREFIX)
349 || (p_strm->nalu_type == H264_NALU_TYPE_SLC_EXT)) {
350
351 RK_U32 head_size = MPP_MIN(HEAD_SYNTAX_MAX_SIZE, p_strm->nalu_len);
352 RK_U32 add_size = head_size + sizeof(H264dNaluHead_t);
353
354 if ((p_strm->head_offset + add_size) >= p_strm->head_max_size) {
355 FUN_CHECK(ret = realloc_buffer(&p_strm->head_buf, &p_strm->head_max_size, add_size));
356 }
357 p_des = &p_strm->head_buf[p_strm->head_offset];
358 ((H264dNaluHead_t *)p_des)->is_frame_end = 0;
359 ((H264dNaluHead_t *)p_des)->nalu_type = p_strm->nalu_type;
360 ((H264dNaluHead_t *)p_des)->sodb_len = head_size;
361 memcpy(p_des + sizeof(H264dNaluHead_t), p_strm->nalu_buf, head_size);
362 p_strm->head_offset += add_size;
363 } //!< fill sodb buffer
364 if ((p_strm->nalu_type == H264_NALU_TYPE_SLICE)
365 || (p_strm->nalu_type == H264_NALU_TYPE_IDR)) {
366
367 RK_U32 add_size = p_strm->nalu_len + sizeof(g_start_precode);
368
369 if ((dxva_ctx->strm_offset + add_size) >= dxva_ctx->max_strm_size) {
370 FUN_CHECK(ret = realloc_buffer(&dxva_ctx->bitstream, &dxva_ctx->max_strm_size, add_size));
371 }
372
373 p_des = &dxva_ctx->bitstream[dxva_ctx->strm_offset];
374 memcpy(p_des, g_start_precode, sizeof(g_start_precode));
375 memcpy(p_des + sizeof(g_start_precode), p_strm->nalu_buf, p_strm->nalu_len);
376 dxva_ctx->strm_offset += add_size;
377 }
378 if (h264d_debug & H264D_DBG_WRITE_ES_EN) {
379 H264dInputCtx_t *p_Inp = p_Cur->p_Inp;
380 if ((p_strm->nalu_type == H264_NALU_TYPE_SPS)
381 || (p_strm->nalu_type == H264_NALU_TYPE_PPS)) {
382 if (p_Inp->spspps_update_flag) {
383 p_des = &p_Inp->spspps_buf[p_Inp->spspps_offset];
384 memcpy(p_des, g_start_precode, sizeof(g_start_precode));
385 memcpy(p_des + sizeof(g_start_precode), p_strm->nalu_buf, p_strm->nalu_len);
386 p_Inp->spspps_offset += p_strm->nalu_len + sizeof(g_start_precode);
387 p_Inp->spspps_len = p_Inp->spspps_offset;
388 }
389 } else if ((p_strm->nalu_type == H264_NALU_TYPE_SLICE)
390 || (p_strm->nalu_type == H264_NALU_TYPE_IDR)) {
391 p_Cur->p_Inp->spspps_update_flag = 1;
392 p_Inp->spspps_offset = 0;
393 }
394 }
395
396 return ret = MPP_OK;
397 __FAILED:
398 return ret;
399 }
400
judge_is_new_frame(H264dCurCtx_t * p_Cur,H264dCurStream_t * p_strm)401 static MPP_RET judge_is_new_frame(H264dCurCtx_t *p_Cur, H264dCurStream_t *p_strm)
402 {
403 MPP_RET ret = MPP_ERR_UNKNOW;
404 RK_U32 nalu_header_bytes = 0;
405
406 BitReadCtx_t *p_bitctx = &p_Cur->bitctx;
407 memset(p_bitctx, 0, sizeof(BitReadCtx_t));
408 {
409 RK_U32 forbidden_bit = -1;
410 RK_U32 nal_reference_idc = -1;
411 mpp_set_bitread_ctx(p_bitctx, p_strm->nalu_buf, 4);
412 mpp_set_bitread_pseudo_code_type(p_bitctx, PSEUDO_CODE_H264_H265);
413
414 READ_BITS(p_bitctx, 1, &forbidden_bit);
415 ASSERT(forbidden_bit == 0);
416 READ_BITS(p_bitctx, 2, &nal_reference_idc);
417 READ_BITS(p_bitctx, 5, &p_strm->nalu_type);
418
419 nalu_header_bytes = 1;
420 if ((p_strm->nalu_type == H264_NALU_TYPE_PREFIX)
421 || (p_strm->nalu_type == H264_NALU_TYPE_SLC_EXT)) {
422 if (p_strm->nalu_type == H264_NALU_TYPE_SLC_EXT) {
423 p_strm->nalu_type = H264_NALU_TYPE_SLICE;
424 }
425 nalu_header_bytes += 3;
426 }
427 }
428 if ((p_strm->nalu_len == 1)
429 && (p_strm->nalu_type == H264_NALU_TYPE_SEI
430 || p_strm->nalu_type == H264_NALU_TYPE_SPS
431 || p_strm->nalu_type == H264_NALU_TYPE_PPS
432 || p_strm->nalu_type == H264_NALU_TYPE_SUB_SPS
433 || p_strm->nalu_type == H264_NALU_TYPE_AUD
434 /*|| p_strm->nalu_type == H264_NALU_TYPE_PREFIX*/)) { // prefix may insert in slices of one frame
435 if (p_Cur->p_Dec->have_slice_data) {
436 p_Cur->p_Dec->is_new_frame = 1;
437 }
438 p_Cur->p_Dec->have_slice_data = 0;
439 } else if ((p_strm->nalu_len > 1)
440 && (p_strm->nalu_type == H264_NALU_TYPE_SLICE
441 || p_strm->nalu_type == H264_NALU_TYPE_IDR)) {
442 RK_U32 first_mb_in_slice = 0;
443 mpp_set_bitread_ctx(p_bitctx, (p_strm->nalu_buf + nalu_header_bytes), 4); // reset
444 mpp_set_bitread_pseudo_code_type(p_bitctx, PSEUDO_CODE_H264_H265);
445 READ_UE(p_bitctx, &first_mb_in_slice);
446 if (first_mb_in_slice == 0) {
447 p_Cur->last_dts = p_Cur->curr_dts;
448 p_Cur->last_pts = p_Cur->curr_pts;
449 p_Cur->curr_dts = p_Cur->p_Inp->in_dts;
450 p_Cur->curr_pts = p_Cur->p_Inp->in_pts;
451 if (p_Cur->p_Dec->have_slice_data) {
452 p_Cur->p_Dec->is_new_frame = 1;
453 }
454 p_Cur->p_Dec->have_slice_data = 1;
455 }
456 }
457
458 return ret = MPP_OK;
459 __BITREAD_ERR:
460 return ret = p_bitctx->ret;
461 }
462
463 #define MAX_ES_FILE_SIZE (100*1024*1024)
464 static RK_U32 global_file_fid = 0;
465 static RK_U64 global_flie_size = 0;
466 /*!
467 ***********************************************************************
468 * \brief
469 * open stream file to store packet
470 ***********************************************************************
471 */
open_stream_file(H264dInputCtx_t * p_Inp,char * path)472 MPP_RET open_stream_file(H264dInputCtx_t *p_Inp, char *path)
473 {
474 if (h264d_debug & H264D_DBG_WRITE_ES_EN) {
475
476 sprintf(p_Inp->fname[0], "%s/rkv_h264d_file_00.h264", path);
477 sprintf(p_Inp->fname[1], "%s/rkv_h264d_file_01.h264", path);
478
479 p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "ab"); {
480 if (p_Inp->fp == NULL) {
481 H264D_WARNNING("[open_stream_file] can not open stream file, %s.", p_Inp->fname[global_file_fid]);
482 }
483 }
484 }
485
486 return MPP_OK;
487 }
488 /*!
489 ***********************************************************************
490 * \brief
491 * write stream file
492 ***********************************************************************
493 */
fwrite_stream_to_file(H264dInputCtx_t * p_Inp,RK_U8 * pdata,RK_U32 len)494 MPP_RET fwrite_stream_to_file(H264dInputCtx_t *p_Inp, RK_U8 *pdata, RK_U32 len)
495 {
496 if (p_Inp->fp && (h264d_debug & H264D_DBG_WRITE_ES_EN)) {
497 if (p_Inp->fp) {
498 fwrite(pdata, sizeof(RK_U8), len, p_Inp->fp);
499 fflush(p_Inp->fp);
500 }
501 global_flie_size += len;
502 if (global_flie_size > MAX_ES_FILE_SIZE) {
503 MPP_FCLOSE(p_Inp->fp);
504 global_file_fid = 1 - global_file_fid;
505 global_flie_size = 0;
506 p_Inp->fp = fopen(p_Inp->fname[global_file_fid], "wb");
507 if (p_Inp->fp == NULL) {
508 H264D_WARNNING("[open_stream_file] can not open stream file, %s", p_Inp->fname[global_file_fid]);
509 } else {
510 fwrite(p_Inp->spspps_buf, sizeof(RK_U8), p_Inp->spspps_len, p_Inp->fp);
511 fflush(p_Inp->fp);
512 }
513 }
514 }
515
516 return MPP_OK;
517 }
518 /*!
519 ***********************************************************************
520 * \brief
521 * close stream file
522 ***********************************************************************
523 */
close_stream_file(H264dInputCtx_t * p_Inp)524 MPP_RET close_stream_file(H264dInputCtx_t *p_Inp)
525 {
526 if (h264d_debug & H264D_DBG_WRITE_ES_EN) {
527 if (p_Inp->fp) {
528 fflush(p_Inp->fp);
529 MPP_FCLOSE(p_Inp->fp);
530 }
531 }
532
533 return MPP_OK;
534 }
535 /*!
536 ***********************************************************************
537 * \brief
538 * prepare function for parser
539 ***********************************************************************
540 */
parse_prepare(H264dInputCtx_t * p_Inp,H264dCurCtx_t * p_Cur)541 MPP_RET parse_prepare(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
542 {
543 MPP_RET ret = MPP_ERR_UNKNOW;
544
545 H264_DecCtx_t *p_Dec = p_Inp->p_Dec;
546 H264dCurStream_t *p_strm = &p_Cur->strm;
547 MppPacketImpl *pkt_impl = (MppPacketImpl *)p_Inp->in_pkt;
548
549 p_Dec->nalu_ret = NALU_NULL;
550 p_Inp->task_valid = 0;
551
552 //!< check eos
553 if (p_Inp->pkt_eos && !p_Inp->in_length) {
554 FUN_CHECK(ret = store_cur_nalu(p_Cur, p_strm, p_Dec->dxva_ctx));
555 FUN_CHECK(ret = add_empty_nalu(p_strm));
556 p_Dec->p_Inp->task_valid = 1;
557 p_Dec->p_Inp->task_eos = 1;
558 H264D_LOG("----- end of stream ----");
559 goto __RETURN;
560 }
561 //!< check input
562 if (!p_Inp->in_length) {
563 p_Dec->nalu_ret = HaveNoStream;
564 goto __RETURN;
565 }
566
567 while (pkt_impl->length > 0) {
568 p_strm->curdata = &p_Inp->in_buf[p_strm->nalu_offset++];
569 pkt_impl->length--;
570 p_strm->prefixdata = (p_strm->prefixdata << 8) | (*p_strm->curdata);
571 if (p_strm->startcode_found) {
572 if (p_strm->nalu_len >= p_strm->nalu_max_size) {
573 FUN_CHECK(ret = realloc_buffer(&p_strm->nalu_buf, &p_strm->nalu_max_size, NALU_BUF_ADD_SIZE));
574 }
575 p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata;
576 if ((p_strm->nalu_len == NALU_TYPE_NORMAL_LENGTH)
577 || (p_strm->nalu_len == NALU_TYPE_EXT_LENGTH)) {
578 FUN_CHECK(ret = judge_is_new_frame(p_Cur, p_strm));
579 if (p_Cur->p_Dec->is_new_frame) {
580 FUN_CHECK(ret = add_empty_nalu(p_strm));
581 p_strm->head_offset = 0;
582 p_Cur->p_Inp->task_valid = 1;
583 p_Cur->p_Dec->is_new_frame = 0;
584 break;
585 }
586 }
587 }
588
589 find_prefix_code(p_strm->curdata, p_strm);
590
591 if (p_strm->endcode_found) {
592 p_strm->nalu_len -= START_PREFIX_3BYTE;
593 if (p_strm->nalu_len > START_PREFIX_3BYTE) {
594 while ((p_strm->nalu_len > 0) &&
595 (p_strm->nalu_buf[p_strm->nalu_len - 1] == 0x00)) {
596 p_strm->nalu_len--;
597 }
598 }
599 p_Dec->nalu_ret = EndOfNalu;
600 FUN_CHECK(ret = store_cur_nalu(p_Cur, p_strm, p_Dec->dxva_ctx));
601 reset_nalu(p_strm);
602 break;
603 }
604 }
605 p_Inp->in_length = pkt_impl->length;
606 //!< check input
607 if (!p_Inp->in_length) {
608 p_strm->nalu_offset = 0;
609 p_Dec->nalu_ret = HaveNoStream;
610 }
611
612 if (p_Inp->pkt_eos && p_Inp->in_length < 4) {
613 FUN_CHECK(ret = store_cur_nalu(p_Cur, p_strm, p_Dec->dxva_ctx));
614 FUN_CHECK(ret = add_empty_nalu(p_strm));
615 p_Dec->p_Inp->task_valid = 1;
616 p_Dec->p_Inp->task_eos = 1;
617 }
618
619 __RETURN:
620
621 return ret = MPP_OK;
622 __FAILED:
623 return ret;
624 }
625
626 /*!
627 ***********************************************************************
628 * \brief
629 * prepare function for parser
630 ***********************************************************************
631 */
parse_prepare_fast(H264dInputCtx_t * p_Inp,H264dCurCtx_t * p_Cur)632 MPP_RET parse_prepare_fast(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
633 {
634 MPP_RET ret = MPP_ERR_UNKNOW;
635
636 H264_DecCtx_t *p_Dec = p_Inp->p_Dec;
637 H264dCurStream_t *p_strm = &p_Cur->strm;
638 MppPacketImpl *pkt_impl = (MppPacketImpl *)p_Inp->in_pkt;
639
640 p_Dec->nalu_ret = NALU_NULL;
641 p_Inp->task_valid = 0;
642
643 while (pkt_impl->length > 0) {
644 p_strm->curdata = &p_Inp->in_buf[p_strm->nalu_offset++];
645 pkt_impl->length--;
646 p_strm->prefixdata = (p_strm->prefixdata << 8) | (*p_strm->curdata);
647 if (p_strm->startcode_found) {
648 if (p_strm->nalu_len >= p_strm->nalu_max_size) {
649 FUN_CHECK(ret = realloc_buffer(&p_strm->nalu_buf, &p_strm->nalu_max_size, NALU_BUF_ADD_SIZE));
650 }
651 p_strm->nalu_buf[p_strm->nalu_len++] = *p_strm->curdata;
652 if (p_strm->nalu_len == 1) {
653 p_strm->nalu_type = p_strm->nalu_buf[0] & 0x1F;
654
655 if (p_strm->nalu_type == H264_NALU_TYPE_SLICE
656 || p_strm->nalu_type == H264_NALU_TYPE_IDR || p_strm->nalu_type == H264_NALU_TYPE_SLC_EXT) {
657
658 if (p_strm->nalu_type == H264_NALU_TYPE_SLC_EXT)
659 p_strm->nalu_type = H264_NALU_TYPE_SLICE;
660
661 p_strm->nalu_len += (RK_U32)pkt_impl->length;
662 if (p_strm->nalu_len >= p_strm->nalu_max_size) {
663 RK_U32 add_size = pkt_impl->length + 1 - p_strm->nalu_max_size;
664 FUN_CHECK(ret = realloc_buffer(&p_strm->nalu_buf, &p_strm->nalu_max_size, MPP_MAX(NALU_BUF_ADD_SIZE, add_size)));
665 }
666 memcpy(&p_strm->nalu_buf[0], p_strm->curdata, pkt_impl->length + 1);
667 pkt_impl->length = 0;
668 p_Cur->p_Inp->task_valid = 1;
669 break;
670 }
671 }
672 }
673
674 find_prefix_code(p_strm->curdata, p_strm);
675
676 if (p_strm->endcode_found) {
677 p_strm->nalu_len -= START_PREFIX_3BYTE;
678 while (p_strm->nalu_len > 0 && p_strm->nalu_buf[p_strm->nalu_len - 1] == 0x00) {
679 p_strm->nalu_len--;
680 }
681 p_Dec->nalu_ret = EndOfNalu;
682 FUN_CHECK(ret = store_cur_nalu(p_Cur, p_strm, p_Dec->dxva_ctx));
683 reset_nalu(p_strm);
684 break;
685 }
686 }
687 if (p_Cur->p_Inp->task_valid) {
688 FUN_CHECK(ret = store_cur_nalu(p_Cur, p_strm, p_Dec->dxva_ctx));
689 FUN_CHECK(ret = add_empty_nalu(p_strm));
690 p_strm->head_offset = 0;
691 p_Cur->last_dts = p_Cur->p_Inp->in_dts;
692 p_Cur->last_pts = p_Cur->p_Inp->in_pts;
693 }
694 p_Inp->in_length = pkt_impl->length;
695 //!< check input
696 if (!p_Inp->in_length) {
697 if (!p_Cur->p_Inp->task_valid) {
698 p_Dec->nalu_ret = EndOfNalu;
699 FUN_CHECK(ret = store_cur_nalu(p_Cur, p_strm, p_Dec->dxva_ctx));
700 } else {
701 p_Dec->nalu_ret = HaveNoStream;
702 }
703 p_strm->nalu_offset = 0;
704 p_strm->endcode_found = 1;
705
706 reset_nalu(p_strm);
707 p_strm->startcode_found = 0;
708 }
709
710 return ret = MPP_OK;
711 __FAILED:
712 return ret;
713 }
714 /*!
715 ***********************************************************************
716 * \brief
717 * main function for parser avcC header
718 ***********************************************************************
719 */
parse_prepare_avcC_header(H264dInputCtx_t * p_Inp,H264dCurCtx_t * p_Cur)720 MPP_RET parse_prepare_avcC_header(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
721 {
722 RK_S32 i = 0;
723 MPP_RET ret = MPP_ERR_UNKNOW;
724
725 H264dCurStream_t *p_strm = &p_Cur->strm;
726 RK_U8 *pdata = p_Inp->in_buf;
727 RK_U64 extrasize = p_Inp->in_length;
728 MppPacketImpl *pkt_impl = (MppPacketImpl *)p_Inp->in_pkt;
729
730 //!< free nalu_buffer
731 MPP_FREE(p_strm->nalu_buf);
732 if (p_Inp->in_length < 7) {
733 H264D_ERR("avcC too short, len=%d \n", p_Inp->in_length);
734 goto __FAILED;
735 }
736 if (pdata[0] != 1) {
737 goto __FAILED;
738 }
739 p_Inp->profile = pdata[1];
740 p_Inp->level = pdata[3];
741 p_Inp->nal_size = 1 + (pdata[4] & 3);
742 p_Inp->sps_num = pdata[5] & 31;
743
744 pdata += 6;
745 extrasize -= 6;
746 for (i = 0; i < p_Inp->sps_num; ++i) {
747 p_strm->nalu_len = U16_AT(pdata);
748 pdata += 2;
749 extrasize -= 2;
750 p_strm->nalu_type = H264_NALU_TYPE_SPS;
751 p_strm->nalu_buf = pdata;
752 FUN_CHECK(ret = store_cur_nalu(p_Cur, p_strm, p_Cur->p_Dec->dxva_ctx));
753 pdata += p_strm->nalu_len;
754 extrasize -= p_strm->nalu_len;
755 }
756 p_strm->nalu_buf = NULL;
757 p_Inp->pps_num = *pdata;
758 ++pdata;
759 --extrasize;
760 for (i = 0; i < p_Inp->pps_num; ++i) {
761 p_strm->nalu_len = U16_AT(pdata);
762 pdata += 2;
763 extrasize -= 2;
764 p_strm->nalu_type = H264_NALU_TYPE_PPS;
765 p_strm->nalu_buf = pdata;
766 FUN_CHECK(ret = store_cur_nalu(p_Cur, p_strm, p_Cur->p_Dec->dxva_ctx));
767 pdata += p_strm->nalu_len;
768 extrasize -= p_strm->nalu_len;
769 }
770 pkt_impl->length = 0;
771 p_strm->nalu_buf = NULL;
772 p_strm->startcode_found = 1;
773
774 ret = MPP_OK;
775 __FAILED:
776 return ret;
777 }
778 /*!
779 ***********************************************************************
780 * \brief
781 * main function for parser avcC data
782 ***********************************************************************
783 */
parse_prepare_avcC_data(H264dInputCtx_t * p_Inp,H264dCurCtx_t * p_Cur)784 MPP_RET parse_prepare_avcC_data(H264dInputCtx_t *p_Inp, H264dCurCtx_t *p_Cur)
785 {
786 MPP_RET ret = MPP_ERR_UNKNOW;
787
788 H264dCurStream_t *p_strm = &p_Cur->strm;
789 MppPacketImpl *pkt_impl = (MppPacketImpl *)p_Inp->in_pkt;
790
791 p_strm->nalu_buf = NULL;
792 p_Inp->task_valid = 0;
793 if (p_Inp->pkt_eos) {
794 p_Inp->task_eos = 1;
795 if (p_Inp->in_length)
796 p_Inp->task_valid = 1;
797 return MPP_OK;
798 }
799 VAL_CHECK(ret, (p_Inp->nal_size > 0));
800 p_strm->curdata = &p_Inp->in_buf[p_strm->nalu_offset];
801 while (p_Inp->in_length > 0) {
802 if (p_strm->startcode_found) {
803 p_strm->nalu_len = parse_nal_size(p_Inp->nal_size, p_strm->curdata);
804 if (p_strm->nalu_len <= 0 || p_strm->nalu_len >= p_Inp->in_length) {
805 p_Cur->p_Dec->is_new_frame = 1;
806 p_Cur->p_Dec->have_slice_data = 0;
807 pkt_impl->length = 0;
808 p_Inp->in_length = 0;
809 p_strm->nalu_len = 0;
810 p_strm->nalu_offset = 0;
811 p_strm->startcode_found = 1;
812 p_strm->endcode_found = 0;
813 p_strm->nalu_buf = NULL;
814 goto __FAILED;
815 }
816
817 p_strm->nalu_buf = p_strm->curdata + p_Inp->nal_size;
818 judge_is_new_frame(p_Cur, p_strm);
819 if (p_Cur->p_Dec->is_new_frame) {
820 p_Cur->p_Dec->have_slice_data = 0;
821 p_strm->startcode_found = 1;
822 p_strm->endcode_found = 0;
823 break;
824 }
825
826 p_strm->curdata += p_Inp->nal_size;
827 p_strm->nalu_offset += p_Inp->nal_size;
828 pkt_impl->length -= p_Inp->nal_size;
829 p_Inp->in_length -= p_Inp->nal_size;
830
831 p_strm->nalu_buf = p_strm->curdata;
832 p_strm->nalu_type = p_strm->nalu_buf[0] & 0x1F;
833 p_strm->startcode_found = 0;
834 p_strm->endcode_found = 1;
835
836 FUN_CHECK(ret = store_cur_nalu(p_Cur, p_strm, p_Cur->p_Dec->dxva_ctx));
837 p_strm->curdata += p_strm->nalu_len;
838 p_strm->nalu_offset += p_strm->nalu_len;
839 pkt_impl->length -= p_strm->nalu_len;
840 p_Inp->in_length -= p_strm->nalu_len;
841 p_strm->startcode_found = 1;
842 p_strm->endcode_found = 0;
843 p_strm->nalu_len = 0;
844 }
845
846 if (p_Inp->in_length < p_Inp->nal_size) {
847 p_Cur->p_Dec->is_new_frame = 1;
848 p_Cur->p_Dec->have_slice_data = 0;
849 pkt_impl->length = 0;
850 p_Inp->in_length = 0;
851 p_strm->nalu_len = 0;
852 p_strm->nalu_offset = 0;
853 p_strm->startcode_found = 1;
854 p_strm->endcode_found = 0;
855 p_strm->nalu_buf = NULL;
856 break;
857 }
858 }
859 //!< one frame end
860 if (p_Cur->p_Dec->is_new_frame) {
861 //!< add an empty nalu to tell frame end
862 FUN_CHECK(ret = add_empty_nalu(p_strm));
863 //!< reset curstream parameters
864 p_strm->head_offset = 0;
865 p_Cur->p_Inp->task_valid = 1;
866 p_Cur->p_Dec->is_new_frame = 0;
867
868 p_Cur->last_dts = p_Inp->in_dts;
869 p_Cur->last_pts = p_Inp->in_pts;
870 }
871 p_strm->nalu_buf = NULL;
872 ret = MPP_OK;
873 __FAILED:
874 //p_strm->nalu_len = 0;
875 p_Cur->last_dts = p_Inp->in_dts;
876 p_Cur->last_pts = p_Inp->in_pts;
877 p_Inp->p_Dec->nalu_ret = HaveNoStream;
878
879 return ret;
880 }
881
882
883
884 /*!
885 ***********************************************************************
886 * \brief
887 * main function for parser
888 ***********************************************************************
889 */
parse_loop(H264_DecCtx_t * p_Dec)890 MPP_RET parse_loop(H264_DecCtx_t *p_Dec)
891 {
892 MPP_RET ret = MPP_ERR_UNKNOW;
893 RK_U8 *p_curdata = NULL;
894 RK_U8 while_loop_flag = 1;
895 H264dNaluHead_t *p_head = NULL;
896
897 INP_CHECK(ret, !p_Dec);
898 //!< ==== loop ====
899 p_Dec->next_state = SliceSTATE_ResetSlice;
900 p_curdata = p_Dec->p_Cur->strm.head_buf;
901
902 while (while_loop_flag) {
903 switch (p_Dec->next_state) {
904 case SliceSTATE_ResetSlice:
905 reset_slice(p_Dec->p_Vid);
906 p_Dec->next_state = SliceSTATE_ReadNalu;
907 H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_ResetSlice");
908 break;
909 case SliceSTATE_ReadNalu:
910 p_head = (H264dNaluHead_t *)p_curdata;
911 if (p_head->is_frame_end) {
912 p_Dec->next_state = SliceSTATE_RegisterOneFrame;
913 p_Dec->nalu_ret = HaveNoStream;
914 } else {
915 p_curdata += sizeof(H264dNaluHead_t);
916 memset(&p_Dec->p_Cur->nalu, 0, sizeof(H264_Nalu_t));
917 p_Dec->p_Cur->nalu.sodb_buf = p_curdata;
918 p_Dec->p_Cur->nalu.sodb_len = p_head->sodb_len;
919 p_curdata += p_head->sodb_len;
920 p_Dec->nalu_ret = EndOfNalu;
921 p_Dec->next_state = SliceSTATE_ParseNalu;
922 }
923 H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_ReadNalu");
924 break;
925 case SliceSTATE_ParseNalu:
926 FUN_CHECK(ret = parser_one_nalu(&p_Dec->p_Cur->slice));
927 if (p_Dec->nalu_ret == StartOfSlice) {
928 p_Dec->next_state = SliceSTATE_GetSliceData;
929 } else if (p_Dec->nalu_ret == StartOfPicture) {
930 p_Dec->next_state = SliceSTATE_InitPicture;
931 } else if (p_Dec->nalu_ret == MvcDisAble) {
932 H264D_LOG("xxxxxxxx MVC disable");
933 goto __FAILED;
934 } else if (p_Dec->nalu_ret == NaluNotSupport) {
935 H264D_LOG("NALU not support, abort decoding");
936 goto __FAILED;
937 } else {
938 p_Dec->next_state = SliceSTATE_ReadNalu;
939 }
940 H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_ParseNalu");
941 break;
942 case SliceSTATE_InitPicture:
943 if (!p_Dec->p_Vid->iNumOfSlicesDecoded) {
944 FUN_CHECK(ret = init_picture(&p_Dec->p_Cur->slice));
945 p_Dec->is_parser_end = 1;
946 }
947 p_Dec->next_state = SliceSTATE_GetSliceData;
948 H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_InitPicture");
949 break;
950 case SliceSTATE_GetSliceData:
951 FUN_CHECK(ret = fill_slice_syntax(&p_Dec->p_Cur->slice, p_Dec->dxva_ctx));
952 p_Dec->p_Vid->iNumOfSlicesDecoded++;
953 if (p_Dec->is_parser_end) {
954 p_Dec->next_state = SliceSTATE_RegisterOneFrame;
955 } else {
956 p_Dec->next_state = SliceSTATE_ResetSlice;
957 }
958 H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_GetSliceData");
959 break;
960 case SliceSTATE_RegisterOneFrame:
961 if (!p_Dec->is_parser_end) {
962 ret = MPP_NOK;
963 goto __FAILED;
964 }
965 commit_buffer(p_Dec->dxva_ctx);
966 while_loop_flag = 0;
967 p_Dec->next_state = SliceSTATE_ReadNalu;
968 H264D_DBG(H264D_DBG_LOOP_STATE, "SliceSTATE_RegisterOneFrame");
969 break;
970 default:
971 ret = MPP_NOK;
972 break;
973 }
974 }
975
976 __RETURN:
977 return ret = MPP_OK;
978 __FAILED:
979 p_Dec->nalu_ret = NALU_NULL;
980 p_Dec->dxva_ctx->slice_count = 0;
981 p_Dec->dxva_ctx->strm_offset = 0;
982 p_Dec->p_Vid->iNumOfSlicesDecoded = 0;
983 p_Dec->p_Vid->exit_picture_flag = 0;
984
985 return ret;
986 }
987
988
989