1 /* SPDX-License-Identifier: Apache-2.0 OR MIT */
2 /*
3 * Copyright (c) 2015 Rockchip Electronics Co., Ltd.
4 */
5
6 #if defined(_WIN32)
7 #include "vld.h"
8 #endif
9
10 #define MODULE_TAG "mpi_dec_mt_test"
11
12 #include <string.h>
13 #include <pthread.h>
14
15 #include "rk_mpi.h"
16
17 #include "mpp_mem.h"
18 #include "mpp_env.h"
19 #include "mpp_time.h"
20 #include "mpp_common.h"
21
22 #include "mpi_dec_utils.h"
23
24 typedef struct {
25 MpiDecTestCmd *cmd;
26 MppCtx ctx;
27 MppApi *mpi;
28
29 volatile RK_U32 loop_end;
30
31 /* buffer for stream data reading */
32 char *buf;
33
34 /* input and output */
35 DecBufMgr buf_mgr;
36 MppBufferGroup frm_grp;
37 MppPacket packet;
38 size_t packet_size;
39 MppFrame frame;
40
41 FILE *fp_output;
42 RK_S32 frame_count;
43 RK_S32 frame_num;
44 FileReader reader;
45
46 /* runtime flag */
47 RK_U32 quiet;
48 } MpiDecMtLoopData;
49
thread_input(void * arg)50 void *thread_input(void *arg)
51 {
52 MpiDecMtLoopData *data = (MpiDecMtLoopData *)arg;
53 MppCtx ctx = data->ctx;
54 MppApi *mpi = data->mpi;
55 MppPacket packet = data->packet;
56 FileReader reader = data->reader;
57 RK_U32 quiet = data->quiet;
58
59 mpp_log_q(quiet, "put packet thread start\n");
60
61 do {
62 RK_U32 pkt_eos = 0;
63 FileBufSlot *slot = NULL;
64 MPP_RET ret = reader_read(reader, &slot);
65 if (ret)
66 break;
67
68 mpp_packet_set_data(packet, slot->data);
69 mpp_packet_set_size(packet, slot->size);
70 mpp_packet_set_pos(packet, slot->data);
71 mpp_packet_set_length(packet, slot->size);
72
73 pkt_eos = slot->eos;
74 // setup eos flag
75 if (pkt_eos) {
76 if (data->frame_num < 0 || data->frame_count < data->frame_num) {
77 mpp_log_q(quiet, "%p loop again\n", ctx);
78 reader_rewind(reader);
79 pkt_eos = 0;
80 } else {
81 mpp_log_q(quiet, "%p found last packet\n", ctx);
82 mpp_packet_set_eos(packet);
83 }
84 }
85
86 // send packet until it success
87 do {
88 ret = mpi->decode_put_packet(ctx, packet);
89 if (MPP_OK == ret) {
90 mpp_assert(0 == mpp_packet_get_length(packet));
91 break;
92
93 }
94 // if failed wait a moment and retry
95 msleep(1);
96 } while (!data->loop_end);
97
98 if (pkt_eos)
99 break;
100 } while (!data->loop_end);
101
102 mpp_log_q(quiet, "put packet thread end\n");
103
104 return NULL;
105 }
106
thread_output(void * arg)107 void *thread_output(void *arg)
108 {
109 MpiDecMtLoopData *data = (MpiDecMtLoopData *)arg;
110 MpiDecTestCmd *cmd = data->cmd;
111 MppCtx ctx = data->ctx;
112 MppApi *mpi = data->mpi;
113 RK_U32 quiet = data->quiet;
114
115 mpp_log_q(quiet, "get frame thread start\n");
116
117 // then get all available frame and release
118 do {
119 RK_U32 frm_eos = 0;
120 MppFrame frame = NULL;
121 MPP_RET ret = mpi->decode_get_frame(ctx, &frame);
122
123 if (ret) {
124 mpp_err("decode_get_frame failed ret %d\n", ret);
125 continue;
126 }
127
128 if (NULL == frame) {
129 msleep(1);
130 continue;
131 }
132
133 if (mpp_frame_get_info_change(frame)) {
134 // found info change and create buffer group for decoding
135 RK_U32 width = mpp_frame_get_width(frame);
136 RK_U32 height = mpp_frame_get_height(frame);
137 RK_U32 hor_stride = mpp_frame_get_hor_stride(frame);
138 RK_U32 ver_stride = mpp_frame_get_ver_stride(frame);
139 RK_U32 buf_size = mpp_frame_get_buf_size(frame);
140 MppBufferGroup grp = NULL;
141
142 mpp_log_q(quiet, "decode_get_frame get info changed found\n");
143 mpp_log_q(quiet, "decoder require buffer w:h [%d:%d] stride [%d:%d] size %d\n",
144 width, height, hor_stride, ver_stride, buf_size);
145
146 if (MPP_FRAME_FMT_IS_FBC(cmd->format)) {
147 MppFrame frm = NULL;
148
149 mpp_frame_init(&frm);
150 mpp_frame_set_width(frm, width);
151 mpp_frame_set_height(frm, height);
152 mpp_frame_set_fmt(frm, cmd->format);
153
154 ret = mpi->control(ctx, MPP_DEC_SET_FRAME_INFO, frm);
155 mpp_frame_deinit(&frm);
156
157 if (ret) {
158 mpp_err("set fbc frame info failed\n");
159 break;
160 }
161 }
162
163 grp = dec_buf_mgr_setup(data->buf_mgr, buf_size, 24, cmd->buf_mode);
164 /* Set buffer to mpp decoder */
165 ret = mpi->control(ctx, MPP_DEC_SET_EXT_BUF_GROUP, grp);
166 if (ret) {
167 mpp_err("%p set buffer group failed ret %d\n", ctx, ret);
168 break;
169 }
170 data->frm_grp = grp;
171
172 ret = mpi->control(ctx, MPP_DEC_SET_INFO_CHANGE_READY, NULL);
173 if (ret) {
174 mpp_err("info change ready failed ret %d\n", ret);
175 break;
176 }
177 } else {
178 char log_buf[256];
179 RK_S32 log_size = sizeof(log_buf) - 1;
180 RK_S32 log_len = 0;
181 RK_U32 err_info = mpp_frame_get_errinfo(frame);
182 RK_U32 discard = mpp_frame_get_discard(frame);
183
184 log_len += snprintf(log_buf + log_len, log_size - log_len,
185 "decode get frame %d", data->frame_count);
186
187 if (mpp_frame_has_meta(frame)) {
188 MppMeta meta = mpp_frame_get_meta(frame);
189 RK_S32 temporal_id = 0;
190
191 mpp_meta_get_s32(meta, KEY_TEMPORAL_ID, &temporal_id);
192
193 log_len += snprintf(log_buf + log_len, log_size - log_len,
194 " tid %d", temporal_id);
195 }
196
197 if (err_info || discard) {
198 log_len += snprintf(log_buf + log_len, log_size - log_len,
199 " err %x discard %x", err_info, discard);
200 }
201 mpp_log_q(quiet, "%p %s\n", ctx, log_buf);
202
203 data->frame_count++;
204 if (data->fp_output && !err_info)
205 dump_mpp_frame_to_file(frame, data->fp_output);
206
207 fps_calc_inc(cmd->fps);
208 }
209
210 frm_eos = mpp_frame_get_eos(frame);
211 mpp_frame_deinit(&frame);
212
213 if ((data->frame_num > 0 && (data->frame_count >= data->frame_num)) ||
214 ((data->frame_num == 0) && frm_eos))
215 data->loop_end = 1;
216 } while (!data->loop_end);
217
218 mpp_log_q(quiet, "get frame thread end\n");
219
220 return NULL;
221 }
222
mt_dec_decode(MpiDecTestCmd * cmd)223 int mt_dec_decode(MpiDecTestCmd *cmd)
224 {
225 MPP_RET ret = MPP_OK;
226 FileReader reader = cmd->reader;
227
228 // base flow context
229 MppCtx ctx = NULL;
230 MppApi *mpi = NULL;
231
232 // input / output
233 MppPacket packet = NULL;
234 MppFrame frame = NULL;
235
236 // config for runtime mode
237 MppDecCfg cfg = NULL;
238 RK_U32 need_split = 1;
239
240 // paramter for resource malloc
241 RK_U32 width = cmd->width;
242 RK_U32 height = cmd->height;
243 MppCodingType type = cmd->type;
244
245 pthread_t thd_in;
246 pthread_t thd_out = 0;
247 pthread_attr_t attr;
248 MpiDecMtLoopData data;
249
250 mpp_log("mpi_dec_mt_test start\n");
251 memset(&data, 0, sizeof(data));
252
253 if (cmd->have_output) {
254 data.fp_output = fopen(cmd->file_output, "w+b");
255 if (NULL == data.fp_output) {
256 mpp_err("failed to open output file %s\n", cmd->file_output);
257 goto MPP_TEST_OUT;
258 }
259 }
260
261 ret = dec_buf_mgr_init(&data.buf_mgr);
262 if (ret) {
263 mpp_err("dec_buf_mgr_init failed\n");
264 goto MPP_TEST_OUT;
265 }
266
267 ret = mpp_packet_init(&packet, NULL, 0);
268 if (ret) {
269 mpp_err("mpp_packet_init failed\n");
270 goto MPP_TEST_OUT;
271 }
272
273 mpp_log("mpi_dec_mt_test decoder test start w %d h %d type %d\n", width, height, type);
274
275 // decoder demo
276 ret = mpp_create(&ctx, &mpi);
277 if (ret) {
278 mpp_err("mpp_create failed\n");
279 goto MPP_TEST_OUT;
280 }
281
282 ret = mpp_init(ctx, MPP_CTX_DEC, type);
283 if (ret) {
284 mpp_err("mpp_init failed\n");
285 goto MPP_TEST_OUT;
286 }
287
288 // NOTE: timeout value please refer to MppPollType definition
289 // 0 - non-block call (default)
290 // -1 - block call
291 // +val - timeout value in ms
292 {
293 MppPollType timeout = MPP_POLL_BLOCK;
294 MppParam param = &timeout;
295
296 ret = mpi->control(ctx, MPP_SET_OUTPUT_TIMEOUT, param);
297 if (ret) {
298 mpp_err("Failed to set output timeout %d ret %d\n", timeout, ret);
299 goto MPP_TEST_OUT;
300 }
301 }
302
303 mpp_dec_cfg_init(&cfg);
304
305 /* get default config from decoder context */
306 ret = mpi->control(ctx, MPP_DEC_GET_CFG, cfg);
307 if (ret) {
308 mpp_err("%p failed to get decoder cfg ret %d\n", ctx, ret);
309 goto MPP_TEST_OUT;
310 }
311
312 /*
313 * split_parse is to enable mpp internal frame spliter when the input
314 * packet is not aplited into frames.
315 */
316 ret = mpp_dec_cfg_set_u32(cfg, "base:split_parse", need_split);
317 if (ret) {
318 mpp_err("%p failed to set split_parse ret %d\n", ctx, ret);
319 goto MPP_TEST_OUT;
320 }
321
322 ret = mpi->control(ctx, MPP_DEC_SET_CFG, cfg);
323 if (ret) {
324 mpp_err("%p failed to set cfg %p ret %d\n", ctx, cfg, ret);
325 goto MPP_TEST_OUT;
326 }
327
328 data.cmd = cmd;
329 data.ctx = ctx;
330 data.mpi = mpi;
331 data.loop_end = 0;
332 data.packet = packet;
333 data.frame = frame;
334 data.frame_count = 0;
335 data.frame_num = cmd->frame_num;
336 data.reader = reader;
337 data.quiet = cmd->quiet;
338
339 pthread_attr_init(&attr);
340 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
341
342 ret = pthread_create(&thd_in, &attr, thread_input, &data);
343 if (ret) {
344 mpp_err("failed to create thread for input ret %d\n", ret);
345 goto THREAD_END;
346 }
347
348 ret = pthread_create(&thd_out, &attr, thread_output, &data);
349 if (ret) {
350 mpp_err("failed to create thread for output ret %d\n", ret);
351 goto THREAD_END;
352 }
353
354 if (cmd->frame_num < 0) {
355 // wait for input then quit decoding
356 mpp_log("*******************************************\n");
357 mpp_log("**** Press Enter to stop loop decoding ****\n");
358 mpp_log("*******************************************\n");
359
360 getc(stdin);
361 data.loop_end = 1;
362 }
363
364 THREAD_END:
365 pthread_attr_destroy(&attr);
366
367 pthread_join(thd_in, NULL);
368 pthread_join(thd_out, NULL);
369
370 ret = mpi->reset(ctx);
371 if (ret) {
372 mpp_err("mpi->reset failed\n");
373 goto MPP_TEST_OUT;
374 }
375
376 MPP_TEST_OUT:
377 if (packet) {
378 mpp_packet_deinit(&packet);
379 packet = NULL;
380 }
381
382 if (frame) {
383 mpp_frame_deinit(&frame);
384 frame = NULL;
385 }
386
387 if (ctx) {
388 mpp_destroy(ctx);
389 ctx = NULL;
390 }
391
392 data.frm_grp = NULL;
393 if (data.buf_mgr) {
394 dec_buf_mgr_deinit(data.buf_mgr);
395 data.buf_mgr = NULL;
396 }
397
398 if (data.fp_output) {
399 fclose(data.fp_output);
400 data.fp_output = NULL;
401 }
402
403 if (cfg) {
404 mpp_dec_cfg_deinit(cfg);
405 cfg = NULL;
406 }
407
408 return ret;
409 }
410
main(int argc,char ** argv)411 int main(int argc, char **argv)
412 {
413 RK_S32 ret = 0;
414 MpiDecTestCmd cmd_ctx;
415 MpiDecTestCmd* cmd = &cmd_ctx;
416
417 memset((void*)cmd, 0, sizeof(*cmd));
418 // default use block mode
419 cmd->timeout = -1;
420
421 // parse the cmd option
422 ret = mpi_dec_test_cmd_init(cmd, argc, argv);
423 if (ret)
424 goto RET;
425
426 mpi_dec_test_cmd_options(cmd);
427
428 if (cmd->type == MPP_VIDEO_CodingMJPEG) {
429 mpp_log("mpi_dec_mt_test not support mjpeg yet\n");
430 goto RET;
431 }
432
433 ret = mt_dec_decode(cmd);
434 if (MPP_OK == ret)
435 mpp_log("test success\n");
436 else
437 mpp_err("test failed ret %d\n", ret);
438
439 RET:
440 mpi_dec_test_cmd_deinit(cmd);
441
442 return ret;
443 }
444