JDK_BOOL JDK_vo_loss_fill_buffer(JDK_UINT32 chn,JDK_UINT32 nStream, JDK_BOOL isIDR)
{
return JDK_TRUE;
if(JDK_IS_BNC_CAM(chn)){
return JDK_TRUE;
}
if(s_buf_size <= 0){
if(JDK_load_user_picture(JDK_DEF_LOSS_NET_H264)<=0){
return JDK_FALSE;
}
}
char meida_name[64];
int key_frame_flag = 0;
SDK_ENC_BUF_ATTR_t attr;
memset(&attr, 0, sizeof(attr));
sprintf(meida_name,"ch%d_%d.264", chn, nStream);
int media_buf_id = MEDIABUF_lookup_byname(meida_name);
attr.magic = SDK_ENC_BUF_DATA_MAGIC;
attr.type = SDK_ENC_BUF_DATA_H264;
struct timeval tv;
gettimeofday(&tv, NULL);
guint64 aPtsUs = (guint64)tv.tv_sec * 1000000ULL + (guint64)tv.tv_usec;
attr.timestamp_us = aPtsUs;
attr.time_us = (unsigned long long)((aPtsUs/1000000ULL) << 32) + (unsigned long long)(aPtsUs%1000000ULL);
if (nStream == 0) {
attr.h264.keyframe = isIDR;
attr.h264.ref_counter = 0;
attr.h264.fps = 25;
attr.h264.width = 704;
attr.h264.height = 480;
key_frame_flag = isIDR;
} else {
attr.h264.keyframe = isIDR;
attr.h264.ref_counter = 0;
attr.h264.fps = 25;
attr.h264.width = 0;
attr.h264.height = 0;
key_frame_flag = isIDR;
}
attr.data_sz = s_buf_size;
MEDIABUF_in_request(media_buf_id, s_buf_size + sizeof(SDK_ENC_BUF_ATTR_t), key_frame_flag);
MEDIABUF_in_append(media_buf_id, &attr, sizeof(SDK_ENC_BUF_ATTR_t));
MEDIABUF_in_append(media_buf_id, s_buf, s_buf_size);
MEDIABUF_in_commit(media_buf_id);
return JDK_TRUE;
}
JDK_BOOL JDK_vo_fill_buffer_picture(JDK_UINT32 chn)
{
int i,n;
int stream_cnt = 2;
char meida_name[64];
int media_buf_id;
const n_max_loop_times = 20;
for(i=0;i<stream_cnt;i++){
int loop_time = 0;
sprintf(meida_name,"ch%d_%d.264", chn, i);
media_buf_id = MEDIABUF_lookup_byname(meida_name);
// while(loop_time < n_max_loop_times){
// ++loop_time;
// usleep(100000);
// }
MEDIABUF_empty(media_buf_id);
JDK_vo_loss_multi_fill_buffer(chn,i, TRUE,1);
JDK_vo_loss_multi_fill_buffer(chn,i, FALSE,3);
}
return JDK_TRUE;
}
void *gb28181_rtp_loop(void *param)
{
#define AUDIO_FRAME_SIZE 320
#define BUF_SIZE (1024*1024)
SipRtpSession_t *srtp=NULL;
Rtp_t *rtp = NULL;
int *trigger = (int *)param;
int i;
int entries=0;
uint8_t *buf=NULL;
uint8_t *ptr;
int out_success=false;
unsigned int base_ts=0xffffffff,ts=0;
unsigned int iRetSize=0;
lpMEDIABUF_USER media_user=NULL;
int media_id;
int is_first_i_frame = 1, i_frame_cnt = 0;
//
FILE *f=file_new("test.720p.264");
buf = (char *)malloc(BUF_SIZE);
if(buf == NULL){
printf("malloc for buffer size failed!\n");
return NULL;
}
while(*trigger){
entries = SIPRTP_session_entries();
if(entries > 0){
// init mediabuf
if(media_user == NULL){
media_id = MEDIABUF_lookup_byname("360p.264");
if(media_id >= 0){
media_user = MEDIABUF_attach(media_id);
if(media_user == NULL){
printf("media attach falied!\n");
usleep(500*1000);
continue;
}
//media_speed = MEDIABUF_in_speed(media_id);
MEDIABUF_sync(media_user);
is_first_i_frame = 1;
i_frame_cnt = 0;
}else{
printf("lookup name failed falied!\n");
usleep(500*1000);
continue;
}
}
/////////////////////////////
ptr = buf;
out_success = false;
if(0 == MEDIABUF_out_lock(media_user)){
const lpSDK_ENC_BUF_ATTR attr = NULL;
size_t out_size = 0;
if(0 == MEDIABUF_out(media_user, (void **)&attr, NULL, &out_size)){
const void* const raw_ptr = (void*)(attr + 1);
ssize_t const raw_size = attr->data_sz;
MEDIABUF_out_unlock(media_user);
if(is_first_i_frame && attr->h264.keyframe){
if(++i_frame_cnt >= 2){
is_first_i_frame = 0;
base_ts = (uint32_t)(attr->timestamp_us/1000);
}
}
if(i_frame_cnt < 2){
//MEDIABUF_out_unlock(media_user);
continue;
}
//if(base_ts == 0xffffffff) base_ts = (uint32_t)(attr->timestamp_us/1000);
if(((uint32_t)(attr->timestamp_us/1000) - base_ts -ts) > 50){
printf("ts dev:%d ts:%u->%u %u\n",(uint32_t)(attr->timestamp_us/1000) - base_ts -ts,ts,
(uint32_t)(attr->timestamp_us/1000) - base_ts,base_ts);
}
ts = (uint32_t)(attr->timestamp_us/1000) - base_ts;
if(kSDK_ENC_BUF_DATA_H264 == attr->type){
if(MPEG_muxer_video(raw_ptr,raw_size,ts,
MPEG_DEFAULT_VIDEO_STREAM,attr->h264.keyframe,ptr,BUF_SIZE,&iRetSize)==0)
{
entries = SIPRTP_session_entries();
for(i=0;i<entries;i++){
srtp = SIPRTP_session_get(i+1);
if(srtp->data.flag == TRUE){
//printf(">>>>>>index %d \n",i+1);
rtp = (Rtp_t *)srtp->data.context;
RTP_send_packet(rtp,ptr,iRetSize,ts,RTP_TYPE_PS);
out_success = true;
}
}
//file_write(f,ptr,iRetSize);
/*
Test264Frame2_t header;
header.flag = 0x7d22628c;
header.isidr = attr->h264.keyframe;
header.size = raw_size;
file_write(f,&header,sizeof(Test264Frame2_t));
file_write(f,raw_ptr,raw_size);
*/
ptr+=iRetSize;
}else{
printf("muxer video failed!\n");
break;
}
}/*
else if(kSDK_ENC_BUF_DATA_G711A == attr->type){
if(MPEG_muxer_audio(raw_ptr,raw_size,attr->timestamp_us/1000,
MPEG_DEFAULT_AUDIO_STREAM,ptr,&iRetSize)==0)
{
entries = SIPRTP_session_entries();
for(i=0;i<entries;i++){
srtp = SIPRTP_session_get(i+1);
if(srtp->data.flag == TRUE){
rtp = (Rtp_t *)srtp->data.context;
RTP_send_packet(rtp,ptr,iRetSize,attr->timestamp_us/1000,RTP_TYPE_PS);
}
}
ptr += iRetSize;
}else{
printf("muxer audio failed!\n");
break;
}
}*/
else {
printf("GB28181 got type=%d impossible\n", attr->type);
}
//MEDIABUF_out_unlock(media_user);
}else{
MEDIABUF_out_unlock(media_user);
//printf("out failed!\n");
usleep(1000);
}
}
}else{
if(media_user){
MEDIABUF_detach(media_user);
media_user = NULL;
base_ts = 0xffffffff;
}
usleep(10*1000);
}
}
printf("rtp loop exit!!!!\n");
if(media_user){
MEDIABUF_detach(media_user);
media_user = NULL;
}
free(buf);
return NULL;
}
SPOOK_SESSION_LOOP_t RTSPD_loop(uint32_t* trigger, int sock, time_t* read_pts, const void* msg, ssize_t msg_sz)
{
RtspdSession_t* session = NULL;
int i;
int ret = 0;
int first_request = 0;
int rtsp_req_complete = 0;
int rtsp_req_handle_ret = 0;
int rtcp_req_handle_ret = 0;
unsigned char* ptr = NULL;
int len = 0;
unsigned char buf[2048];
SOCKET_RW_CTX rw_ctx;
// H264_FILE_BUFFER* hfb = NULL;
struct timeval timeout;
fd_set read_set;
fd_set write_set;
int select_ret;
int rtcp_head_len = 0;
int rtcp_body_len = 0;
char file_name[64];
void* payload_ptr = NULL;
ssize_t payload_sz = 0;
int nalu_size;
int mediabuf_ch = 0;
MediaBufUser_t* user = NULL;
session = rtspd_create_session(trigger, sock, msg, msg_sz);
mediabuf_ch = MEDIABUF_lookup_byname(session->server_trace);
RTSPD_TRACE("connecting to mediabuf %d", mediabuf_ch);
if(mediabuf_ch < 0){
return SPOOK_LOOP_FAILURE;
}
user = MEDIABUF_user_attach(mediabuf_ch);
if(!user){
return SPOOK_LOOP_FAILURE;
}
//rtcp init
RTCP_init(session);
while(*session->trigger)
{
timeout.tv_sec = 0;
timeout.tv_usec = 50*1000;
FD_ZERO(&read_set);
FD_SET(session->sock, &read_set);
if(session->server_udp_sock1 > 0)
{
// RTSPD_TRACE("server_udp_sock1=%d", session->server_udp_sock1);
FD_SET(session->server_udp_sock1, &read_set);
}
if(first_request != 0)
{
#define MAX(a, b) ((a) > (b) ? (a) : (b))
select_ret = select(MAX(session->sock, session->server_udp_sock1)+ 1, &read_set, NULL, NULL, &timeout);
}
else
{
select_ret = 1;
}
if (select_ret < 0)
{
*session->trigger = 0;
// printf("read select error stop\n");
break;
}
else if(select_ret == 0)
{
// printf("read select timeout...\n");
}
else
{
if(first_request == 0 || FD_ISSET(session->sock, &read_set))
{
//´¦ÀíÉÏ´«
if(first_request == 0)
{
ptr = (unsigned char*)msg;
len = msg_sz;
first_request = 1;
}
else
{
SOCKETRW_rwinit(&rw_ctx, session->sock, buf, sizeof(buf), RTSPD_READ_TIMEOUT);
SOCKETRW_read(&rw_ctx);
if(rw_ctx.result != SOCKET_RW_RESULT_SUCCESS)
{
*session->trigger = 0;
break;
}
ptr = buf;
len = rw_ctx.actual_len;
}
for(i = 0; i < len; i++)
{
//rtcp over tcp
if(ptr[i] == '$') //rtcp start
{
session->request_sz = 0;
session->request_buf[session->request_sz] = ptr[i];
session->request_sz++;
rtcp_head_len = 3;
continue;
}
if(rtcp_head_len > 0) //rtcp head
{
session->request_buf[session->request_sz] = ptr[i];
session->request_sz++;
rtcp_head_len--;
if(rtcp_head_len == 0)
{
rtcp_body_len = *((unsigned char*)(session->request_buf+3)) | (*((unsigned char*)(session->request_buf+2)) << 8);
}
continue;
}
if(rtcp_body_len > 0) //rtcp body
{
session->request_buf[session->request_sz] = ptr[i];
session->request_sz++;
rtcp_body_len--;
if(rtcp_body_len == 0)
{
RTSPD_TRACE("found tcp rtcp len=%d p[0]=%02x p[1]=%02x p[2]=%02x p[3]=%02x",
rtcp_body_len, session->request_buf[0], session->request_buf[1], session->request_buf[2], session->request_buf[3]);
rtcp_req_handle_ret = RTCP_handle(session);
if(rtcp_req_handle_ret != 0)
{
*session->trigger = 0;
break;
}
if(session->response_sz > 0)
{
SOCKETRW_rwinit(&rw_ctx, session->sock, session->response_buf, session->response_sz, RTSPD_WRITE_TIMEOUT);
SOCKETRW_writen(&rw_ctx);
if(rw_ctx.result != SOCKET_RW_RESULT_SUCCESS)
{
*session->trigger = 0;
break;
}
}
session->response_sz = 0;
session->request_sz = 0;
}
continue;
}
//rtsp
session->request_buf[session->request_sz] = ptr[i];
session->request_sz++;
rtsp_req_complete = is_rtsp_req_complete(session->request_buf, session->request_sz);
if(rtsp_req_complete == 1)
{
session->request_buf[session->request_sz] = 0;
rtsp_req_handle_ret = RTSP_handle(session);
if(rtsp_req_handle_ret != 0)
{
*session->trigger = 0;
break;
}
if(session->response_sz > 0)
{
SOCKETRW_rwinit(&rw_ctx, session->sock, session->response_buf, session->response_sz, RTSPD_WRITE_TIMEOUT);
SOCKETRW_writen(&rw_ctx);
if(rw_ctx.result != SOCKET_RW_RESULT_SUCCESS)
{
*session->trigger = 0;
break;
}
}
session->response_sz = 0;
session->request_sz = 0;
}
}
}
if(FD_ISSET(session->server_udp_sock1, &read_set))
{
session->request_sz = recvfrom(session->server_udp_sock1, session->request_buf, sizeof(session->request_buf), 0, NULL, NULL);
if(session->request_sz > 0)
{
RTSPD_TRACE("found udp rtcp len=%d p[0]=%02x p[1]=%02x p[2]=%02x p[3]=%02x",
rtcp_body_len, session->request_buf[0], session->request_buf[1], session->request_buf[2], session->request_buf[3]);
rtcp_req_handle_ret = RTCP_handle(session);
if(rtcp_req_handle_ret != 0)
{
*session->trigger = 0;
break;
}
if(session->response_sz > 0)
{
//todo udp send backup
}
session->response_sz = 0;
session->request_sz = 0;
}
}
}
if(session->playing == RTSPD_PLAYING)
{
RTCP_schedule(session);
if(session->response_sz > 0)
{
SOCKETRW_rwinit(&rw_ctx, session->sock, session->response_buf, session->response_sz, RTSPD_WRITE_TIMEOUT);
SOCKETRW_writen(&rw_ctx);
if(rw_ctx.result != SOCKET_RW_RESULT_SUCCESS)
{
*session->trigger = 0;
break;
}
session->response_sz = 0;
}
if(0 == MEDIABUF_out_lock(user)){
ret = MEDIABUF_out(user, &payload_ptr, NULL, &payload_sz);
if(0 == ret){
RTP_packet_nalu(session, payload_ptr + sizeof(SDK_AVENC_BUF_ATTR_t), payload_sz - sizeof(SDK_AVENC_BUF_ATTR_t));
if(session->transport == RTP_OVER_TCP)
{
timeout.tv_sec = 0;
timeout.tv_usec = 10*1000;
FD_ZERO(&write_set);
FD_SET(session->sock, &write_set);
select_ret = select(session->sock + 1, NULL, &write_set, NULL, &timeout);
if (select_ret < 0)
{
*session->trigger = 0;
printf("write select error stop\n");
}
else if(select_ret == 0)
{
printf("write select timeout...\n");
}
else
{
for(i = 0; i < session->rtp_entries; ++i)
{
SOCKETRW_rwinit(&rw_ctx, session->sock, session->rtp_entry[i].ptr, session->rtp_entry[i].len, RTSPD_WRITE_TIMEOUT);
SOCKETRW_writen(&rw_ctx);
if(rw_ctx.result != SOCKET_RW_RESULT_SUCCESS)
{
*session->trigger = 0;
break;
}
}
}
}
else if(session->transport == RTP_UDP)
{
RTSPD_ASSERT(session->server_udp_sock0 != 0);
RTSPD_ASSERT(session->server_udp_sock1 != 0);
for(i = 0; i < session->rtp_entries; i++)
{
udp_send2(session, session->rtp_entry[i].ptr, session->rtp_entry[i].len,
session->client_ip, session->client_udp_port0);
}
}
}
MEDIABUF_out_unlock(user); // unlock the buf
if(!ret){
usleep(MEDIABUF_in_speed(user->pool_ch));
}
}
}
}
MEDIABUF_user_detach(user);
user = NULL;
close(session->sock);
if(session->transport == RTP_UDP)
{
close(session->server_udp_sock0);
close(session->server_udp_sock1);
}
rtspd_free_session(session);
return SPOOK_LOOP_SUCCESS;
}
