int main()
{
pj_caching_pool cp;
pj_bool_t done = PJ_FALSE;
pj_status_t status;
/* Init pjlib */
status = pj_init();
PJ_ASSERT_RETURN(status==PJ_SUCCESS, 1);
pj_log_set_decor(PJ_LOG_HAS_NEWLINE);
/* Must create a pool factory before we can allocate any memory. */
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
status = pjmedia_aud_subsys_init(&cp.factory);
if (status != PJ_SUCCESS) {
app_perror("pjmedia_aud_subsys_init()", status);
pj_caching_pool_destroy(&cp);
pj_shutdown();
return 1;
}
list_devices();
while (!done) {
char line[80];
print_menu();
if (fgets(line, sizeof(line), stdin)==NULL)
break;
switch (line[0]) {
case 'l':
list_devices();
break;
case 'R':
pjmedia_aud_dev_refresh();
puts("Audio device list refreshed.");
break;
case 'i':
{
unsigned dev_index;
if (sscanf(line+2, "%u", &dev_index) != 1) {
puts("error: device ID required");
break;
}
show_dev_info(dev_index);
}
break;
case 't':
{
pjmedia_dir dir;
int rec_id, play_id;
unsigned clock_rate, ptime, chnum;
int cnt;
cnt = sscanf(line+2, "%d %d %u %u %u", &rec_id, &play_id,
&clock_rate, &ptime, &chnum);
if (cnt < 4) {
puts("error: not enough parameters");
break;
}
if (clock_rate < 8000 || clock_rate > 128000) {
puts("error: invalid clock rate");
break;
}
if (ptime < 10 || ptime > 500) {
puts("error: invalid ptime");
break;
}
if (cnt==5) {
if (chnum < 1 || chnum > 4) {
puts("error: invalid number of channels");
break;
}
} else {
chnum = 1;
}
if (rec_id >= 0 && rec_id < (int)dev_count) {
if (play_id >= 0 && play_id < (int)dev_count)
dir = PJMEDIA_DIR_CAPTURE_PLAYBACK;
else
dir = PJMEDIA_DIR_CAPTURE;
} else if (play_id >= 0 && play_id < (int)dev_count) {
dir = PJMEDIA_DIR_PLAYBACK;
} else {
puts("error: at least one valid device index required");
break;
}
test_device(dir, rec_id, play_id, clock_rate, ptime, chnum);
}
break;
case 'r':
/* record */
{
int index;
char filename[80];
int count;
count = sscanf(line+2, "%d %s", &index, filename);
if (count==1)
record(index, NULL);
else if (count==2)
record(index, filename);
else
puts("error: invalid command syntax");
}
break;
case 'p':
/* playback */
{
int index;
char filename[80];
int count;
count = sscanf(line+2, "%d %s", &index, filename);
if (count==1)
play_file(index, NULL);
else if (count==2)
play_file(index, filename);
else
puts("error: invalid command syntax");
}
break;
case 'd':
/* latencies */
{
int rec_lat, play_lat;
if (sscanf(line+2, "%d %d", &rec_lat, &play_lat) == 2) {
capture_lat = (unsigned)
(rec_lat>=0? rec_lat:PJMEDIA_SND_DEFAULT_REC_LATENCY);
playback_lat = (unsigned)
(play_lat >= 0? play_lat : PJMEDIA_SND_DEFAULT_PLAY_LATENCY);
printf("Recording latency=%ums, playback latency=%ums",
capture_lat, playback_lat);
} else {
printf("Current latencies: record=%ums, playback=%ums",
capture_lat, playback_lat);
}
puts("");
}
break;
case 'v':
if (pj_log_get_level() <= 3) {
pj_log_set_level(5);
puts("Logging set to detail");
} else {
pj_log_set_level(3);
puts("Logging set to quiet");
}
break;
case 'q':
done = PJ_TRUE;
break;
}
}
pj_caching_pool_destroy(&cp);
pj_shutdown();
return 0;
}
int jbuf_main(void)
{
FILE *input;
pj_bool_t data_eof = PJ_FALSE;
int old_log_level;
int rc = 0;
const char* input_filename = "Jbtest.dat";
const char* input_search_path[] = {
"../build",
"pjmedia/build",
"build"
};
/* Try to open test data file in the working directory */
input = fopen(input_filename, "rt");
/* If that fails, try to open test data file in specified search paths */
if (input == NULL) {
char input_path[PJ_MAXPATH];
int i;
for (i = 0; !input && i < PJ_ARRAY_SIZE(input_search_path); ++i) {
pj_ansi_snprintf(input_path, PJ_MAXPATH, "%s/%s",
input_search_path[i],
input_filename);
input = fopen(input_path, "rt");
}
}
/* Failed to open test data file. */
if (input == NULL) {
printf("Failed to open test data file, Jbtest.dat\n");
return -1;
}
old_log_level = pj_log_get_level();
pj_log_set_level(5);
while (rc == 0 && !data_eof) {
pj_str_t jb_name = {"JBTEST", 6};
pjmedia_jbuf *jb;
pj_pool_t *pool;
pjmedia_jb_state state;
pj_uint16_t last_seq = 0;
pj_uint16_t seq = 1;
char line[1024], *p = NULL;
test_param_t param;
test_cond_t cond;
param.adaptive = PJ_TRUE;
param.init_prefetch = JB_INIT_PREFETCH;
param.min_prefetch = JB_MIN_PREFETCH;
param.max_prefetch = JB_MAX_PREFETCH;
cond.burst = -1;
cond.delay = -1;
cond.discard = -1;
cond.empty = -1;
cond.lost = -1;
printf("\n\n");
/* Parse test session title, param, and conditions */
do {
p = fgets(line, sizeof(line), input);
} while (p && parse_test_headers(line, ¶m, &cond));
/* EOF test data */
if (p == NULL)
break;
//printf("======================================================\n");
/* Initialize test session */
pool = pj_pool_create(mem, "JBPOOL", 256*16, 256*16, NULL);
pjmedia_jbuf_create(pool, &jb_name, 1, JB_PTIME, JB_BUF_SIZE, &jb);
pjmedia_jbuf_reset(jb);
if (param.adaptive) {
pjmedia_jbuf_set_adaptive(jb,
param.init_prefetch,
param.min_prefetch,
param.max_prefetch);
} else {
pjmedia_jbuf_set_fixed(jb, param.init_prefetch);
}
#ifdef REPORT
pjmedia_jbuf_get_state(jb, &state);
printf("Initial\tsize=%d\tprefetch=%d\tmin.pftch=%d\tmax.pftch=%d\n",
state.size, state.prefetch, state.min_prefetch,
state.max_prefetch);
#endif
/* Test session start */
while (1) {
char c;
/* Get next line of test data */
if (!p || *p == 0) {
p = fgets(line, sizeof(line), input);
if (p == NULL) {
data_eof = PJ_TRUE;
break;
}
}
/* Get next char of test data */
c = *p++;
/* Skip spaces */
if (isspace(c))
continue;
/* Print comment line */
if (c == '#') {
#ifdef PRINT_COMMENT
while (*p && isspace(*p)) ++p;
if (*p) printf("..%s", p);
#endif
*p = 0;
continue;
}
/* Process test data */
if (!process_test_data(c, jb, &seq, &last_seq))
break;
}
/* Print JB states */
pjmedia_jbuf_get_state(jb, &state);
printf("------------------------------------------------------\n");
printf("Summary:\n");
printf(" size=%d prefetch=%d\n", state.size, state.prefetch);
printf(" delay (min/max/avg/dev)=%d/%d/%d/%d ms\n",
state.min_delay, state.max_delay, state.avg_delay,
state.dev_delay);
printf(" lost=%d discard=%d empty=%d burst(avg)=%d\n",
state.lost, state.discard, state.empty, state.avg_burst);
/* Evaluate test session */
if (cond.burst >= 0 && (int)state.avg_burst > cond.burst) {
printf("! 'Burst' should be %d, it is %d\n",
cond.burst, state.avg_burst);
rc |= 1;
}
if (cond.delay >= 0 && (int)state.avg_delay/JB_PTIME > cond.delay) {
printf("! 'Delay' should be %d, it is %d\n",
cond.delay, state.avg_delay/JB_PTIME);
rc |= 2;
}
if (cond.discard >= 0 && (int)state.discard > cond.discard) {
printf("! 'Discard' should be %d, it is %d\n",
cond.discard, state.discard);
rc |= 4;
}
if (cond.empty >= 0 && (int)state.empty > cond.empty) {
printf("! 'Empty' should be %d, it is %d\n",
cond.empty, state.empty);
rc |= 8;
}
if (cond.lost >= 0 && (int)state.lost > cond.lost) {
printf("! 'Lost' should be %d, it is %d\n",
cond.lost, state.lost);
rc |= 16;
}
pjmedia_jbuf_destroy(jb);
pj_pool_release(pool);
}
fclose(input);
pj_log_set_level(old_log_level);
return rc;
}
int vid_codec_test(void)
{
pj_pool_t *pool;
int rc = 0;
pj_status_t status;
int orig_log_level;
orig_log_level = pj_log_get_level();
pj_log_set_level(3);
PJ_LOG(3, (THIS_FILE, "Performing video codec tests.."));
pool = pj_pool_create(mem, "Vid codec test", 256, 256, 0);
status = pjmedia_vid_dev_subsys_init(mem);
if (status != PJ_SUCCESS)
return -10;
#if PJMEDIA_HAS_VIDEO && PJMEDIA_HAS_OPENH264_CODEC
status = pjmedia_codec_openh264_vid_init(NULL, mem);
if (status != PJ_SUCCESS) {
return -22;
}
#endif
#if PJMEDIA_HAS_FFMPEG_VID_CODEC
status = pjmedia_codec_ffmpeg_vid_init(NULL, mem);
if (status != PJ_SUCCESS)
return -20;
#endif
rc = enum_codecs();
if (rc != 0)
goto on_return;
#if PJMEDIA_HAS_FFMPEG_VID_CODEC
rc = encode_decode_test(pool, "h263-1998", PJMEDIA_VID_PACKING_WHOLE);
if (rc != 0)
goto on_return;
rc = encode_decode_test(pool, "h263-1998", PJMEDIA_VID_PACKING_PACKETS);
if (rc != 0)
goto on_return;
#endif
#if PJMEDIA_HAS_FFMPEG_VID_CODEC || PJMEDIA_HAS_OPENH264_CODEC
rc = encode_decode_test(pool, "h264", PJMEDIA_VID_PACKING_WHOLE);
if (rc != 0)
goto on_return;
rc = encode_decode_test(pool, "h264", PJMEDIA_VID_PACKING_PACKETS);
if (rc != 0)
goto on_return;
#endif
on_return:
#if PJMEDIA_HAS_FFMPEG_VID_CODEC
pjmedia_codec_ffmpeg_vid_deinit();
#endif
#if defined(PJMEDIA_HAS_OPENH264_CODEC) && PJMEDIA_HAS_OPENH264_CODEC != 0
pjmedia_codec_openh264_vid_deinit();
#endif
pjmedia_vid_dev_subsys_shutdown();
pj_pool_release(pool);
pj_log_set_level(orig_log_level);
return rc;
}
