pjmedia_clock_src_get_time_msec( const pjmedia_clock_src *clocksrc )
{
pj_timestamp ts;
pjmedia_clock_src_get_current_timestamp(clocksrc, &ts);
#if PJ_HAS_INT64
if (ts.u64 > PJ_UINT64(0x3FFFFFFFFFFFFF))
return (pj_uint32_t)(ts.u64 / clocksrc->clock_rate * 1000);
else
return (pj_uint32_t)(ts.u64 * 1000 / clocksrc->clock_rate);
#elif PJ_HAS_FLOATING_POINT
return (pj_uint32_t)((1.0 * ts.u32.hi * 0xFFFFFFFFUL + ts.u32.lo)
* 1000.0 / clocksrc->clock_rate);
#else
if (ts.u32.lo > 0x3FFFFFUL)
return (pj_uint32_t)(0xFFFFFFFFUL / clocksrc->clock_rate * ts.u32.hi
* 1000UL + ts.u32.lo / clocksrc->clock_rate *
1000UL);
else
return (pj_uint32_t)(0xFFFFFFFFUL / clocksrc->clock_rate * ts.u32.hi
* 1000UL + ts.u32.lo * 1000UL /
clocksrc->clock_rate);
#endif
}
/* get frame from mmap */
static pj_status_t vid4lin_stream_get_frame_mmap(vid4lin_stream *stream,
pjmedia_frame *frame)
{
struct v4l2_buffer buf;
pj_time_val time;
pj_status_t status = PJ_SUCCESS;
unsigned tmp_idx;
pj_bzero(&buf, sizeof(buf));
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
status = xioctl(stream->fd, VIDIOC_DQBUF, &buf);
if (status != PJ_SUCCESS)
return status;
if (frame->size < buf.bytesused) {
/* supplied buffer is too small */
pj_assert(!"frame buffer is too small for v4l2");
status = PJ_ETOOSMALL;
goto on_return;
}
time.sec = buf.timestamp.tv_sec;
time.msec = buf.timestamp.tv_usec / 1000;
PJ_TIME_VAL_SUB(time, stream->start_time);
frame->type = PJMEDIA_FRAME_TYPE_VIDEO;
frame->bit_info = 0;
frame->size = buf.bytesused;
frame->timestamp.u64 = PJ_UINT64(1) * PJ_TIME_VAL_MSEC(time) *
stream->param.clock_rate / PJ_UINT64(1000);
pj_memcpy(frame->buf, stream->buffers[buf.index].start, buf.bytesused);
on_return:
tmp_idx = buf.index;
pj_bzero(&buf, sizeof(buf));
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = tmp_idx;
xioctl(stream->fd, VIDIOC_QBUF, &buf);
return status;
}
int txdata_test(void)
{
enum { REPEAT = 4 };
unsigned i, msgs;
pj_timestamp usec[REPEAT], min, freq;
int status;
status = pj_get_timestamp_freq(&freq);
if (status != PJ_SUCCESS)
return status;
status = core_txdata_test();
if (status != 0)
return status;
#if INCLUDE_GCC_TEST
status = gcc_test();
if (status != 0)
return status;
#endif
status = txdata_test_uri_params();
if (status != 0)
return status;
/*
* Benchmark create_request()
*/
PJ_LOG(3,(THIS_FILE, " benchmarking request creation:"));
for (i=0; i<REPEAT; ++i) {
PJ_LOG(3,(THIS_FILE, " test %d of %d..",
i+1, REPEAT));
status = create_request_bench(&usec[i]);
if (status != PJ_SUCCESS)
return status;
}
min.u64 = PJ_UINT64(0xFFFFFFFFFFFFFFF);
for (i=0; i<REPEAT; ++i) {
if (usec[i].u64 < min.u64) min.u64 = usec[i].u64;
}
msgs = (unsigned)(freq.u64 * LOOP / min.u64);
PJ_LOG(3,(THIS_FILE, " Requests created at %d requests/sec", msgs));
report_ival("create-request-per-sec",
msgs, "msg/sec",
"Number of typical request messages that can be created "
"per second with <tt>pjsip_endpt_create_request()</tt>");
/*
* Benchmark create_response()
*/
PJ_LOG(3,(THIS_FILE, " benchmarking response creation:"));
for (i=0; i<REPEAT; ++i) {
PJ_LOG(3,(THIS_FILE, " test %d of %d..",
i+1, REPEAT));
status = create_response_bench(&usec[i]);
if (status != PJ_SUCCESS)
return status;
}
min.u64 = PJ_UINT64(0xFFFFFFFFFFFFFFF);
for (i=0; i<REPEAT; ++i) {
if (usec[i].u64 < min.u64) min.u64 = usec[i].u64;
}
msgs = (unsigned)(freq.u64 * LOOP / min.u64);
PJ_LOG(3,(THIS_FILE, " Responses created at %d responses/sec", msgs));
report_ival("create-response-per-sec",
msgs, "msg/sec",
"Number of typical response messages that can be created "
"per second with <tt>pjsip_endpt_create_response()</tt>");
return 0;
}
int tsx_bench(void)
{
enum { WORKING_SET=10000, REPEAT = 4 };
unsigned i, speed;
pj_timestamp usec[REPEAT], min, freq;
char desc[250];
int status;
status = pj_get_timestamp_freq(&freq);
if (status != PJ_SUCCESS)
return status;
/*
* Benchmark UAC
*/
PJ_LOG(3,(THIS_FILE, " benchmarking UAC transaction creation:"));
for (i=0; i<REPEAT; ++i) {
PJ_LOG(3,(THIS_FILE, " test %d of %d..",
i+1, REPEAT));
status = uac_tsx_bench(WORKING_SET, &usec[i]);
if (status != PJ_SUCCESS)
return status;
}
min.u64 = PJ_UINT64(0xFFFFFFFFFFFFFFF);
for (i=0; i<REPEAT; ++i) {
if (usec[i].u64 < min.u64) min.u64 = usec[i].u64;
}
/* Report time */
pj_ansi_sprintf(desc, "Time to create %d UAC transactions, in miliseconds",
WORKING_SET);
report_ival("create-uac-time", (unsigned)(min.u64 * 1000 / freq.u64), "msec", desc);
/* Write speed */
speed = (unsigned)(freq.u64 * WORKING_SET / min.u64);
PJ_LOG(3,(THIS_FILE, " UAC created at %d tsx/sec", speed));
pj_ansi_sprintf(desc, "Number of UAC transactions that potentially can be created per second "
"with <tt>pjsip_tsx_create_uac()</tt>, based on the time "
"to create %d simultaneous transactions above.",
WORKING_SET);
report_ival("create-uac-tsx-per-sec",
speed, "tsx/sec", desc);
/*
* Benchmark UAS
*/
PJ_LOG(3,(THIS_FILE, " benchmarking UAS transaction creation:"));
for (i=0; i<REPEAT; ++i) {
PJ_LOG(3,(THIS_FILE, " test %d of %d..",
i+1, REPEAT));
status = uas_tsx_bench(WORKING_SET, &usec[i]);
if (status != PJ_SUCCESS)
return status;
}
min.u64 = PJ_UINT64(0xFFFFFFFFFFFFFFF);
for (i=0; i<REPEAT; ++i) {
if (usec[i].u64 < min.u64) min.u64 = usec[i].u64;
}
/* Report time */
pj_ansi_sprintf(desc, "Time to create %d UAS transactions, in miliseconds",
WORKING_SET);
report_ival("create-uas-time", (unsigned)(min.u64 * 1000 / freq.u64), "msec", desc);
/* Write speed */
speed = (unsigned)(freq.u64 * WORKING_SET / min.u64);
PJ_LOG(3,(THIS_FILE, " UAS created at %d tsx/sec", speed));
pj_ansi_sprintf(desc, "Number of UAS transactions that potentially can be created per second "
"with <tt>pjsip_tsx_create_uas()</tt>, based on the time "
"to create %d simultaneous transactions above.",
WORKING_SET);
report_ival("create-uas-tsx-per-sec",
speed, "tsx/sec", desc);
return PJ_SUCCESS;
}
