使用三方摄像头，实现pjsip的视频通话功能
提要：
近期一直在做视频通话功能，主要基于pjsip来实现的，将这些过程记录下来，可能对做同类型工作的同学有所帮助！
实现思路，参考pjsip原来设备采集视频、编码并rtp组包发送的思路，再在原有流程中做修改！
主要关键点：
1、摄像头采集完成后已经是已编码的H264/H265的流，不需要再开启pjsip的编码/解码流程；
2、组包发送，H264的FU-A组包、PS封装发送；
首先梳理流程，具体包括下面几个点：
1. 摄像头设备适配（这里可以考虑多个数据源，包括文件、socket或者摄像头的数据源；）
2. 参考android_dev.c 实现一个ov5000_dev.c
/* $Id$ */
/*
* Copyright (C) 2015 Teluu Inc. (http://www.teluu.com)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "util.h"
#include <pjmedia-videodev/videodev_imp.h>
#include <pj/assert.h>
#include <pj/log.h>
#include <pj/math.h>
#include <pj/os.h>
//#define ARM_LINUX
#define VIDEO_USE_SOCKET
extern void set_take_ps_packet(int enable_value);
int log_printf(int a,...)
{
return 0;
}
#define PJMEDIA_VIDEO_DEV_HAS_OV5000 1
#if defined(PJMEDIA_HAS_VIDEO) && PJMEDIA_HAS_VIDEO != 0 && \
defined(PJMEDIA_VIDEO_DEV_HAS_OV5000)
#define THIS_FILE "ov5000_dev.c"
/* Default video params */
#define DEFAULT_CLOCK_RATE 90000
#define DEFAULT_WIDTH 352
#define DEFAULT_HEIGHT 288
#define DEFAULT_FPS 15
#define ALIGN16(x) ((((x)+15) >> 4) << 4)
/* Define whether we should maintain the aspect ratio when rotating the image.
* For more details, please refer to util.h.
*/
#define MAINTAIN_ASPECT_RATIO PJ_TRUE
#define JNIEnv (void *)
/* Format map info */
typedef struct ov5000_fmt_map
{
pjmedia_format_id fmt_id;
pj_uint32_t ov5000_fmt_id;
} ov5000_fmt_map;
/* Format map.
* Note: it seems that most of Ov5000 devices don't support I420, while
* unfortunately, our converter (libyuv based) only support I420 & RGBA,
* so in this case, we'd just pretend that we support I420 and we'll do
* the NV21/YV12 -> I420 conversion here.
*/
static ov5000_fmt_map fmt_map[] =
{
{PJMEDIA_FORMAT_NV21, 0x00000011},
{PJMEDIA_FORMAT_YV12, 0x32315659},
{PJMEDIA_FORMAT_I420, 0x00000023}, /* YUV_420_888 */
};
/* Device info */
typedef struct ov5000_dev_info
{
pjmedia_vid_dev_info info; /**< Base info */
unsigned dev_idx; /**< Original dev ID */
pj_bool_t facing; /**< Front/back camera?*/
unsigned sup_size_cnt; /**< # of supp'd size */
pjmedia_rect_size *sup_size; /**< Supported size */
unsigned sup_fps_cnt; /**< # of supp'd FPS */
pjmedia_rect_size *sup_fps; /**< Supported FPS */
pj_bool_t has_yv12; /**< Support YV12? */
pj_bool_t has_nv21; /**< Support NV21? */
pj_bool_t forced_i420; /**< Support I420 with
conversion */
} ov5000_dev_info;
/* Video factory */
typedef struct ov5000_factory
{
pjmedia_vid_dev_factory base; /**< Base factory */
pj_pool_t *pool; /**< Memory pool */
pj_pool_factory *pf; /**< Pool factory */
pj_pool_t *dev_pool; /**< Device list pool */
unsigned dev_count; /**< Device count */
ov5000_dev_info *dev_info; /**< Device info list */
} ov5000_factory;
/* Video stream. */
typedef struct ov5000_stream
{
pjmedia_vid_dev_stream base; /**< Base stream */
pjmedia_vid_dev_param param; /**< Settings */
pj_pool_t *pool; /**< Memory pool */
ov5000_factory *factory; /**< Factory */
pjmedia_vid_dev_cb vid_cb; /**< Stream callback */
void *user_data; /**< Application data */
pj_bool_t is_running; /**< Stream running? */
void* jcam; /**< PjCamera instance */
pj_timestamp frame_ts; /**< Current timestamp */
unsigned ts_inc; /**< Timestamp interval*/
unsigned convert_to_i420; /**< Need to convert to I420?
0: no
1: from NV21
2: from YV12 */
/** Capture thread info */
pj_bool_t thread_initialized;
pj_thread_desc thread_desc;
pj_thread_t *thread;
/** NV21/YV12 -> I420 Conversion buffer */
pj_uint8_t *convert_buf;
pjmedia_rect_size cam_size;
/** Converter to rotate frame */
pjmedia_vid_dev_conv conv;
//
pj_uint8_t *sps_pps;
int sps_pps_p_index;
int pps_len;
int sps_pps_len;
int recive_video_packet_count;
/** Frame format param for NV21/YV12 -> I420 conversion */
pjmedia_video_apply_fmt_param vafp;
//capture thread.
pj_thread_t *ca_thread;
} ov5000_stream;
/* Prototypes */
static pj_status_t ov5000_factory_init(pjmedia_vid_dev_factory *f);
static pj_status_t ov5000_factory_destroy(pjmedia_vid_dev_factory *f);
static pj_status_t ov5000_factory_refresh(pjmedia_vid_dev_factory *f);
static unsigned ov5000_factory_get_dev_count(pjmedia_vid_dev_factory *f);
static pj_status_t ov5000_factory_get_dev_info(pjmedia_vid_dev_factory *f,
unsigned index,
pjmedia_vid_dev_info *info);
static pj_status_t ov5000_factory_default_param(pj_pool_t *pool,
pjmedia_vid_dev_factory *f,
unsigned index,
pjmedia_vid_dev_param *param);
static pj_status_t ov5000_factory_create_stream(
pjmedia_vid_dev_factory *f,
pjmedia_vid_dev_param *param,
const pjmedia_vid_dev_cb *cb,
void *user_data,
pjmedia_vid_dev_stream **p_vid_strm);
static pj_status_t ov5000_stream_get_param(pjmedia_vid_dev_stream *strm,
pjmedia_vid_dev_param *param);
static pj_status_t ov5000_stream_get_cap(pjmedia_vid_dev_stream *strm,
pjmedia_vid_dev_cap cap,
void *value);
static pj_status_t ov5000_stream_set_cap(pjmedia_vid_dev_stream *strm,
pjmedia_vid_dev_cap cap,
const void *value);
static pj_status_t ov5000_stream_start(pjmedia_vid_dev_stream *strm);
static pj_status_t ov5000_stream_stop(pjmedia_vid_dev_stream *strm);
static pj_status_t ov5000_stream_destroy(pjmedia_vid_dev_stream *strm);
static void OnGetFrame2(uint8_t* data, int length, void* user_data);
/* Operations */
static pjmedia_vid_dev_factory_op factory_op =
{
&ov5000_factory_init,
&ov5000_factory_destroy,
&ov5000_factory_get_dev_count,
&ov5000_factory_get_dev_info,
&ov5000_factory_default_param,
&ov5000_factory_create_stream,
&ov5000_factory_refresh
};
static pjmedia_vid_dev_stream_op stream_op =
{
&ov5000_stream_get_param,
&ov5000_stream_get_cap,
&ov5000_stream_set_cap,
&ov5000_stream_start,
NULL,
NULL,
&ov5000_stream_stop,
&ov5000_stream_destroy
};
#endif /* PJMEDIA_VIDEO_DEV_HAS_Ov5000 */3. ov5000_dev摄像头采集的数据最终会回调到strm->vid_cb.capture_cb ，这个回调方法是video_port.c中的vidstream_cap_cb方法；
static void copy_frame_to_buffer(pjmedia_vid_port *vp,
pjmedia_frame *frame)
{
if (frame == NULL){
return;
}
pj_mutex_lock(vp->frm_mutex);
#if PJMEDIA_VIDEO_DEV_HAS_OV5000
//PJ_LOG(4, (THIS_FILE, "-1--copy_frame_to_buffer: frame.size:%d, %d len", frame->size, vp->frm_buf->size));
#if 1
if (vp->frm_buf == NULL){
pj_mutex_unlock(vp->frm_mutex);
return;
}
ringput(frame->buf, frame->size, 0);
vp->frm_buf->size = frame->size;
vp->frm_buf->type = frame->type;
vp->frm_buf->timestamp = frame->timestamp;
vp->frm_buf->bit_info = frame->bit_info;
#else
//direct put frame?
pjmedia_frame_copy(vp->frm_buf, frame);
#endif
#endif//
pj_mutex_unlock(vp->frm_mutex);
}另外，vid_port中的frm_buf缓存数据太少，数据帧存在明显的跳帧现象，所以参考之前的fifobuffer思路，实现了一个fifobuffer;
//add for ring buffer
#if PJMEDIA_VIDEO_DEV_HAS_OV5000
pthread_mutex_t ring_mutex;
struct ringbuf {
unsigned char *buffer;
int frame_type;
int size;
};
static int addring (int i);
static int ringget(struct ringbuf *getinfo);
static void ringput(unsigned char *buffer,int size,int encode_type);
static void ringfree();
static void ringmalloc(int size);
static void ringreset();
#define NMAX 10//30
#define RING_BUFFER_SIZE 145000//50000
static volatile int iput = 0; /* */
static volatile int iget = 0; /* */
static volatile int n = 0; /* */
#define USE_MALLOC_MEM
#ifndef USE_MALLOC_MEM
static uint8_t mem_buffer[RING_BUFFER_SIZE*NMAX];
#endif
static volatile struct ringbuf ringfifo[NMAX];
static volatile int init_flag = 0;
static void ringmalloc(int size)
{
int i;
#ifdef USE_MALLOC_MEM
//
pthread_mutex_init(&ring_mutex, 0);
if (init_flag){
return;
}
for(i =0; i<NMAX; i++)
{
ringfifo[i].buffer = malloc(size);
ringfifo[i].size = 0;
ringfifo[i].frame_type = 0;
// printf("FIFO INFO:idx:%d,len:%d,ptr:%x\n",i,ringfifo[i].size,(int)(ringfifo[i].buffer));
}
init_flag = 1;
#else
for(i =0; i<NMAX; i++)
{
ringfifo[i].buffer = &mem_buffer[i*RING_BUFFER_SIZE];
ringfifo[i].size = 0;
ringfifo[i].frame_type = 0;
// printf("FIFO INFO:idx:%d,len:%d,ptr:%x\n",i,ringfifo[i].size,(int)(ringfifo[i].buffer));
}
#endif
iput = 0; /* ?隆陇D??o3???娄脤?娄脤隆脌?隆茫隆陇?篓篓????? */
iget = 0; /* ?o3???娄脤?娄脤隆脌?隆茫篓篓?3????? */
n = 0; /* ?隆陇D??o3????D娄脤??a??隆脕篓鹿篓潞y篓垄? */
}
/**************************************************************************************************
**
**
**
**************************************************************************************************/
static void ringreset()
{
pthread_mutex_lock(&ring_mutex);
iput = 0; /* ?隆陇D??o3???娄脤?娄脤隆脌?隆茫隆陇?篓篓????? */
iget = 0; /* ?o3???娄脤?娄脤隆脌?隆茫篓篓?3????? */
n = 0; /* ?隆陇D??o3????D娄脤??a??隆脕篓鹿篓潞y篓垄? */
pthread_mutex_unlock(&ring_mutex);
}
/**************************************************************************************************
**
**
**
**************************************************************************************************/
static void ringfree(void)
{
int i;
printf("begin free mem\n");
for(i =0; i<NMAX; i++)
{
// printf("FREE FIFO INFO:idx:%d,len:%d,ptr:%x\n",i,ringfifo[i].size,(int)(ringfifo[i].buffer));
#ifdef USE_MALLOC_MEM
free(ringfifo[i].buffer);
ringfifo[i].buffer = NULL;
#endif//#ifdef USE_MALLOC_MEM
ringfifo[i].size = 0;
}
init_flag = 0;
//pthread_mutex_destroy(&ring_mutex);
}
/**************************************************************************************************
**
**
**
**************************************************************************************************/
static int addring(int i)
{
return (i+1) == NMAX ? 0 : i+1;
}
/**************************************************************************************************
**
**
**
**************************************************************************************************/
static int ringget(struct ringbuf *getinfo)
{
int Pos;
if(n>0)
{
pthread_mutex_lock(&ring_mutex);
Pos = iget;
iget = addring(iget);
n--;
getinfo->buffer = (ringfifo[Pos].buffer);
if (getinfo->buffer == NULL){
pthread_mutex_unlock(&ring_mutex);
return 0;
}
getinfo->frame_type = ringfifo[Pos].frame_type;
getinfo->size = ringfifo[Pos].size;
pthread_mutex_unlock(&ring_mutex);
//printf("Get FIFO INFO:idx:%d,len:%d,ptr:%x,type:%d\n",Pos,getinfo->size,(int)(getinfo->buffer),getinfo->frame_type);
return ringfifo[Pos].size;
}
else
{
//printf("Buffer is empty\n");
return 0;
}
}
/**************************************************************************************************
**
**
**
**************************************************************************************************/
static void ringput(unsigned char *buffer,int size,int encode_type)
{
if (size > RING_BUFFER_SIZE){
PJ_PERROR(4,(THIS_FILE, 0, "Error ringput, size:%d > %d", size, RING_BUFFER_SIZE));
return;
}
if(n >= 0 && n<NMAX)
{
pthread_mutex_lock(&ring_mutex);
if (ringfifo[iput].buffer == NULL){
pthread_mutex_unlock(&ring_mutex);
return;
}
if (size > RING_BUFFER_SIZE){
//pthread_mutex_unlock(&ring_mutex);
//return;
ringfifo[iput].buffer = realloc(ringfifo[iput].buffer, size);
}
memcpy(ringfifo[iput].buffer,buffer,size);
ringfifo[iput].size= size;
ringfifo[iput].frame_type = encode_type;
//printf("Put FIFO INFO:idx:%d,len:%d,ptr:%x,type:%d\n",iput,ringfifo[iput].size,(int)(ringfifo[iput].buffer),ringfifo[iput].frame_type);
iput = addring(iput);
pthread_mutex_unlock(&ring_mutex);
n++;
}
else
{
// printf("Buffer is full\n");
}
}
#endif
//add end.
vid_port.c中的get_frame_from_buffer做如下修改:
static pj_status_t get_frame_from_buffer(pjmedia_vid_port *vp,
pjmedia_frame *frame)
{
pj_status_t status = PJ_SUCCESS;
pj_mutex_lock(vp->frm_mutex);
if (vp->conv.conv)
status = convert_frame(vp, vp->frm_buf, frame);
else{
//for bug
//PJ_LOG(4, (THIS_FILE, "-1--get_frame_from_buffer: frame.size:%d, %d len", frame->size, vp->frm_buf->size));
#if PJMEDIA_VIDEO_DEV_HAS_OV5000
struct ringbuf ringitem ;
int itemlen = ringget(&ringitem);
if (itemlen > 0 && frame->buf != NULL){
int copy_len = itemlen;
if (itemlen > frame->size){
copy_len = frame->size;
}
memcpy(frame->buf, ringitem.buffer, copy_len);
frame->size = copy_len;
}else{
frame->size = 0;
pj_mutex_unlock(vp->frm_mutex);
return -1;
}
if (vp->frm_buf != NULL){
frame->type = vp->frm_buf->type;
frame->timestamp = vp->frm_buf->timestamp;
frame->bit_info = vp->frm_buf->bit_info;
//PJ_LOG(4, (THIS_FILE, "-2--get_frame_from_buffer: frame.size:%d, %d len, itemlen:%d", frame->size, vp->frm_buf->size, itemlen));
}
#else
int itemlen = vp->frm_buf->size;
pjmedia_frame_copy(frame, vp->frm_buf);
#endif
}
pj_mutex_unlock(vp->frm_mutex);
return status;
}3. 视频帧获取驱动定时器适配，调试发现视频流卡顿明显，发现是驱动的定时器跑的太慢，涉及到vid_conf.c中的on_clock_tick方法。
clock_param.clock_rate = 900000;//TS_CLOCK_RATE;
clock_param.usec_interval = 1000000 /1000;// vid_conf->opt.frame_rate;
status = pjmedia_clock_create2(pool, &clock_param, 0, &on_clock_tick,
vid_conf, &vid_conf->clock);
#if PJMEDIA_VIDEO_DEV_HAS_OV5000//lyz@ no need converter
vp->conv.conv_param.src.id = vp->conv.conv_param.dst.id;
vp->conv.conv_param.src.det.vid.size.w = vp->conv.conv_param.dst.det.vid.size.w;
vp->conv.conv_param.src.det.vid.size.h= vp->conv.conv_param.dst.det.vid.size.h;
//vp->role = ROLE_ACTIVE;
//return PJ_SUCCESS;
#endif
vconf_port结构体中增加
pj_size_t get_buf_real_size; /**< Data size for get_frame(). */
pj_size_t put_buf_real_size; /**< Data size for put_frame(). */
on_clock_tick方法中
status = pjmedia_port_get_frame(src->port, &frame);
if (status != PJ_SUCCESS) {
PJ_PERROR(5, (THIS_FILE, status,
"Failed to get frame from port %d [%s]!",
src->idx, src->port->info.name.ptr));
src->got_frame = PJ_FALSE;
} else {
#if PJMEDIA_VIDEO_DEV_HAS_OV5000//just set got_frame by
//PJ_PERROR(4, (THIS_FILE, status, "get frame from port %d ,len:%d, src_buf_size:%d!", src->idx, frame.size, src->get_buf_size));
src->got_frame = PJ_TRUE;
src->get_buf_real_size = frame.size;
#else
src->got_frame = (frame.size == src->get_buf_size);
#endif
/* There is a possibility that the source port's format has
* changed, but we haven't received the event yet.
*/
cur_fmt = &src->format;
new_fmt = &src->port->info.fmt;
if (cmp_fps(cur_fmt, new_fmt) ||
cmp_size(cur_fmt, new_fmt))
{
op_param prm;
prm.update_port.port = src->idx;
op_update_port(vid_conf, &prm);
}
}
render_src_frame方法中做下面的修改
static pj_status_t render_src_frame(vconf_port *src, vconf_port *sink,
unsigned transmitter_idx)
if (sink->transmitter_cnt == 1 && (!rs || !rs->converter)) {
/* The only transmitter and no conversion needed */
#if PJMEDIA_VIDEO_DEV_HAS_OV5000//just set got_frame
int get_buf_size = src->get_buf_real_size < sink->put_buf_size?src->get_buf_real_size:sink->put_buf_size;
sink->put_buf_real_size = get_buf_size;
#else
/* The only transmitter and no conversion needed */
if (src->get_buf_size != sink->put_buf_size)
return PJMEDIA_EVID_BADFORMAT;
int get_buf_size = src->put_buf_size;
#endif//
pj_memcpy(sink->put_buf, src->get_buf, get_buf_size);
} else if (rs && rs->converter) {4、rtp h264 fu-a组包发送和回调，涉及的文件,vid_stream.c 的 put_frame 方法。
/*
mark need modify later.
*/
#if PJMEDIA_VIDEO_DEV_HAS_OV5000
int rtp_per_packet_len = 1200;//1300;
int i=0;
int send_len = 0;
int reserved_len = frame->size;
int data_start_index = 0;
#if 1//SUPPORT_PS_ENPACKED
char ps_header[PS_HDR_LEN];
char ps_system_header[SYS_HDR_LEN];
char ps_map_header[PSM_HDR_LEN];
char pes_header[PES_HDR_LEN];
char temp_frame[1024 * 128];
#endif//
uint8_t nalu = 0;
uint8_t *data = (uint8_t *)frame->buf;
if ( *data == 0x00 && *(data+1)==0x00 && *(data+2) == 0x00 && *(data+3) == 0x01){
nalu = *(data+4);
data_start_index = 4;
if (reserved_len > rtp_per_packet_len){
//fu-a
data_start_index = 5;
}
}else if ( *data == 0x00 && *(data+1)==0x00 && *(data+2) == 0x01 ){
nalu = *(data+3);
data_start_index = 3;
if (reserved_len > rtp_per_packet_len){
//fu-a
data_start_index = 4;
}
}else{
nalu = *(data);
data_start_index = 0;
}
int index = 0;
if (ps_packet_flag){
int time_base = 90000;
int fps = 24;
int send_packet_interval = 1000 / fps;
int interval = time_base / fps;
stream->pts += interval;
long pts = stream->pts;
//ps封装
if (nalu == 0x67 || nalu == 0x68 || nalu == 0x65){
//I frame
gb28181_make_ps_header(ps_header, pts);
memcpy(temp_frame,ps_header,PS_HDR_LEN);
index += PS_HDR_LEN;
gb28181_make_sys_header(ps_system_header, 0x3f);
memcpy(temp_frame+ index, ps_system_header, SYS_HDR_LEN);
index += SYS_HDR_LEN;
gb28181_make_psm_header(ps_map_header);
memcpy(temp_frame + index, ps_map_header, PSM_HDR_LEN);
index += PSM_HDR_LEN;
}else{
gb28181_make_ps_header(ps_header, pts);
memcpy(temp_frame, ps_header, PS_HDR_LEN);
index += PS_HDR_LEN;
}
//封装pes
gb28181_make_pes_header(pes_header, 0xe0, reserved_len, pts, pts);
memcpy(temp_frame+index, pes_header, PES_HDR_LEN);
index += PES_HDR_LEN;
memcpy(temp_frame + index, data, reserved_len);
index += reserved_len;
data = temp_frame;
reserved_len = index;
data_start_index = 0;
}else{
//data_start_index = 0;
reserved_len -= data_start_index;
}
while(1){
send_len = rtp_per_packet_len;
if (reserved_len < rtp_per_packet_len){
send_len = reserved_len;
has_more_data = PJ_FALSE;
}else{
has_more_data = PJ_TRUE;
}
status = pjmedia_rtp_encode_rtp(&channel->rtp,
channel->pt,
(has_more_data == PJ_FALSE ? 1 : 0),
(int)send_len,
rtp_ts_len,
(const void**)&rtphdr,
&rtphdrlen);
if (status != PJ_SUCCESS) {
LOGERR_((channel->port.info.name.ptr, status,
"RTP encode_rtp() error"));
return status;
}
/* When the payload length is zero, we should not send anything,
* but proceed the rest normally.
*/
int fu_a_index = 0;
uint8_t *p_data = (uint8_t *)channel->buf;
if (reserved_len > 0) {
#if 1
if (frame->size > rtp_per_packet_len){
//fu-a
if (total_sent == 0){
//start
p_data[sizeof(pjmedia_rtp_hdr)] = (nalu & 0x60) | 28;
// |S|E|R| Type |
//S 1 E 0 R 0
p_data[sizeof(pjmedia_rtp_hdr)+1] = (1 << 7) | (nalu & 0x1f);
fu_a_index += 2;
}else{
if (has_more_data){
//end
p_data[sizeof(pjmedia_rtp_hdr)] = 28;
// |S|E|R| Type |
//S 0 E 0 R 0
p_data[sizeof(pjmedia_rtp_hdr)+1] = (nalu & 0x1f);
fu_a_index += 2;
}else{ //end
p_data[sizeof(pjmedia_rtp_hdr)] = 28;
// |S|E|R| Type |
//S 0 E 1 R 0
p_data[sizeof(pjmedia_rtp_hdr)+1] = (1 << 6) | (nalu & 0x1f);
fu_a_index += 2;
}
}
//send_len+=fu_a_index;
}
#endif//no -fu-a
/* Copy RTP header to the beginning of packet */
pj_memcpy(channel->buf, rtphdr, sizeof(pjmedia_rtp_hdr));
//copy data
pj_memcpy(channel->buf + fu_a_index + sizeof(pjmedia_rtp_hdr), data +total_sent + data_start_index, send_len+fu_a_index);
if (stream->transport == NULL){
break;
}
/* Send the RTP packet to the transport. */
status = pjmedia_transport_send_rtp(stream->transport,
(char*)channel->buf,
send_len +
sizeof(pjmedia_rtp_hdr) +fu_a_index);
if (status != PJ_SUCCESS) {
if (stream->rtp_tx_err_cnt++ == 0) {
LOGERR_((channel->port.info.name.ptr, status,
"Error sending RTP"));
}
if (stream->rtp_tx_err_cnt > SEND_ERR_COUNT_TO_REPORT) {
stream->rtp_tx_err_cnt = 0;
}
break;
}
pjmedia_rtcp_tx_rtp(&stream->rtcp, (unsigned)send_len);
//total_sent += frame_out.size;
pj_thread_sleep(2);//2ms
pkt_cnt++;
}
/* Next packets use same timestamp */
rtp_ts_len = 0;
reserved_len -= send_len;
total_sent += send_len;
if (reserved_len <= 0){
break;
}
}
//PJ_PERROR(4,(THIS_FILE, status, "put_frame len:%d,total_sent:%d", frame->size,total_sent));
goto ov5000_end;
#endif
ov5000_end:
#if TRACE_RC
/* Trace log for rate control */
{
pj_timestamp end_time;
unsigned total_sleep;
pj_get_timestamp(&end_time);
total_sleep = pj_elapsed_msec(&initial_time, &end_time);
PJ_LOG(5, (stream->name.ptr, "total pkt=%d size=%d sleep=%d",
pkt_cnt, total_sent, total_sleep));
if (stream->tx_start.u64 == 0)
stream->tx_start = initial_time;
stream->tx_end = end_time;
stream->rc_total_pkt += pkt_cnt;
stream->rc_total_sleep += total_sleep;
stream->rc_total_img++;
}
#endif其他修改：
vid_port_destroy #if PJMEDIA_VIDEO_DEV_HAS_OV5000 //free ringbuffer ringfree(); //add end. #endif
本文为呱牛笔记原创文章,转载无需和我联系,但请注明来自呱牛笔记 ,it3q.com
- 上一篇： 读书《静静的顿河》
- 下一篇： UWB主从站选举机制
请先登录后发表评论
- 最新评论
- 总共0条评论
