leon/ss928_framework
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
ss928_framework/ss928sdk/common/sample_comm_vdec.c
Your Name 9e9bb7036c first commit
2024-12-16 13:31:45 +08:00

862 lines
33 KiB
C
Executable File
Raw Permalink Blame History

/*
Copyright (c), 2001-2022, Shenshu Tech. Co., Ltd.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/poll.h>
#include <sys/time.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>
#include <math.h>
#include <unistd.h>
#include <signal.h>
#include <sys/prctl.h>
#include <limits.h>
#include "sample_comm.h"
#define SEND_STREAM_CNT 5
#define VDEC_SECOND 1000000
#define SAMPLE_VDEC_LOW_DELAY_LINE_CNT 16
static ot_vb_src g_vdec_vb_src = OT_VB_SRC_MOD;
static td_bool g_vdec_line_ldy_en = TD_FALSE;
static ot_vb_pool g_pic_vb_pool[OT_VB_MAX_POOLS] = { [0 ... (OT_VB_MAX_POOLS - 1)] = OT_VB_INVALID_POOL_ID };
static ot_vb_pool g_tmv_vb_pool[OT_VB_MAX_POOLS] = { [0 ... (OT_VB_MAX_POOLS - 1)] = OT_VB_INVALID_POOL_ID };
td_void sample_comm_vdec_print_chn_status(td_s32 chn, ot_vdec_chn_status status)
{
printf("\033[0;33m ---------------------------------------------------------------\033[0;39m\n");
printf("\033[0;33m chn:%d, type:%d, start:%d, decode_frames:%d, left_pics:%d, left_bytes:%d, "
"left_frames:%d, recv_frames:%d \033[0;39m\n",
chn, (status).type, (status).is_started, (status).dec_stream_frames, (status).left_decoded_frames,
(status).left_stream_bytes, (status).left_stream_frames, (status).recv_stream_frames);
printf("\033[0;33m format_err:%d, pic_size_err_set:%d, stream_unsprt:%d, pack_err:%d, "
"set_pic_size_err:%d, ref_err_set:%d, pic_buf_size_err_set:%d \033[0;39m\n",
(status).dec_err.format_err, (status).dec_err.set_pic_size_err, (status).dec_err.stream_unsupport,
(status).dec_err.pack_err, (status).dec_err.set_protocol_num_err, (status).dec_err.set_ref_num_err,
(status).dec_err.set_pic_buf_size_err);
printf("\033[0;33m -----------------------------------------------------------------\033[0;39m\n");
return;
}
td_bool sample_comm_vdec_get_lowdelay_en(td_void)
{
return g_vdec_line_ldy_en;
}
td_void sample_comm_vdec_set_lowdelay_en(td_bool enable)
{
g_vdec_line_ldy_en = enable;
}
td_s32 sample_comm_vdec_init_user_vb_pool(td_u32 chn_num, struct_vdec_buf *vdec_buf,
struct_vdec_attr *sample_vdec, td_u32 array_len)
{
td_u32 i;
ot_vb_pool_cfg vb_pool_cfg;
for (i = 0; (i < chn_num) && (i < array_len) && (i < OT_VB_MAX_POOLS); i++) {
if ((vdec_buf[i].pic_buf_size != 0) && (sample_vdec[i].frame_buf_cnt != 0)) {
(td_void)memset_s(&vb_pool_cfg, sizeof(ot_vb_pool_cfg), 0, sizeof(ot_vb_pool_cfg));
vb_pool_cfg.blk_size = vdec_buf[i].pic_buf_size;
vb_pool_cfg.blk_cnt = sample_vdec[i].frame_buf_cnt;
vb_pool_cfg.remap_mode = OT_VB_REMAP_MODE_NONE;
g_pic_vb_pool[i] = ss_mpi_vb_create_pool(&vb_pool_cfg);
if (g_pic_vb_pool[i] == OT_VB_INVALID_POOL_ID) {
return TD_FAILURE;
}
}
if (vdec_buf[i].tmv_buf_size != 0) {
(td_void)memset_s(&vb_pool_cfg, sizeof(ot_vb_pool_cfg), 0, sizeof(ot_vb_pool_cfg));
vb_pool_cfg.blk_size = vdec_buf[i].tmv_buf_size;
vb_pool_cfg.blk_cnt = sample_vdec[i].member_vdec_video.ref_frame_num + 1;
vb_pool_cfg.remap_mode = OT_VB_REMAP_MODE_NONE;
g_tmv_vb_pool[i] = ss_mpi_vb_create_pool(&vb_pool_cfg);
if (g_tmv_vb_pool[i] == OT_VB_INVALID_POOL_ID) {
return TD_FAILURE;
}
}
}
return TD_SUCCESS;
}
td_void sample_comm_handle_init_vb_fail(td_s32 idx)
{
td_s32 ret;
td_s32 i = idx;
for (; (i >= 0) && (i < OT_VB_MAX_POOLS); i--) {
if (g_pic_vb_pool[i] != OT_VB_INVALID_POOL_ID) {
ret = ss_mpi_vb_destroy_pool(g_pic_vb_pool[i]);
if (ret != TD_SUCCESS) {
printf("vb destroy pool %d fail!\n", g_pic_vb_pool[i]);
}
g_pic_vb_pool[i] = OT_VB_INVALID_POOL_ID;
}
if (g_tmv_vb_pool[i] != OT_VB_INVALID_POOL_ID) {
ret = ss_mpi_vb_destroy_pool(g_tmv_vb_pool[i]);
if (ret != TD_SUCCESS) {
printf("vb destroy pool %d fail!\n", g_tmv_vb_pool[i]);
}
g_tmv_vb_pool[i] = OT_VB_INVALID_POOL_ID;
}
}
return;
}
td_void sample_comm_vdec_cal_vb_size(td_u32 chn_num, struct_vdec_attr *sample_vdec,
td_u32 sample_vdec_arr_len, struct_vdec_buf *vdec_buf)
{
td_u32 i;
ot_pic_buf_attr buf_attr = { 0 };
for (i = 0; (i < chn_num) && (i < sample_vdec_arr_len); i++) {
buf_attr.align = 0;
buf_attr.height = sample_vdec[i].height;
buf_attr.width = sample_vdec[i].width;
if (sample_vdec[i].type == OT_PT_H265) {
buf_attr.bit_width = sample_vdec[i].member_vdec_video.bit_width;
buf_attr.pixel_format = OT_PIXEL_FORMAT_YVU_SEMIPLANAR_420;
vdec_buf[i].pic_buf_size = ot_vdec_get_pic_buf_size(sample_vdec[i].type, &buf_attr);
vdec_buf[i].tmv_buf_size =
ot_vdec_get_tmv_buf_size(sample_vdec[i].type, sample_vdec[i].width, sample_vdec[i].height);
} else if (sample_vdec[i].type == OT_PT_H264) {
buf_attr.bit_width = sample_vdec[i].member_vdec_video.bit_width;
buf_attr.pixel_format = OT_PIXEL_FORMAT_YVU_SEMIPLANAR_420;
vdec_buf[i].pic_buf_size = ot_vdec_get_pic_buf_size(sample_vdec[i].type, &buf_attr);
if (sample_vdec[i].member_vdec_video.dec_mode == OT_VIDEO_DEC_MODE_IPB) {
vdec_buf[i].tmv_buf_size =
ot_vdec_get_tmv_buf_size(sample_vdec[i].type, sample_vdec[i].width, sample_vdec[i].height);
}
} else {
buf_attr.bit_width = OT_DATA_BIT_WIDTH_8;
buf_attr.pixel_format = sample_vdec[i].member_vdec_picture.pixel_format;
vdec_buf[i].pic_buf_size = ot_vdec_get_pic_buf_size(sample_vdec[i].type, &buf_attr);
}
}
return;
}
td_s32 sample_comm_vdec_config_vb_pool(td_u32 chn_num, struct_vdec_attr *sample_vdec, td_u32 arr_len,
struct_vdec_buf *vdec_buf, ot_vb_cfg *vb_conf)
{
td_u32 i, j;
td_bool find_flag;
td_s32 pos = 0;
/* pic_buffer */
for (j = 0; j < OT_VB_MAX_COMMON_POOLS; j++) {
find_flag = TD_FALSE;
for (i = 0; (i < chn_num) && (i < arr_len); i++) {
if ((find_flag == TD_FALSE) && (vdec_buf[i].pic_buf_size != 0) && (vdec_buf[i].pic_buf_alloc == TD_FALSE)) {
vb_conf->common_pool[j].blk_size = vdec_buf[i].pic_buf_size;
vb_conf->common_pool[j].blk_cnt = sample_vdec[i].frame_buf_cnt;
vdec_buf[i].pic_buf_alloc = TD_TRUE;
find_flag = TD_TRUE;
pos = j;
}
if ((find_flag == TD_TRUE) && (vdec_buf[i].pic_buf_alloc == TD_FALSE) &&
(vb_conf->common_pool[j].blk_size == vdec_buf[i].pic_buf_size)) {
vb_conf->common_pool[j].blk_cnt += sample_vdec[i].frame_buf_cnt;
vdec_buf[i].pic_buf_alloc = TD_TRUE;
}
}
}
/* tmv_buffer */
for (j = pos + 1; j < OT_VB_MAX_COMMON_POOLS; j++) {
find_flag = TD_FALSE;
for (i = 0; (i < chn_num) && (i < arr_len); i++) {
if ((find_flag == TD_FALSE) && (vdec_buf[i].tmv_buf_size != 0) && (vdec_buf[i].tmv_buf_alloc == TD_FALSE)) {
vb_conf->common_pool[j].blk_size = vdec_buf[i].tmv_buf_size;
vb_conf->common_pool[j].blk_cnt = sample_vdec[i].member_vdec_video.ref_frame_num + 1;
vdec_buf[i].tmv_buf_alloc = TD_TRUE;
find_flag = TD_TRUE;
pos = j;
}
if ((find_flag == TD_TRUE) && (vdec_buf[i].tmv_buf_alloc == TD_FALSE) &&
(vb_conf->common_pool[j].blk_size == vdec_buf[i].tmv_buf_size)) {
vb_conf->common_pool[j].blk_cnt += sample_vdec[i].member_vdec_video.ref_frame_num + 1;
vdec_buf[i].tmv_buf_alloc = TD_TRUE;
}
}
}
vb_conf->max_pool_cnt = pos + 1;
return i - 1;
}
td_s32 sample_comm_vdec_init_vb_pool(td_u32 chn_num, struct_vdec_attr *sample_vdec, td_u32 arr_len)
{
ot_vb_cfg vb_conf;
td_s32 i, ret;
struct_vdec_buf vdec_buf[OT_VDEC_MAX_CHN_NUM];
check_null_ptr_return(sample_vdec);
if (arr_len > OT_VDEC_MAX_CHN_NUM) {
printf("struct_vdec_attr array len Invalid \n");
return TD_FAILURE;
}
(td_void)memset_s(vdec_buf, sizeof(vdec_buf), 0, sizeof(struct_vdec_buf) * OT_VDEC_MAX_CHN_NUM);
(td_void)memset_s(&vb_conf, sizeof(ot_vb_cfg), 0, sizeof(ot_vb_cfg));
sample_comm_vdec_cal_vb_size(chn_num, sample_vdec, arr_len, vdec_buf);
i = sample_comm_vdec_config_vb_pool(chn_num, sample_vdec, arr_len, vdec_buf, &vb_conf);
if (g_vdec_vb_src == OT_VB_SRC_MOD) {
ss_mpi_vb_exit_mod_common_pool(OT_VB_UID_VDEC);
check_return(ss_mpi_vb_set_mod_pool_cfg(OT_VB_UID_VDEC, &vb_conf), "vb set mod pool config");
ret = ss_mpi_vb_init_mod_common_pool(OT_VB_UID_VDEC);
if (ret != TD_SUCCESS) {
printf("vb exit mod common pool fail for 0x%x\n", ret);
ss_mpi_vb_exit_mod_common_pool(OT_VB_UID_VDEC);
return TD_FAILURE;
}
} else if (g_vdec_vb_src == OT_VB_SRC_USER) {
if (sample_comm_vdec_init_user_vb_pool(chn_num, &vdec_buf[0], &sample_vdec[0], OT_VDEC_MAX_CHN_NUM) !=
TD_SUCCESS) {
goto fail;
}
}
return TD_SUCCESS;
fail:
sample_comm_handle_init_vb_fail(i);
return TD_FAILURE;
}
td_void sample_comm_vdec_exit_user_vb_pool(td_void)
{
td_s32 i, ret;
for (i = OT_VB_MAX_POOLS - 1; i >= 0; i--) {
if (g_pic_vb_pool[i] != OT_VB_INVALID_POOL_ID) {
ret = ss_mpi_vb_destroy_pool(g_pic_vb_pool[i]);
if (ret != TD_SUCCESS) {
printf("vb destroy pool %d fail!\n", g_pic_vb_pool[i]);
}
g_pic_vb_pool[i] = OT_VB_INVALID_POOL_ID;
}
if (g_tmv_vb_pool[i] != OT_VB_INVALID_POOL_ID) {
ret = ss_mpi_vb_destroy_pool(g_tmv_vb_pool[i]);
if (ret != TD_SUCCESS) {
printf("vb destroy pool %d fail!\n", g_tmv_vb_pool[i]);
}
g_tmv_vb_pool[i] = OT_VB_INVALID_POOL_ID;
}
}
return;
}
td_void sample_comm_vdec_exit_vb_pool(td_void)
{
if (g_vdec_vb_src == OT_VB_SRC_MOD) {
ss_mpi_vb_exit_mod_common_pool(OT_VB_UID_VDEC);
} else if (g_vdec_vb_src == OT_VB_SRC_USER) {
sample_comm_vdec_exit_user_vb_pool();
}
return;
}
td_void sample_comm_vdec_send_h264_frame_process(td_s32 *read_len, td_u8 *buf,
struct_vdec_thread_param *thread_param, td_s32 used_bytes)
{
td_s32 i;
td_bool find_start = TD_FALSE;
td_bool find_end = TD_FALSE;
td_bool new_pic;
/* H264 frame start marker */
if (*read_len > thread_param->min_buf_size) {
sample_print("chn %d read_len %d is bigger than buf_size %u!\n", thread_param->chn_id, *read_len,
thread_param->min_buf_size);
return;
}
for (i = 0; i < *read_len - 8; i++) { /* 8:h264 frame start code length */
int tmp = buf[i + 3] & 0x1F; /* 3:index 0x1F:frame start marker */
new_pic = (buf[i] == 0 && buf[i + 1] == 0 && buf[i + 2] == 1 && /* 1 2:index */
(((tmp == 0x5 || tmp == 0x1) && ((buf[i + 4] & 0x80) == 0x80)) || /* 4:index 0x5 0x80:frame start mark */
(tmp == 20 && (buf[i + 7] & 0x80) == 0x80))); /* 20 0x1 0x80:frame start marker 7:index */
if (new_pic == TD_TRUE) {
find_start = TD_TRUE;
i += 8; /* 8:h264 frame start code length */
break;
}
}
for (; i < *read_len - 8; i++) { /* 8:h264 frame start code length */
int tmp = buf[i + 3] & 0x1F; /* 3:index 0x1F:frame start marker */
new_pic = (buf[i] == 0 && buf[i + 1] == 0 && buf[i + 2] == 1 && /* 1 2:index */
(tmp == 15 || tmp == 7 || tmp == 8 || tmp == 6 || /* 15 7 8 6:frame start marker */
((tmp == 5 || tmp == 1) && ((buf[i + 4] & 0x80) == 0x80)) || /* 4:index 5 0x80:frame start marker */
(tmp == 20 && (buf[i + 7] & 0x80) == 0x80))); /* 7:index 20 0x80:frame start marker */
if (new_pic == TD_TRUE) {
find_end = TD_TRUE;
break;
}
}
if (i > 0) {
*read_len = i;
}
if (find_start == TD_FALSE) {
sample_print("chn %d can not find H264 start code! read_len %d, used_bytes %d!\n", thread_param->chn_id,
*read_len, used_bytes);
}
if (find_end == TD_FALSE) {
*read_len = i + 8; /* 8:h264 frame start code length */
}
return;
}
td_void sample_comm_vdec_send_mpeg4_frame_process(td_s32 *read_len, td_u8 *buf,
struct_vdec_thread_param *thread_param, td_s32 used_bytes)
{
td_s32 i;
td_bool find_start = TD_FALSE;
td_bool find_end = TD_FALSE;
/* MPEG4 frame start marker */
if (*read_len > thread_param->min_buf_size) {
sample_print("chn %d read_len %d is bigger than buf_size %u!\n", thread_param->chn_id, *read_len,
thread_param->min_buf_size);
return;
}
for (i = 0; i < *read_len - 4; i++) { /* 4:mpeg4 frame start code length */
if (buf[i] == 0 && buf[i + 1] == 0 &&
buf[i + 2] == 1 && buf[i + 3] == 0xB6) { /* 0xB6:frame start marker 2 3:index */
find_start = TD_TRUE;
i += 4; /* 4:mpeg4 frame start code length */
break;
}
}
for (; i < *read_len - 4; i++) { /* 4:mpeg4 frame start code length */
if (buf[i] == 0 && buf[i + 1] == 0 &&
buf[i + 2] == 1 && buf[i + 3] == 0xB6) { /* 2 3:index 0xB6:frame start marker */
find_end = TD_TRUE;
break;
}
}
if (i > 0) {
*read_len = i;
}
if (find_start == TD_FALSE) {
sample_print("chn %d can not find MPEG4 start code! read_len %d, used_bytes %d!\n", thread_param->chn_id,
*read_len, used_bytes);
}
if (find_end == TD_FALSE) {
*read_len = i + 4; /* 4:mpeg4 frame start code length */
}
return;
}
td_void sample_comm_vdec_send_h265_frame_process(td_s32 *read_len, td_u8 *buf,
struct_vdec_thread_param *thread_param, td_s32 used_bytes)
{
td_s32 i;
td_bool find_start = TD_FALSE;
td_bool find_end = TD_FALSE;
/* H265 frame start marker */
td_bool new_pic;
if (*read_len > thread_param->min_buf_size) {
sample_print("chn %d read_len %d is bigger than buf_size %u!\n", thread_param->chn_id, *read_len,
thread_param->min_buf_size);
return;
}
for (i = 0; i < *read_len - 6; i++) { /* 6:h265 frame start code length */
td_u32 tmp = (buf[i + 3] & 0x7E) >> 1; /* 0x7E:frame start marker 3:index */
new_pic = (buf[i + 0] == 0 && buf[i + 1] == 0 && buf[i + 2] == 1 && /* 1 2:index */
(tmp <= 21) && ((buf[i + 5] & 0x80) == 0x80)); /* 5:index 21 0x80:frame start marker */
if (new_pic) {
find_start = TD_TRUE;
i += 6; /* 6:h265 frame start code length */
break;
}
}
for (; i < *read_len - 6; i++) { /* 6:h265 frame start code length */
td_u32 tmp = (buf[i + 3] & 0x7E) >> 1; /* 0x7E:frame start marker 3:index */
new_pic = (buf[i + 0] == 0 && buf[i + 1] == 0 && buf[i + 2] == 1 && /* 1 2:index */
(tmp == 32 || tmp == 33 || tmp == 34 || tmp == 39 || tmp == 40 || /* 32 33 34 39 40:frame start marker */
((tmp <= 21) && (buf[i + 5] & 0x80) == 0x80))); /* 5:index 21 0x80:frame start marker */
if (new_pic) {
find_end = TD_TRUE;
break;
}
}
if (i > 0) {
*read_len = i;
}
if (find_start == TD_FALSE) {
sample_print("chn %d can not find H265 start code! read_len %d, used_bytes %d!\n", thread_param->chn_id,
*read_len, used_bytes);
}
if (find_end == TD_FALSE) {
*read_len = i + 6; /* 6:h265 frame start code length */
}
return;
}
td_u32 sample_comm_vdec_send_jpeg_frame_process(td_s32 *read_len, td_u8 *buf,
struct_vdec_thread_param *thread_param, td_s32 used_bytes)
{
td_s32 i;
td_u32 len;
td_u32 start = 0;
td_bool find_start = TD_FALSE;
if (*read_len > thread_param->min_buf_size) {
sample_print("chn %d read_len %d is bigger than buf_size %u!\n", thread_param->chn_id, *read_len,
thread_param->min_buf_size);
return start;
}
/* JPEG frame start marker */
for (i = 0; i < *read_len - 1; i++) {
if (buf[i] == 0xFF && buf[i + 1] == 0xD8) { /* 0xFF 0xD8:frame start marker */
start = i;
find_start = TD_TRUE;
i = i + 2; /* 2:offset */
break;
}
}
for (; i < *read_len - 3; i++) { /* 3:jpeg frame start code length */
if ((buf[i] == 0xFF) && (buf[i + 1] & 0xF0) == 0xE0) { /* 0xFF 0xF0 0xE0:frame start marker */
len = (buf[i + 2] << 8) + buf[i + 3]; /* 2 3:index 8:left shift length */
i += 1 + len;
} else {
break;
}
}
for (; i < *read_len - 1; i++) {
if (buf[i] == 0xFF && buf[i + 1] == 0xD9) { /* 0xFF 0xD9:frame start marker */
break;
}
}
*read_len = i + 2; /* 2:offset */
if (find_start == TD_FALSE) {
sample_print("chn %d can not find JPEG start code! read_len %d, used_bytes %d!\n", thread_param->chn_id,
*read_len, used_bytes);
}
return start;
}
td_u32 sample_comm_vdec_cut_frame(td_s32 *read_len, td_u8 *buf, struct_vdec_thread_param *thread_param,
td_s32 used_bytes, td_bool *end_of_stream)
{
td_u32 start = 0;
if ((thread_param->stream_mode == OT_VDEC_SEND_MODE_FRAME ||
thread_param->stream_mode == OT_VDEC_SEND_MODE_COMPAT) && thread_param->type == OT_PT_H264) {
sample_comm_vdec_send_h264_frame_process(read_len, buf, thread_param, used_bytes);
} else if ((thread_param->stream_mode == OT_VDEC_SEND_MODE_FRAME ||
thread_param->stream_mode == OT_VDEC_SEND_MODE_COMPAT) && thread_param->type == OT_PT_H265) {
sample_comm_vdec_send_h265_frame_process(read_len, buf, thread_param, used_bytes);
} else if ((thread_param->stream_mode == OT_VDEC_SEND_MODE_FRAME ||
thread_param->stream_mode == OT_VDEC_SEND_MODE_COMPAT) && thread_param->type == OT_PT_MP4VIDEO) {
sample_comm_vdec_send_mpeg4_frame_process(read_len, buf, thread_param, used_bytes);
} else if ((thread_param->stream_mode == OT_VDEC_SEND_MODE_FRAME ||
thread_param->stream_mode == OT_VDEC_SEND_MODE_COMPAT) && (thread_param->type == OT_PT_MJPEG ||
thread_param->type == OT_PT_JPEG)) {
start = sample_comm_vdec_send_jpeg_frame_process(read_len, buf, thread_param, used_bytes);
} else {
if ((*read_len != 0) && (*read_len < thread_param->min_buf_size)) {
*end_of_stream = TD_TRUE;
}
}
return start;
}
td_void sample_comm_vdec_send_stream_proc(struct_vdec_thread_param *thread_param,
ot_vdec_stream *stream, td_bool end_of_stream)
{
td_s32 ret;
td_s32 total_len = stream->len;
td_s32 cur_len = 0;
td_s32 i;
td_u8 *base = stream->addr;
td_s32 cnt = (thread_param->stream_mode == OT_VDEC_SEND_MODE_COMPAT) ? SEND_STREAM_CNT : 1;
for (i = 0; i < cnt; i++) {
stream->addr = base + cur_len;
if (i == cnt - 1) {
stream->len = total_len - cur_len;
stream->end_of_frame = TD_TRUE;
stream->end_of_stream = end_of_stream;
} else {
stream->len = total_len / cnt;
cur_len += stream->len;
stream->end_of_frame = TD_FALSE;
stream->end_of_stream = TD_FALSE;
}
ret = ss_mpi_vdec_send_stream(thread_param->chn_id, stream, thread_param->milli_sec);
while ((ret != TD_SUCCESS) && (thread_param->e_thread_ctrl == THREAD_CTRL_START)) {
usleep(thread_param->interval_time);
ret = ss_mpi_vdec_send_stream(thread_param->chn_id, stream, thread_param->milli_sec);
}
}
}
td_void sample_comm_vdec_handle_send_stream(struct_vdec_thread_param *thread_param, ot_vdec_stream *stream,
td_bool *end_of_stream, td_u64 *pts)
{
td_u64 cur_time;
while (1) {
if (thread_param->e_thread_ctrl != THREAD_CTRL_START) {
break;
}
ss_mpi_sys_get_cur_pts(&cur_time);
if ((thread_param->last_time == 0) ||
((cur_time - thread_param->last_time) >= (VDEC_SECOND / thread_param->fps - thread_param->time_gap))) {
sample_comm_vdec_send_stream_proc(thread_param, stream, *end_of_stream);
*end_of_stream = TD_FALSE;
*pts += thread_param->pts_increase;
if (thread_param->last_time != 0) {
thread_param->time_gap =
((cur_time - thread_param->last_time) >= (VDEC_SECOND / thread_param->fps)) ?
(cur_time - thread_param->last_time - (VDEC_SECOND / thread_param->fps)) : 0;
thread_param->time_gap = (thread_param->time_gap > (VDEC_SECOND / thread_param->fps)) ?
(VDEC_SECOND / thread_param->fps) : thread_param->time_gap;
}
thread_param->last_time = cur_time;
break;
} else {
usleep(thread_param->interval_time);
}
}
return;
}
td_void sample_comm_vdec_send_stream_process(struct_vdec_thread_param *thread_param, FILE *fp_strm,
td_u8 *buf)
{
td_bool end_of_stream;
td_s32 used_bytes = 0;
td_s32 read_len;
td_u64 pts = thread_param->pts_init;
td_u32 start;
ot_vdec_stream stream;
thread_param->last_time = 0;
thread_param->time_gap = 0;
while (1) {
if (thread_param->e_thread_ctrl == THREAD_CTRL_STOP) {
break;
} else if (thread_param->e_thread_ctrl == THREAD_CTRL_PAUSE) {
sleep(1);
continue;
}
end_of_stream = TD_FALSE;
fseek(fp_strm, used_bytes, SEEK_SET);
read_len = fread(buf, 1, thread_param->min_buf_size, fp_strm);
if (read_len == 0) {
if (thread_param->circle_send == TD_TRUE) {
(td_void)memset_s(&stream, sizeof(ot_vdec_stream), 0, sizeof(ot_vdec_stream));
stream.end_of_stream = TD_TRUE;
ss_mpi_vdec_send_stream(thread_param->chn_id, &stream, -1);
used_bytes = 0;
fseek(fp_strm, 0, SEEK_SET);
read_len = fread(buf, 1, thread_param->min_buf_size, fp_strm);
} else {
break;
}
}
start = sample_comm_vdec_cut_frame(&read_len, buf, thread_param, used_bytes, &end_of_stream);
stream.pts = pts;
stream.addr = buf + start;
stream.len = read_len;
stream.end_of_frame = (thread_param->stream_mode == OT_VDEC_SEND_MODE_FRAME ||
thread_param->stream_mode == OT_VDEC_SEND_MODE_COMPAT) ? TD_TRUE : TD_FALSE;
stream.end_of_stream = end_of_stream;
stream.need_display = 1;
sample_comm_vdec_handle_send_stream(thread_param, &stream, &end_of_stream, &pts);
used_bytes += read_len + start;
}
return;
}
td_s32 sample_comm_vdec_check_send_stream_param(struct_vdec_thread_param *thread_param,
td_char *c_stream_file, td_u32 arr_len)
{
if (thread_param->c_file_path == TD_NULL || thread_param->c_file_name == TD_NULL) {
sample_print("chn %d stream file path or stream file name is NULL\n", thread_param->chn_id);
return TD_FAILURE;
}
if (arr_len <= 1) {
sample_print("chn %d arr length might be overflow\n", thread_param->chn_id);
return TD_FAILURE;
}
if (snprintf_s(c_stream_file, arr_len, arr_len - 1, "%s/%s", thread_param->c_file_path,
thread_param->c_file_name) < 0) {
sample_print("chn %d config stream file failed!\n", thread_param->chn_id);
return TD_FAILURE;
}
if (thread_param->min_buf_size <= 0) {
sample_print("chn %d min_buf_size should greater than zero!\n", thread_param->chn_id);
return TD_FAILURE;
}
if (thread_param->fps <= 0 || thread_param->fps > 300) { /* 0~300:frame rate limit */
sample_print("chn %d fps should be [1, 300]!\n", thread_param->chn_id);
return TD_FAILURE;
}
return TD_SUCCESS;
}
td_void *sample_comm_vdec_send_stream(td_void *args)
{
struct_vdec_thread_param *thread_param = (struct_vdec_thread_param *)args;
FILE *fp_strm = TD_NULL;
td_u8 *buf = TD_NULL;
ot_vdec_stream stream;
td_char c_stream_file[FILE_NAME_LEN];
td_char *path = TD_NULL;
prctl(PR_SET_NAME, "video_send_stream", 0, 0, 0);
if (sample_comm_vdec_check_send_stream_param(thread_param, c_stream_file, FILE_NAME_LEN) != TD_SUCCESS) {
return (td_void *)(TD_FAILURE);
}
path = realpath(c_stream_file, TD_NULL);
if (path == TD_NULL) {
sample_print("chn %d Invalid stream path. Please check!\n", thread_param->chn_id);
return (td_void *)(TD_FAILURE);
}
fp_strm = fopen(path, "rb");
if (fp_strm == TD_NULL) {
sample_print("chn %d can't open file %s in send stream thread!\n", thread_param->chn_id, c_stream_file);
goto end1;
}
printf("\n \033[0;36m chn %d, stream file:%s, userbufsize: %d \033[0;39m\n", thread_param->chn_id,
thread_param->c_file_name, thread_param->min_buf_size);
buf = malloc(thread_param->min_buf_size);
if (buf == TD_NULL) {
sample_print("chn %d can't alloc %d in send stream thread!\n",
thread_param->chn_id, thread_param->min_buf_size);
goto end;
}
fflush(stdout);
sample_comm_vdec_send_stream_process(thread_param, fp_strm, buf);
/* send the flag of stream end */
(td_void)memset_s(&stream, sizeof(ot_vdec_stream), 0, sizeof(ot_vdec_stream));
stream.end_of_stream = TD_TRUE;
ss_mpi_vdec_send_stream(thread_param->chn_id, &stream, -1);
printf("\033[0;35m chn %d send steam thread return ... \033[0;39m\n", thread_param->chn_id);
fflush(stdout);
if (buf != TD_NULL) {
free(buf);
buf = TD_NULL;
}
end:
fclose(fp_strm);
fp_strm = TD_NULL;
end1:
free(path);
path = TD_NULL;
return (td_void *)TD_SUCCESS;
}
td_void sample_comm_vdec_cmd_not_circle_send(td_u32 chn_num, struct_vdec_thread_param *vdec_send,
pthread_t *vdec_thread, td_u32 send_arr_len, td_u32 thread_arr_len)
{
td_u32 i;
td_s32 ret;
ot_vdec_chn_status status;
printf("decoding..............");
for (i = 0; (i < chn_num) && (i < send_arr_len) && (i < thread_arr_len); i++) {
if (vdec_thread[i] != 0) {
ret = pthread_join(vdec_thread[i], TD_NULL);
if (ret == 0) {
vdec_thread[i] = 0;
}
}
vdec_thread[i] = 0;
while (1) {
ret = ss_mpi_vdec_query_status(vdec_send[i].chn_id, &status);
if (ret != TD_SUCCESS) {
printf("chn %d vdec query status fail!!\n", ret);
return;
}
if ((status.left_stream_bytes == 0) && (status.left_stream_frames == 0)) {
sample_comm_vdec_print_chn_status(vdec_send[i].chn_id, status);
break;
}
usleep(1000); /* 1000:Decoding wait time */
}
}
printf("end!\n");
return;
}
td_void sample_comm_vdec_start_send_stream(td_s32 chn_num, struct_vdec_thread_param *vdec_send,
pthread_t *vdec_thread, td_u32 send_arr_len, td_u32 thread_arr_len)
{
td_u32 i;
if ((vdec_send == TD_NULL) || (vdec_thread == TD_NULL)) {
printf("vdec_send or vdec_thread can't be NULL!\n");
return;
}
for (i = 0; (i < (td_u32)chn_num) && (i < send_arr_len) && (i < thread_arr_len); i++) {
vdec_thread[i] = 0;
pthread_create(&vdec_thread[i], 0, sample_comm_vdec_send_stream, (td_void *)&vdec_send[i]);
}
}
td_void sample_comm_vdec_stop_send_stream(td_s32 chn_num, struct_vdec_thread_param *vdec_send,
pthread_t *vdec_thread, td_u32 send_arr_len, td_u32 thread_arr_len)
{
td_u32 i;
if ((vdec_send == TD_NULL) || (vdec_thread == TD_NULL)) {
printf("vdec_send or vdec_thread can't be NULL!\n");
return;
}
for (i = 0; (i < (td_u32)chn_num) && (i < send_arr_len) && (i < thread_arr_len); i++) {
vdec_send[i].e_thread_ctrl = THREAD_CTRL_STOP;
if (vdec_thread[i] != 0) {
pthread_join(vdec_thread[i], TD_NULL);
vdec_thread[i] = 0;
}
ss_mpi_vdec_stop_recv_stream(i);
}
}
td_void sample_comm_vdec_config_attr(ot_vdec_chn_attr *chn_attr, struct_vdec_attr *sample_vdec)
{
ot_pic_buf_attr buf_attr = { 0 };
chn_attr->type = sample_vdec->type;
chn_attr->mode = sample_vdec->mode;
chn_attr->pic_width = sample_vdec->width;
chn_attr->pic_height = sample_vdec->height;
chn_attr->stream_buf_size = sample_vdec->width * sample_vdec->height;
chn_attr->frame_buf_cnt = sample_vdec->frame_buf_cnt;
buf_attr.align = 0;
buf_attr.height = sample_vdec->height;
buf_attr.width = sample_vdec->width;
if (sample_vdec->type == OT_PT_H264 || sample_vdec->type == OT_PT_H265) {
buf_attr.bit_width = sample_vdec->member_vdec_video.bit_width;
buf_attr.pixel_format = OT_PIXEL_FORMAT_YVU_SEMIPLANAR_420;
chn_attr->video_attr.ref_frame_num = sample_vdec->member_vdec_video.ref_frame_num;
chn_attr->video_attr.temporal_mvp_en = 1;
if ((sample_vdec->type == OT_PT_H264) &&
(sample_vdec->member_vdec_video.dec_mode != OT_VIDEO_DEC_MODE_IPB)) {
chn_attr->video_attr.temporal_mvp_en = 0;
}
chn_attr->frame_buf_size = ot_vdec_get_pic_buf_size(chn_attr->type, &buf_attr);
} else if (sample_vdec->type == OT_PT_JPEG || sample_vdec->type == OT_PT_MJPEG) {
chn_attr->mode = OT_VDEC_SEND_MODE_FRAME;
buf_attr.bit_width = OT_DATA_BIT_WIDTH_8;
buf_attr.pixel_format = sample_vdec->member_vdec_picture.pixel_format;
chn_attr->frame_buf_size = ot_vdec_get_pic_buf_size(chn_attr->type, &buf_attr);
}
return;
}
td_s32 sample_comm_config_ldy_attr(td_s32 i, td_u32 height)
{
ot_low_delay_info ldy_attr;
if (g_vdec_line_ldy_en == TD_TRUE) {
check_chn_return(ss_mpi_vdec_get_low_delay_attr(i, &ldy_attr), i, "ss_mpi_vdec_get_low_delay_attr");
ldy_attr.enable = TD_TRUE;
ldy_attr.line_cnt = SAMPLE_VDEC_LOW_DELAY_LINE_CNT;
check_chn_return(ss_mpi_vdec_set_low_delay_attr(i, &ldy_attr), i, "ss_mpi_vdec_set_low_delay_attr");
check_chn_return(ss_mpi_vdec_set_display_mode(i, OT_VIDEO_DISPLAY_MODE_PREVIEW), i,
"ss_mpi_vdec_set_display_mode");
}
return TD_SUCCESS;
}
td_s32 sample_comm_vdec_start(td_s32 chn_num, struct_vdec_attr *sample_vdec, td_u32 arr_len)
{
td_s32 i, ret;
ot_vdec_chn_attr chn_attr[OT_VDEC_MAX_CHN_NUM];
ot_vdec_chn_pool pool;
ot_vdec_chn_param chn_param;
ot_vdec_mod_param mod_param;
check_null_ptr_return(sample_vdec);
if (arr_len > OT_VDEC_MAX_CHN_NUM) {
sample_print("array size(%u) of chn_attr need < %u!\n", arr_len, OT_VDEC_MAX_CHN_NUM);
return TD_FAILURE;
}
check_return(ss_mpi_vdec_get_mod_param(&mod_param), "vdec get mod param");
mod_param.vb_src = g_vdec_vb_src;
check_return(ss_mpi_vdec_set_mod_param(&mod_param), "vdec set mod param");
for (i = 0; (i < chn_num) && (i < (td_s32)arr_len); i++) {
sample_comm_vdec_config_attr(&chn_attr[i], &sample_vdec[i]);
check_chn_return(ss_mpi_vdec_create_chn(i, &chn_attr[i]), i, "vdec create chn");
if ((g_vdec_vb_src == OT_VB_SRC_USER) && (i < OT_VB_MAX_POOLS)) {
pool.pic_vb_pool = g_pic_vb_pool[i];
pool.tmv_vb_pool = g_tmv_vb_pool[i];
check_chn_return(ss_mpi_vdec_attach_vb_pool(i, &pool), i, "vdec attach vb pool");
}
check_chn_return(ss_mpi_vdec_get_chn_param(i, &chn_param), i, "vdec get chn param");
if (sample_vdec[i].type == OT_PT_H264 || sample_vdec[i].type == OT_PT_H265 ||
sample_vdec[i].type == OT_PT_MP4VIDEO) {
chn_param.video_param.dec_mode = sample_vdec[i].member_vdec_video.dec_mode;
chn_param.video_param.compress_mode = OT_COMPRESS_MODE_NONE;
chn_param.video_param.video_format = OT_VIDEO_FORMAT_LINEAR;
if (chn_param.video_param.dec_mode == OT_VIDEO_DEC_MODE_IPB) {
chn_param.video_param.out_order = OT_VIDEO_OUT_ORDER_DISPLAY;
} else {
chn_param.video_param.out_order = OT_VIDEO_OUT_ORDER_DEC;
}
chn_param.video_param.slice_input_en = sample_comm_vdec_get_lowdelay_en();
} else {
chn_param.pic_param.pixel_format = sample_vdec[i].member_vdec_picture.pixel_format;
chn_param.pic_param.alpha = sample_vdec[i].member_vdec_picture.alpha;
}
chn_param.display_frame_num = sample_vdec[i].display_frame_num;
check_chn_return(ss_mpi_vdec_set_chn_param(i, &chn_param), i, "vdec set chn param");
ret = sample_comm_config_ldy_attr(i, chn_attr[i].pic_height);
if (ret != TD_SUCCESS) {
return ret;
}
check_chn_return(ss_mpi_vdec_start_recv_stream(i), i, "vdec start recv stream");
}
return TD_SUCCESS;
}
td_s32 sample_comm_vdec_stop(td_s32 chn_num)
{
td_s32 i;
for (i = 0; i < chn_num; i++) {
check_chn_return(ss_mpi_vdec_stop_recv_stream(i), i, "vdec stop recv stream");
check_chn_return(ss_mpi_vdec_destroy_chn(i), i, "vdec destroy chn");
}
return TD_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink