void circle(float x, float y, float r, uint32_t color)
{
olPushMatrix();
olPushColor();
olMultColor(color);
olTranslate(x, y);
olRotate((x+y)*123);
/*olBegin(OL_BEZIERSTRIP);
olVertex(0, r, color);
int i;
for (i=0; i<2; i++) {
olVertex(CP*r, r, C_WHITE);
olVertex(r, CP*r, C_WHITE);
olVertex(r, 0, C_WHITE);
olVertex(r, -CP*r, C_WHITE);
olVertex(CP*r, -r, C_WHITE);
olVertex(0, -r, C_WHITE);
olVertex(-CP*r, -r, C_WHITE);
olVertex(-r, -CP*r, C_WHITE);
olVertex(-r, 0, C_WHITE);
olVertex(-r, CP*r, C_WHITE);
olVertex(-CP*r, r, C_WHITE);
olVertex(0, r, C_WHITE);
}*/
/* olVertex(0, r, color);
olVertex(0, r, color);
olVertex(r*0.1, r, color);
olVertex(r*0.1, r, color);*/
float circum = 2 * M_PI * r;
int segments = circum / (1/30.0);
if (segments < 50)
segments = 50;
int i;
olBegin(OL_POINTS);
olVertex(r, 0);
for (i=0; i<=(2*segments+10); i++) {
float w = i * M_PI * 2.0 / segments;
uint32_t c = C_WHITE;
if (i > 2*segments)
c = C_GREY((10-(i-segments)) * 28);
else if (i < 3)
c = C_GREY(i * 85);
olVertex(r*cosf(w), r*sinf(w));
}
olEnd();
olPopColor();
olPopMatrix();
}
void olDrawIlda3D(IldaFile *ild)
{
if (!ild)
return;
IldaPoint *p = ild->points;
int i;
olBegin(OL_POINTS);
for (i = 0; i < ild->count; i++) {
if (p->is_blank)
olVertex3(p->x, p->y, p->z, C_BLACK);
else
olVertex3(p->x, p->y, p->z, C_WHITE);
p++;
}
olEnd();
}
void draw_generic(struct object *o)
{
int j;
int x1, y1, x2, y2;
if (o->v->p == NULL)
return;
x1 = o->x + o->v->p[0].x - camerax;
y1 = o->y + o->v->p[0].y - cameray;
olBegin(OL_LINESTRIP);
olVertex(x1,y1,openlase_color);
for (j = 0; j < o->v->npoints - 1; j++) {
if (o->v->p[j+1].x == LINE_BREAK) { /* Break in the line segments. */
j += 2;
x1 = o->x + o->v->p[j].x - camerax;
y1 = o->y + o->v->p[j].y - cameray;
olVertex(x1,y1,C_BLACK);
}
if (o->v->p[j].x == COLOR_CHANGE) {
/* do something here to change colors */
j += 1;
x1 = o->x + o->v->p[j].x - camerax;
y1 = o->y + o->v->p[j].y - cameray;
}
x2 = o->x + o->v->p[j+1].x - camerax;
y2 = o->y + o->v->p[j+1].y - cameray;
if (x1 > 0 && x2 > 0)
olVertex(x2,y2,openlase_color);
x1 = x2;
y1 = y2;
}
olEnd();
}
int main (int argc, char *argv[])
{
OLRenderParams params;
AVFrame *frame;
int i;
// Register all formats and codecs
av_register_all();
memset(¶ms, 0, sizeof params);
params.rate = 48000;
params.on_speed = 2.0/100.0;
params.off_speed = 2.0/15.0;
params.start_wait = 8;
params.end_wait = 3;
params.snap = 1/120.0;
params.render_flags = RENDER_GRAYSCALE;
params.min_length = 4;
params.start_dwell = 2;
params.end_dwell = 2;
float snap_pix = 3;
float aspect = 0;
float framerate = 0;
float overscan = 0;
int thresh_dark = 60;
int thresh_light = 160;
int sw_dark = 100;
int sw_light = 256;
int decimate = 2;
int edge_off = 0;
int optchar;
OLTraceParams tparams = {
.mode = OL_TRACE_THRESHOLD,
.sigma = 0,
.threshold2 = 50
};
while ((optchar = getopt(argc, argv, "hct:T:b:w:B:W:O:d:m:S:E:D:g:s:p:a:r:R:o:v:")) != -1) {
switch (optchar) {
case 'h':
case '?':
usage(argv[0]);
return 0;
case 'c':
tparams.mode = OL_TRACE_CANNY;
tparams.sigma = 1;
break;
case 't':
thresh_dark = thresh_light = atoi(optarg);
break;
case 'T':
tparams.threshold2 = atoi(optarg);
break;
case 'b':
thresh_dark = atoi(optarg);
break;
case 'w':
thresh_light = atoi(optarg);
break;
case 'B':
sw_dark = atoi(optarg);
break;
case 'W':
sw_light = atoi(optarg);
break;
case 'O':
edge_off = atoi(optarg);
break;
case 'd':
decimate = atoi(optarg);
break;
case 'm':
params.min_length = atoi(optarg);
break;
case 'S':
params.start_wait = atoi(optarg);
break;
case 'E':
params.end_wait = atoi(optarg);
break;
case 'D':
params.start_dwell = atoi(optarg);
params.end_dwell = atoi(optarg);
break;
case 'g':
tparams.sigma = atof(optarg);
break;
case 's':
params.off_speed = 2.0f/atof(optarg);
break;
case 'p':
snap_pix = atof(optarg);
break;
case 'a':
aspect = atof(optarg);
break;
case 'r':
framerate = atof(optarg);
break;
case 'R':
params.max_framelen = params.rate/atof(optarg);
break;
case 'o':
overscan = atof(optarg);
break;
case 'v':
volume = atof(optarg);
break;
}
}
if (optind == argc) {
usage(argv[0]);
return 1;
}
if (av_vid_init(argv[optind]) != 0) {
printf("Video open/init failed\n");
return 1;
}
if (av_aud_init(argv[optind]) != 0) {
printf("Audio open/init failed\n");
return 1;
}
if(olInit(FRAMES_BUF, 300000) < 0) {
printf("OpenLase init failed\n");
return 1;
}
if (aspect == 0)
aspect = pCodecCtx->width / (float)pCodecCtx->height;
if (framerate == 0)
framerate = (float)pFormatCtx->streams[videoStream]->r_frame_rate.num / (float)pFormatCtx->streams[videoStream]->r_frame_rate.den;
float iaspect = 1/aspect;
if (aspect > 1) {
olSetScissor(-1, -iaspect, 1, iaspect);
olScale(1, iaspect);
} else {
olSetScissor(-aspect, -1, aspect, 1);
olScale(aspect, 1);
}
printf("Aspect is %f %f\n", aspect, iaspect);
printf("Overscan is %f\n", overscan);
olScale(1+overscan, 1+overscan);
olTranslate(-1.0f, 1.0f);
olScale(2.0f/pCodecCtx->width, -2.0f/pCodecCtx->height);
int maxd = pCodecCtx->width > pCodecCtx->height ? pCodecCtx->width : pCodecCtx->height;
params.snap = (snap_pix*2.0)/(float)maxd;
float frametime = 1.0f/framerate;
printf("Framerate: %f (%fs per frame)\n", framerate, frametime);
olSetAudioCallback(moreaudio);
olSetRenderParams(¶ms);
float vidtime = 0;
int inf=0;
int bg_white = -1;
float time = 0;
float ftime;
int frames = 0;
OLFrameInfo info;
OLTraceCtx *trace_ctx;
OLTraceResult result;
memset(&result, 0, sizeof(result));
tparams.width = pCodecCtx->width,
tparams.height = pCodecCtx->height,
olTraceInit(&trace_ctx, &tparams);
while(GetNextFrame(pFormatCtx, pCodecCtx, videoStream, &frame)) {
if (inf == 0)
printf("Frame stride: %d\n", frame->linesize[0]);
inf+=1;
if (vidtime < time) {
vidtime += frametime;
printf("Frame skip!\n");
continue;
}
vidtime += frametime;
int thresh;
int obj;
int bsum = 0;
int c;
for (c=edge_off; c<(pCodecCtx->width-edge_off); c++) {
bsum += frame->data[0][c+edge_off*frame->linesize[0]];
bsum += frame->data[0][c+(pCodecCtx->height-edge_off-1)*frame->linesize[0]];
}
for (c=edge_off; c<(pCodecCtx->height-edge_off); c++) {
bsum += frame->data[0][edge_off+c*frame->linesize[0]];
bsum += frame->data[0][(c+1)*frame->linesize[0]-1-edge_off];
}
bsum /= (2*(pCodecCtx->width+pCodecCtx->height));
if (bg_white == -1)
bg_white = bsum > 128;
if (bg_white && bsum < sw_dark)
bg_white = 0;
if (!bg_white && bsum > sw_light)
bg_white = 1;
if (bg_white)
thresh = thresh_light;
else
thresh = thresh_dark;
tparams.threshold = thresh;
olTraceReInit(trace_ctx, &tparams);
olTraceFree(&result);
obj = olTrace(trace_ctx, frame->data[0], frame->linesize[0], &result);
do {
int i, j;
for (i = 0; i < result.count; i++) {
OLTraceObject *o = &result.objects[i];
olBegin(OL_POINTS);
OLTracePoint *p = o->points;
for (j = 0; j < o->count; j++) {
if (j % decimate == 0)
olVertex(p->x, p->y, C_WHITE);
p++;
}
olEnd();
}
ftime = olRenderFrame(200);
olGetFrameInfo(&info);
frames++;
time += ftime;
printf("Frame time: %.04f, Cur FPS:%6.02f, Avg FPS:%6.02f, Drift: %7.4f, "
"In %4d, Out %4d Thr %3d Bg %3d Pts %4d",
ftime, 1/ftime, frames/time, time-vidtime,
inf, frames, thresh, bsum, info.points);
if (info.resampled_points)
printf(" Rp %4d Bp %4d", info.resampled_points, info.resampled_blacks);
if (info.padding_points)
printf(" Pad %4d", info.padding_points);
printf("\n");
} while ((time+frametime) < vidtime);
}
olTraceDeinit(trace_ctx);
for(i=0;i<FRAMES_BUF;i++)
olRenderFrame(200);
olShutdown();
av_deinit();
exit (0);
}
int trace(int *field, uint8_t *tmp, int thresh, int w, int h, int decimate)
{
int x, y, cx, cy, px, py, i;
int iters = 0;
int objects = 0;
int sx[OVERDRAW], sy[OVERDRAW];
memset(tmp, 0, w*h);
for (y=1; y<h-1; y++) {
for (x=1; x<w-1;x++) {
int idx = y*w+x;
if (field[idx] > thresh && (!(field[idx-w] > thresh)
|| !(field[idx+w] > thresh)
|| !(field[idx-1] > thresh)
|| !(field[idx+1] > thresh))) {
tmp[idx] = 1;
}
}
}
int total = h*w;
int dir = 0;
int minx = 0, miny = 0;
int maxx = w-1, maxy = h-1;
int div = 0;
px = 0;
py = 0;
while (total--)
{
if (tmp[py*w+px]) {
x = cx = px;
y = cy = py;
iters = 0;
olBegin(OL_POINTS);
while (1)
{
int idx = y*w+x;
if(div==0) {
if (iters < OVERDRAW) {
sx[iters] = x;
sy[iters] = y;
}
olVertex(x, y, C_WHITE);
iters++;
}
div = (div+1)%decimate;
tmp[idx] = 0;
if (tmp[idx-1]) {
x--;
} else if (tmp[idx+1]) {
x++;
} else if (tmp[idx-w]) {
y--;
} else if (tmp[idx+w]) {
y++;
} else if (tmp[idx-w-1]) {
y--; x--;
} else if (tmp[idx-w+1]) {
y--; x++;
} else if (tmp[idx+w-1]) {
y++; x--;
} else if (tmp[idx+w+1]) {
y++; x++;
} else {
break;
}
}
if (iters) {
objects++;
if (ABS(cx-x) <= 1 && ABS(cy-y) <= 1) {
if (iters > OVERDRAW)
iters = OVERDRAW;
for (i=0; i<iters; i++)
olVertex(sx[i], sy[i], C_GREY((int)(255.0 * (OVERDRAW - 1 - i) / (float)OVERDRAW)));
}
}
olEnd();
}
switch(dir) {
case 0:
px++;
if (px > maxx) {
px--; py++; maxx--; dir++;
}
break;
case 1:
py++;
if (py > maxy) {
py--; px--; maxy--; dir++;
}
break;
case 2:
px--;
if (px < minx) {
px++; py--; minx++; dir++;
}
break;
case 3:
py--;
if (py < miny) {
py++; px++; miny++; dir=0;
}
break;
}
}
return objects;
}
int main(int argc, char** argv) {
int opt, i, result = 0;
const char* path = NULL;
const char* serial_number = NULL;
int exit_code = EXIT_SUCCESS;
struct timeval time_now;
float time_diff;
float sweep_rate;
unsigned int lna_gain=16, vga_gain=20;
uint32_t freq_min = 0;
uint32_t freq_max = 6000;
uint32_t requested_fft_bin_width;
while( (opt = getopt(argc, argv, "a:f:p:l:g:d:n:w:1BILr:h?")) != EOF ) {
result = HACKRF_SUCCESS;
switch( opt )
{
case 'd':
serial_number = optarg;
break;
case 'a':
amp = true;
result = parse_u32(optarg, &_enable);
break;
case 'f':
result = parse_u32_range(optarg, &freq_min, &freq_max);
if(freq_min >= freq_max) {
fprintf(stderr,
"argument error: freq_max must be greater than freq_min.\n");
usage();
return EXIT_FAILURE;
}
if(FREQ_MAX_MHZ <freq_max) {
fprintf(stderr,
"argument error: freq_max may not be higher than %u.\n",
FREQ_MAX_MHZ);
usage();
return EXIT_FAILURE;
}
if(MAX_SWEEP_RANGES <= num_ranges) {
fprintf(stderr,
"argument error: specify a maximum of %u frequency ranges.\n",
MAX_SWEEP_RANGES);
usage();
return EXIT_FAILURE;
}
frequencies[2*num_ranges] = (uint16_t)freq_min;
frequencies[2*num_ranges+1] = (uint16_t)freq_max;
num_ranges++;
break;
case 'p':
antenna = true;
result = parse_u32(optarg, &antenna_enable);
break;
case 'l':
result = parse_u32(optarg, &lna_gain);
break;
case 'g':
result = parse_u32(optarg, &vga_gain);
break;
case 'n':
result = parse_u32(optarg, &num_samples);
break;
case 'w':
result = parse_u32(optarg, &requested_fft_bin_width);
fftSize = DEFAULT_SAMPLE_RATE_HZ / requested_fft_bin_width;
break;
case '1':
one_shot = true;
break;
case 'B':
binary_output = true;
break;
case 'I':
ifft_output = true;
break;
case 'L':
openlase_output = true;
break;
case 'r':
path = optarg;
break;
case 'h':
case '?':
usage();
return EXIT_SUCCESS;
default:
fprintf(stderr, "unknown argument '-%c %s'\n", opt, optarg);
usage();
return EXIT_FAILURE;
}
if( result != HACKRF_SUCCESS ) {
fprintf(stderr, "argument error: '-%c %s' %s (%d)\n", opt, optarg, hackrf_error_name(result), result);
usage();
return EXIT_FAILURE;
}
}
if (lna_gain % 8)
fprintf(stderr, "warning: lna_gain (-l) must be a multiple of 8\n");
if (vga_gain % 2)
fprintf(stderr, "warning: vga_gain (-g) must be a multiple of 2\n");
if (num_samples % SAMPLES_PER_BLOCK) {
fprintf(stderr, "warning: num_samples (-n) must be a multiple of 8192\n");
return EXIT_FAILURE;
}
if (num_samples < SAMPLES_PER_BLOCK) {
fprintf(stderr, "warning: num_samples (-n) must be at least 8192\n");
return EXIT_FAILURE;
}
if( amp ) {
if( amp_enable > 1 ) {
fprintf(stderr, "argument error: amp_enable shall be 0 or 1.\n");
usage();
return EXIT_FAILURE;
}
}
if (antenna) {
if (antenna_enable > 1) {
fprintf(stderr, "argument error: antenna_enable shall be 0 or 1.\n");
usage();
return EXIT_FAILURE;
}
}
if (0 == num_ranges) {
frequencies[0] = (uint16_t)freq_min;
frequencies[1] = (uint16_t)freq_max;
num_ranges++;
}
if(binary_output + ifft_output + openlase_output > 1) {
fprintf(stderr, "argument error: binary output (-B), IFFT output (-I) and openlase output (-L) are mutually exclusive.\n");
return EXIT_FAILURE;
}
if(ifft_output && (1 < num_ranges)) {
fprintf(stderr, "argument error: only one frequency range is supported in IFFT output (-I) mode.\n");
return EXIT_FAILURE;
}
if(4 > fftSize) {
fprintf(stderr,
"argument error: FFT bin width (-w) must be no more than one quarter the sample rate\n");
return EXIT_FAILURE;
}
if(8184 < fftSize) {
fprintf(stderr,
"argument error: FFT bin width (-w) too small, resulted in more than 8184 FFT bins\n");
return EXIT_FAILURE;
}
/* In interleaved mode, the FFT bin selection works best if the total
* number of FFT bins is equal to an odd multiple of four.
* (e.g. 4, 12, 20, 28, 36, . . .)
*/
while((fftSize + 4) % 8) {
fftSize++;
}
fft_bin_width = (double)DEFAULT_SAMPLE_RATE_HZ / fftSize;
fftwIn = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize);
fftwOut = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize);
fftwPlan = fftwf_plan_dft_1d(fftSize, fftwIn, fftwOut, FFTW_FORWARD, FFTW_MEASURE);
pwr = (float*)fftwf_malloc(sizeof(float) * fftSize);
window = (float*)fftwf_malloc(sizeof(float) * fftSize);
for (i = 0; i < fftSize; i++) {
window[i] = (float) (0.5f * (1.0f - cos(2 * M_PI * i / (fftSize - 1))));
}
result = hackrf_init();
if( result != HACKRF_SUCCESS ) {
fprintf(stderr, "hackrf_init() failed: %s (%d)\n", hackrf_error_name(result), result);
usage();
return EXIT_FAILURE;
}
result = hackrf_open_by_serial(serial_number, &device);
if( result != HACKRF_SUCCESS ) {
fprintf(stderr, "hackrf_open() failed: %s (%d)\n", hackrf_error_name(result), result);
usage();
return EXIT_FAILURE;
}
if((NULL == path) || (strcmp(path, "-") == 0)) {
fd = stdout;
} else {
fd = fopen(path, "wb");
}
if(NULL == fd) {
fprintf(stderr, "Failed to open file: %s\n", path);
return EXIT_FAILURE;
}
/* Change fd buffer to have bigger one to store or read data on/to HDD */
result = setvbuf(fd , NULL , _IOFBF , FD_BUFFER_SIZE);
if( result != 0 ) {
fprintf(stderr, "setvbuf() failed: %d\n", result);
usage();
return EXIT_FAILURE;
}
#ifdef _MSC_VER
SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
#else
signal(SIGINT, &sigint_callback_handler);
signal(SIGILL, &sigint_callback_handler);
signal(SIGFPE, &sigint_callback_handler);
signal(SIGSEGV, &sigint_callback_handler);
signal(SIGTERM, &sigint_callback_handler);
signal(SIGABRT, &sigint_callback_handler);
#endif
fprintf(stderr, "call hackrf_sample_rate_set(%.03f MHz)\n",
((float)DEFAULT_SAMPLE_RATE_HZ/(float)FREQ_ONE_MHZ));
result = hackrf_set_sample_rate_manual(device, DEFAULT_SAMPLE_RATE_HZ, 1);
if( result != HACKRF_SUCCESS ) {
fprintf(stderr, "hackrf_sample_rate_set() failed: %s (%d)\n",
hackrf_error_name(result), result);
usage();
return EXIT_FAILURE;
}
fprintf(stderr, "call hackrf_baseband_filter_bandwidth_set(%.03f MHz)\n",
((float)DEFAULT_BASEBAND_FILTER_BANDWIDTH/(float)FREQ_ONE_MHZ));
result = hackrf_set_baseband_filter_bandwidth(device, DEFAULT_BASEBAND_FILTER_BANDWIDTH);
if( result != HACKRF_SUCCESS ) {
fprintf(stderr, "hackrf_baseband_filter_bandwidth_set() failed: %s (%d)\n",
hackrf_error_name(result), result);
usage();
return EXIT_FAILURE;
}
result = hackrf_set_vga_gain(device, vga_gain);
result |= hackrf_set_lna_gain(device, lna_gain);
/*
* For each range, plan a whole number of tuning steps of a certain
* bandwidth. Increase high end of range if necessary to accommodate a
* whole number of steps, minimum 1.
*/
for(i = 0; i < num_ranges; i++) {
step_count = 1 + (frequencies[2*i+1] - frequencies[2*i] - 1)
/ TUNE_STEP;
frequencies[2*i+1] = (uint16_t) (frequencies[2*i] + step_count * TUNE_STEP);
fprintf(stderr, "Sweeping from %u MHz to %u MHz\n",
frequencies[2*i], frequencies[2*i+1]);
}
if(ifft_output) {
ifftwIn = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize * step_count);
ifftwOut = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize * step_count);
ifftwPlan = fftwf_plan_dft_1d(fftSize * step_count, ifftwIn, ifftwOut, FFTW_BACKWARD, FFTW_MEASURE);
}
if (openlase_output) {
openlaseBuf = (float*)malloc(sizeof(float) * fftSize * step_count);
OLRenderParams params;
memset(¶ms, 0, sizeof params);
params.rate = 48000;
params.on_speed = 2.0/100.0;
params.off_speed = 2.0/20.0;
params.start_wait = 8;
params.start_dwell = 3;
params.curve_dwell = 0;
params.corner_dwell = 8;
params.curve_angle = cosf(30.0*(M_PI/180.0)); // 30 deg
params.end_dwell = 3;
params.end_wait = 7;
params.snap = 1/100000.0;
params.render_flags = RENDER_GRAYSCALE;
if(olInit(3, 30000) < 0)
return EXIT_FAILURE;
olSetRenderParams(¶ms);
olBegin(OL_LINESTRIP);
}
result |= hackrf_start_rx(device, rx_callback, NULL);
if (result != HACKRF_SUCCESS) {
fprintf(stderr, "hackrf_start_rx() failed: %s (%d)\n", hackrf_error_name(result), result);
usage();
return EXIT_FAILURE;
}
result = hackrf_init_sweep(device, frequencies, num_ranges, num_samples * 2,
TUNE_STEP * FREQ_ONE_MHZ, OFFSET, INTERLEAVED);
if( result != HACKRF_SUCCESS ) {
fprintf(stderr, "hackrf_init_sweep() failed: %s (%d)\n",
hackrf_error_name(result), result);
return EXIT_FAILURE;
}
if (amp) {
fprintf(stderr, "call hackrf_set_amp_enable(%u)\n", amp_enable);
result = hackrf_set_amp_enable(device, (uint8_t)amp_enable);
if (result != HACKRF_SUCCESS) {
fprintf(stderr, "hackrf_set_amp_enable() failed: %s (%d)\n",
hackrf_error_name(result), result);
usage();
return EXIT_FAILURE;
}
}
if (antenna) {
fprintf(stderr, "call hackrf_set_antenna_enable(%u)\n", antenna_enable);
result = hackrf_set_antenna_enable(device, (uint8_t)antenna_enable);
if (result != HACKRF_SUCCESS) {
fprintf(stderr, "hackrf_set_antenna_enable() failed: %s (%d)\n",
hackrf_error_name(result), result);
usage();
return EXIT_FAILURE;
}
}
gettimeofday(&t_start, NULL);
fprintf(stderr, "Stop with Ctrl-C\n");
while((hackrf_is_streaming(device) == HACKRF_TRUE) && (do_exit == false)) {
float time_difference;
sleep(1);
gettimeofday(&time_now, NULL);
time_difference = TimevalDiff(&time_now, &t_start);
sweep_rate = (float)sweep_count / time_difference;
fprintf(stderr, "%" PRIu64 " total sweeps completed, %.2f sweeps/second\n",
sweep_count, sweep_rate);
if (byte_count == 0) {
exit_code = EXIT_FAILURE;
fprintf(stderr, "\nCouldn't transfer any data for one second.\n");
break;
}
byte_count = 0;
}
result = hackrf_is_streaming(device);
if (do_exit) {
fprintf(stderr, "\nExiting...\n");
} else {
fprintf(stderr, "\nExiting... hackrf_is_streaming() result: %s (%d)\n",
hackrf_error_name(result), result);
}
gettimeofday(&time_now, NULL);
time_diff = TimevalDiff(&time_now, &t_start);
fprintf(stderr, "Total sweeps: %" PRIu64 " in %.5f seconds (%.2f sweeps/second)\n",
sweep_count, time_diff, sweep_rate);
if(device != NULL) {
result = hackrf_stop_rx(device);
if(result != HACKRF_SUCCESS) {
fprintf(stderr, "hackrf_stop_rx() failed: %s (%d)\n",
hackrf_error_name(result), result);
} else {
fprintf(stderr, "hackrf_stop_rx() done\n");
}
result = hackrf_close(device);
if(result != HACKRF_SUCCESS) {
fprintf(stderr, "hackrf_close() failed: %s (%d)\n",
hackrf_error_name(result), result);
} else {
fprintf(stderr, "hackrf_close() done\n");
}
hackrf_exit();
fprintf(stderr, "hackrf_exit() done\n");
}
if(fd != NULL) {
fclose(fd);
fd = NULL;
fprintf(stderr, "fclose(fd) done\n");
}
if (openlase_output)
olShutdown();
fftwf_free(fftwIn);
fftwf_free(fftwOut);
fftwf_free(pwr);
fftwf_free(window);
fftwf_free(ifftwIn);
fftwf_free(ifftwOut);
fprintf(stderr, "exit\n");
return exit_code;
}
int rx_callback(hackrf_transfer* transfer) {
int8_t* buf;
uint8_t* ubuf;
uint64_t frequency; /* in Hz */
uint64_t band_edge;
uint32_t record_length;
int i, j, ifft_bins;
struct tm *fft_time;
char time_str[50];
struct timeval usb_transfer_time;
if(NULL == fd) {
return -1;
}
gettimeofday(&usb_transfer_time, NULL);
byte_count += transfer->valid_length;
buf = (int8_t*) transfer->buffer;
ifft_bins = fftSize * step_count;
for(j=0; j<BLOCKS_PER_TRANSFER; j++) {
ubuf = (uint8_t*) buf;
if(ubuf[0] == 0x7F && ubuf[1] == 0x7F) {
frequency = ((uint64_t)(ubuf[9]) << 56) | ((uint64_t)(ubuf[8]) << 48) | ((uint64_t)(ubuf[7]) << 40)
| ((uint64_t)(ubuf[6]) << 32) | ((uint64_t)(ubuf[5]) << 24) | ((uint64_t)(ubuf[4]) << 16)
| ((uint64_t)(ubuf[3]) << 8) | ubuf[2];
} else {
buf += BYTES_PER_BLOCK;
continue;
}
if (frequency == (uint64_t)(FREQ_ONE_MHZ*frequencies[0])) {
if(sweep_started) {
if(ifft_output) {
fftwf_execute(ifftwPlan);
for(i=0; i < ifft_bins; i++) {
ifftwOut[i][0] *= 1.0f / ifft_bins;
ifftwOut[i][1] *= 1.0f / ifft_bins;
fwrite(&ifftwOut[i][0], sizeof(float), 1, fd);
fwrite(&ifftwOut[i][1], sizeof(float), 1, fd);
}
}
if (openlase_output) {
olLoadIdentity3();
olLoadIdentity();
// olPerspective(60, 1, 1, 100);
olTranslate3(0, 0, -3);
olScale3(0.6f, 0.6f, 0.6f);
int len = fftSize * step_count;
olBegin(OL_LINESTRIP);
float mul = 2.0f / len;
for (int i = 0; i < len; i++) {
float x = i * mul - 1.0f;
float pwr = openlaseBuf[i] / 100.0f;
olVertex3(x, pwr, 0.0f, (255 << 16) | 255);
}
olEnd();
olRenderFrame(60);
}
sweep_count++;
if(one_shot) {
do_exit = true;
}
}
sweep_started = true;
time_stamp = usb_transfer_time;
time_stamp.tv_usec +=
(uint64_t)(num_samples + THROWAWAY_BLOCKS * SAMPLES_PER_BLOCK)
* j * FREQ_ONE_MHZ / DEFAULT_SAMPLE_RATE_HZ;
if(999999 < time_stamp.tv_usec) {
time_stamp.tv_sec += time_stamp.tv_usec / 1000000;
time_stamp.tv_usec = time_stamp.tv_usec % 1000000;
}
}
if(do_exit) {
return 0;
}
if(!sweep_started) {
buf += BYTES_PER_BLOCK;
continue;
}
if((FREQ_MAX_MHZ * FREQ_ONE_MHZ) < frequency) {
buf += BYTES_PER_BLOCK;
continue;
}
/* copy to fftwIn as floats */
buf += BYTES_PER_BLOCK - (fftSize * 2);
for(i=0; i < fftSize; i++) {
fftwIn[i][0] = buf[i*2] * window[i] * 1.0f / 128.0f;
fftwIn[i][1] = buf[i*2+1] * window[i] * 1.0f / 128.0f;
}
buf += fftSize * 2;
fftwf_execute(fftwPlan);
for (i=0; i < fftSize; i++) {
pwr[i] = logPower(fftwOut[i], 1.0f / fftSize);
}
if(binary_output) {
record_length = 2 * sizeof(band_edge)
+ (fftSize/4) * sizeof(float);
fwrite(&record_length, sizeof(record_length), 1, fd);
band_edge = frequency;
fwrite(&band_edge, sizeof(band_edge), 1, fd);
band_edge = frequency + DEFAULT_SAMPLE_RATE_HZ / 4;
fwrite(&band_edge, sizeof(band_edge), 1, fd);
fwrite(&pwr[1+(fftSize*5)/8], sizeof(float), fftSize/4, fd);
fwrite(&record_length, sizeof(record_length), 1, fd);
band_edge = frequency + DEFAULT_SAMPLE_RATE_HZ / 2;
fwrite(&band_edge, sizeof(band_edge), 1, fd);
band_edge = frequency + (DEFAULT_SAMPLE_RATE_HZ * 3) / 4;
fwrite(&band_edge, sizeof(band_edge), 1, fd);
fwrite(&pwr[1+fftSize/8], sizeof(float), fftSize/4, fd);
} else if(ifft_output) {
ifft_idx = (uint32_t) round((frequency - (uint64_t)(FREQ_ONE_MHZ*frequencies[0]))
/ fft_bin_width);
ifft_idx = (ifft_idx + ifft_bins/2) % ifft_bins;
for(i = 0; (fftSize / 4) > i; i++) {
ifftwIn[ifft_idx + i][0] = fftwOut[i + 1 + (fftSize*5)/8][0];
ifftwIn[ifft_idx + i][1] = fftwOut[i + 1 + (fftSize*5)/8][1];
}
ifft_idx += fftSize / 2;
ifft_idx %= ifft_bins;
for(i = 0; (fftSize / 4) > i; i++) {
ifftwIn[ifft_idx + i][0] = fftwOut[i + 1 + (fftSize/8)][0];
ifftwIn[ifft_idx + i][1] = fftwOut[i + 1 + (fftSize/8)][1];
}
} else if (openlase_output) {
ifft_idx = (uint32_t) round((frequency - (uint64_t)(FREQ_ONE_MHZ*frequencies[0]))
/ fft_bin_width);
ifft_idx = (ifft_idx + ifft_bins/2) % ifft_bins;
for(i = 0; (fftSize / 4) > i; i++) {
openlaseBuf[ifft_idx + i] = pwr[i + 1 + (fftSize*5)/8];
}
ifft_idx += fftSize / 2;
ifft_idx %= ifft_bins;
for(i = 0; (fftSize / 4) > i; i++) {
openlaseBuf[ifft_idx + i] = pwr[i + 1 + (fftSize/8)];
}
} else {
time_t time_stamp_seconds = time_stamp.tv_sec;
fft_time = localtime(&time_stamp_seconds);
strftime(time_str, 50, "%Y-%m-%d, %H:%M:%S", fft_time);
fprintf(fd, "%s.%06ld, %" PRIu64 ", %" PRIu64 ", %.2f, %u",
time_str,
(long int)time_stamp.tv_usec,
(uint64_t)(frequency),
(uint64_t)(frequency+DEFAULT_SAMPLE_RATE_HZ/4),
fft_bin_width,
fftSize);
for(i = 0; (fftSize / 4) > i; i++) {
fprintf(fd, ", %.2f", pwr[i + 1 + (fftSize*5)/8]);
}
fprintf(fd, "\n");
fprintf(fd, "%s.%06ld, %" PRIu64 ", %" PRIu64 ", %.2f, %u",
time_str,
(long int)time_stamp.tv_usec,
(uint64_t)(frequency+(DEFAULT_SAMPLE_RATE_HZ/2)),
(uint64_t)(frequency+((DEFAULT_SAMPLE_RATE_HZ*3)/4)),
fft_bin_width,
fftSize);
for(i = 0; (fftSize / 4) > i; i++) {
fprintf(fd, ", %.2f", pwr[i + 1 + (fftSize/8)]);
}
fprintf(fd, "\n");
}
}
return 0;
}
void
openlase_trace(t_jit_openlase_trace *x, int width, int height, uint8_t *base, unsigned bytesperrow)
{
//float vidtime = 0;
//int inf=0;
int bg_white = -1;
//float time = 0;
float ftime;
//int frames = 0;
OLTraceResult result;
memset(&result, 0, sizeof(result));
int thresh;
int obj;
int bsum = 0;
int c;
int thresh_dark;
int thresh_light;
int sw_dark;
int sw_light;
int decimate = x->decimate;
int edge_off;
thresh_dark = 60;
thresh_light = 160;
sw_dark = 100;
sw_light = 256;
//decimate = 1;
//decimate = 2;
edge_off = 0;
for (c=edge_off; c<(width-edge_off); c++) {
bsum += base[c+edge_off*bytesperrow];
bsum += base[c+(height-edge_off-1)*bytesperrow];
}
for (c=edge_off; c<(height-edge_off); c++) {
bsum += base[edge_off+c*bytesperrow];
bsum += base[(c+1)*bytesperrow-1-edge_off];
}
bsum /= (2*(width+height));
if (bg_white == -1)
bg_white = bsum > 128;
if (bg_white && bsum < sw_dark)
bg_white = 0;
if (!bg_white && bsum > sw_light)
bg_white = 1;
if (bg_white)
thresh = thresh_light;
else
thresh = thresh_dark;
x->tparams.threshold = thresh;
olTraceReInit(x->trace_ctx, &x->tparams);
olTraceFree(&result);
obj = olTrace(x->trace_ctx, base, bytesperrow, &result);
//do {
int i, j;
for (i = 0; i < result.count; i++) {
OLTraceObject *o = &result.objects[i];
olBegin(OL_POINTS);
OLTracePoint *p = o->points;
for (j = 0; j < o->count; j++) {
if (j % decimate == 0)
olVertex(p->x, p->y, C_WHITE);
p++;
}
olEnd();
}
ftime = olRenderFrame(200);
if (0) {
OLFrameInfo info;
char msg[256];
olGetFrameInfo(&info);
sprintf(msg, "%d:%d Thr %3d Bg %3d Pts %4d", width, height, thresh, bsum, info.points);
object_post((t_object *)x, msg);
}
//frames++;
//time += ftime;
//printf("Frame time: %.04f, Cur FPS:%6.02f, Avg FPS:%6.02f, Drift: %7.4f, "
// "In %4d, Out %4d Thr %3d Bg %3d Pts %4d",
// ftime, 1/ftime, frames/time, time-vidtime,
// inf, frames, thresh, bsum, info.points);
//if (info.resampled_points)
// printf(" Rp %4d Bp %4d", info.resampled_points, info.resampled_blacks);
//if (info.padding_points)
// printf(" Pad %4d", info.padding_points);
//printf("\n");
//} while ((time+frametime) < vidtime);
olTraceFree(&result);
}
int main (int argc, char *argv[])
{
OLRenderParams params;
memset(¶ms, 0, sizeof params);
params.rate = 48000;
params.on_speed = 2.0/100.0;
params.off_speed = 2.0/20.0;
params.start_wait = 8;
params.start_dwell = 3;
params.curve_dwell = 0;
params.corner_dwell = 8;
params.curve_angle = cosf(30.0*(M_PI/180.0)); // 30 deg
params.end_dwell = 3;
params.end_wait = 7;
params.snap = 1/100000.0;
params.render_flags = RENDER_GRAYSCALE;
if(olInit(3, 30000) < 0)
return 1;
olSetRenderParams(¶ms);
float time = 0;
float ftime;
int i,j;
int frames = 0;
while(1) {
olLoadIdentity3();
olLoadIdentity();
olPerspective(60, 1, 1, 100);
olTranslate3(0, 0, -3);
for(i=0; i<2; i++) {
if (i == 1)
olColor3(0.0,1.0,0.0);
else
olColor3(0.0,1.0,0.0);
olScale3(0.6, 0.6, 0.6);
olRotate3Z(time * M_PI * 0.1);
olRotate3Y(time * M_PI * 0.8);
olRotate3X(time * M_PI * 0.73);
olBegin(OL_LINESTRIP);
olVertex3(-1, -1, -1);
olVertex3( 1, -1, -1);
olVertex3( 1, 1, -1);
olVertex3(-1, 1, -1);
olVertex3(-1, -1, -1);
olVertex3(-1, -1, 1);
olEnd();
olBegin(OL_LINESTRIP);
olVertex3( 1, 1, 1);
olVertex3(-1, 1, 1);
olVertex3(-1, -1, 1);
olVertex3( 1, -1, 1);
olVertex3( 1, 1, 1);
olVertex3( 1, 1, -1);
olEnd();
olBegin(OL_LINESTRIP);
olVertex3( 1, -1, -1);
olVertex3( 1, -1, 1);
olEnd();
olBegin(OL_LINESTRIP);
olVertex3(-1, 1, 1);
olVertex3(-1, 1, -1);
olEnd();
}
ftime = olRenderFrame(60);
frames++;
time += ftime;
printf("Frame time: %f, FPS:%f\n", ftime, frames/time);
}
olShutdown();
exit (0);
}
static VALUE
ol_begin(VALUE self, VALUE prim)
{
olBegin(NUM2INT(prim));
return Qnil;
}
void DoTunnel(float limit)
{
params.on_speed = 2.0/100.0;
params.start_dwell = 2;
params.curve_dwell = 0;
params.corner_dwell = 2;
params.curve_angle = cosf(30.0*(M_PI/180.0)); // 30 deg
params.end_dwell = 2;
params.snap = 1/100000.0;
params.flatness = 0.000005;
params.start_wait = 6;
params.off_speed = 2.0/30.0;
params.end_wait = 3;
params.render_flags &= ~RENDER_NOREORDER;
olSetRenderParams(¶ms);
float ctime = 0;
int i,j;
olLoadIdentity();
float z = 0.0f;
float rz = 0.0f;
float dz=1.2;
int id=0;
while (audiotime < limit) {
float left = (limit-audiotime)/AB;
olResetColor();
if (ctime < 2.0)
olMultColor(C_GREY((int)(255*ctime/2)));
else if (left < 2.0)
olMultColor(C_GREY((int)(255*left/2)));
olLoadIdentity3();
olPerspective(45, 1, 1, 100);
while(z > dz) {
z -= dz;
id++;
}
olScale3(0.6, 0.6, 1.0);
olTranslate3(0, 0, 1.5);
olTranslate3(0, 0, -z);
tunnel_revxform(rz);
for(i=0;i<10;i++) {
if ((id+i) > 5) {
olPushMatrix3();
olTranslate3(0,0,dz*i);
tunnel_xform(rz+dz*(i+id));
olBegin(OL_LINESTRIP);
for(j=0;j<11;j++) {
float theta = j/5.0*M_PI;
uint32_t c = C_RED;
if(i==9) {
c = C_RED_I((int)(255 * z/dz));
}
olVertex3(sinf(theta), cosf(theta), 0, c);
//olVertex3(j/11.0,0,0,C_WHITE);
}
olEnd();
olPopMatrix3();
}
}
for(j=0;j<10;j++) {
float theta = j/5.0*M_PI;
olBegin(OL_LINESTRIP);
for(i=0;i<9;i++) {
if ((id+i) > 5) {
olPushMatrix3();
olTranslate3(0,0,dz*i);
tunnel_xform(rz+dz*(i+id));
olVertex3(sinf(theta), cosf(theta), 0,
C_GREEN_I((int)(255 * i/8.0)) | C_BLUE_I((int)(255 * (1-(i/8.0)))));
olPopMatrix3();
}
}
olEnd();
}
ctime += render();
z += ftime*3.2;
rz += ftime*3.2;
}
}
void render_cubes(float time)
{
int i;
OLRenderParams mpar;
memcpy(&mpar, ¶ms, sizeof(OLRenderParams));
if (time > 32) {
time += 1.0;
mpar.on_speed = 0.022 + (1-usin(time, 2.0)) * 0.02;
mpar.corner_dwell = 8*usin(time, 2.0);
mpar.start_dwell = 2+3*usin(time, 2.0);
mpar.start_wait = 3+5*usin(time, 2.0);
mpar.end_dwell = 2+3*usin(time, 2.0);
mpar.end_wait = 2*usin(time, 2.0);
olSetRenderParams(&mpar);
time -= 1.0;
}
printf("%f %d %d %d %d %d\n", mpar.on_speed, mpar.corner_dwell, mpar.start_dwell, mpar.start_wait, mpar.end_dwell, mpar.end_wait);
olLoadIdentity3();
olPerspective(60, 1, 1, 100);
olTranslate3(0, 0, -2.1);
for(i=0; i<3; i++) {
if (i>0)
olPushMatrix3();
olScale3(0.6, 0.6, 0.6);
if (i>0) {
float tx = sinf(time + (i-1)*M_PI);
float ty = cosf(time + (i-1)*M_PI);
float tz = sinf(time + (i-1)*M_PI);
float s = sinf(0.6*time);
olTranslate3(tx*s,ty*s,tz*s);
//olScale3(s,s,s);
olScale3(0.3,0.3,0.3);
}
float mult;
if (i==0)
mult = 1;
else if (i==1)
mult = 1.5;
else if (i==2)
mult = -1.5;
if (i==0)
olMultColor(C_GREY(120));
else
olResetColor();
olRotate3Z(mult*time * M_PI * 0.1 / 3.0);
olRotate3Y(mult*time * M_PI * 0.8 / 3.0);
olRotate3X(mult*time * M_PI * 0.73 / 3.0);
olBegin(OL_LINESTRIP);
olVertex3(-1, -1, -1, C_RED);
olVertex3( 1, -1, -1, C_RED);
olVertex3( 1, 1, -1, C_RED);
olVertex3(-1, 1, -1, C_RED);
olVertex3(-1, -1, -1, C_RED);
olVertex3(-1, -1, 1, C_RED);
olEnd();
olBegin(OL_LINESTRIP);
olVertex3( 1, 1, 1, C_GREEN);
olVertex3(-1, 1, 1, C_GREEN);
olVertex3(-1, -1, 1, C_GREEN);
olVertex3( 1, -1, 1, C_GREEN);
olVertex3( 1, 1, 1, C_GREEN);
olVertex3( 1, 1, -1, C_GREEN);
olEnd();
olBegin(OL_LINESTRIP);
olVertex3( 1, -1, -1, C_RED);
olVertex3( 1, -1, 1, C_RED);
olEnd();
olBegin(OL_LINESTRIP);
olVertex3(-1, 1, 1, C_GREEN);
olVertex3(-1, 1, -1, C_GREEN);
olEnd();
/*olBegin(OL_BEZIERSTRIP);
olVertex3(-1, 1, 0, C_WHITE);
olVertex3(0, -1, 0, C_WHITE);
olVertex3(0, -1, 0, C_WHITE);
olVertex3(1, 1, 0, C_WHITE);
olVertex3(-1, 0, 0, C_WHITE);
olVertex3(-1, 0, 0, C_WHITE);
olVertex3(1, -1, 0, C_WHITE);
olVertex3(0, 1, 0, C_WHITE);
olVertex3(0, 1, 0, C_WHITE);
olVertex3(-1, -1, 0, C_WHITE);
olVertex3(1, 0, 0, C_WHITE);
olVertex3(1, 0, 0, C_WHITE);
olVertex3(-1, 1, 0, C_WHITE);
olEnd();*/
if (i>0)
olPopMatrix3();
}
olLoadIdentity3();
olLoadIdentity();
olSetRenderParams(¶ms);
olResetColor();
}
void *display_thread(void *arg)
{
PlayerCtx *ctx = arg;
int i;
OLRenderParams params;
memset(¶ms, 0, sizeof params);
params.rate = 48000;
params.on_speed = 2.0/100.0;
params.off_speed = 2.0/15.0;
params.start_wait = 8;
params.end_wait = 3;
params.snap = 1/120.0;
params.render_flags = RENDER_GRAYSCALE;
params.min_length = 20;
params.start_dwell = 2;
params.end_dwell = 2;
params.max_framelen = 48000/20.0;
if(olInit(OL_FRAMES_BUF, 300000) < 0) {
printf("OpenLase init failed\n");
return NULL;
}
float aspect = ctx->width / (float)ctx->height;
float sample_aspect = av_q2d(ctx->v_stream->sample_aspect_ratio);
if (sample_aspect != 0)
aspect *= sample_aspect;
printf("Aspect: %f\n", aspect);
float iaspect = 1/aspect;
int maxd = ctx->width > ctx->height ? ctx->width : ctx->height;
int mind = ctx->width < ctx->height ? ctx->width : ctx->height;
g_ctx = ctx;
olSetAudioCallback(get_audio);
olSetRenderParams(¶ms);
OLTraceCtx *trace_ctx;
OLTraceParams tparams;
OLTraceResult result;
memset(&result, 0, sizeof(result));
ctx->settings_changed = 1;
tparams.sigma = ctx->settings.blur / 100.0;
if (ctx->settings.canny)
tparams.mode = OL_TRACE_CANNY;
else
tparams.mode = OL_TRACE_THRESHOLD;
tparams.width = ctx->width;
tparams.height = ctx->height;
printf("Resolution: %dx%d\n", ctx->width, ctx->height);
olTraceInit(&trace_ctx, &tparams);
VideoFrame *last = NULL;
pthread_mutex_lock(&ctx->display_mode_mutex);
DisplayMode display_mode = ctx->display_mode;
pthread_mutex_unlock(&ctx->display_mode_mutex);
int inf = 0;
int bg_white = -1;
float time = 0;
int frames = 0;
while (display_mode != STOP) {
pthread_mutex_lock(&ctx->settings_mutex);
PlayerSettings settings = ctx->settings;
int settings_changed = ctx->settings_changed;
ctx->settings_changed = 0;
pthread_mutex_unlock(&ctx->settings_mutex);
if (ctx->audio_idx == -1) {
drop_all_video(ctx);
next_video_frame(ctx);
}
params.min_length = settings.minsize;
params.end_dwell = params.start_dwell = settings.dwell;
params.off_speed = settings.offspeed * 0.002;
params.snap = (settings.snap*2.0)/(float)maxd;
params.start_wait = settings.startwait;
params.end_wait = settings.endwait;
if (settings.minrate == 0)
params.max_framelen = 0;
else
params.max_framelen = params.rate / settings.minrate;
olSetRenderParams(¶ms);
olLoadIdentity();
if (aspect > 1) {
olSetScissor(-1, -iaspect, 1, iaspect);
olScale(1, iaspect);
} else {
olSetScissor(-aspect, -1, aspect, 1);
olScale(aspect, 1);
}
olScale(1 + settings.overscan/100.0, 1 + settings.overscan/100.0);
olTranslate(-1.0f, 1.0f);
olScale(2.0f/ctx->width, -2.0f/ctx->height);
if (!ctx->cur_frame || ctx->cur_frame->seekid < 0) {
printf("Dummy frame\n");
float ftime = olRenderFrame(80);
pthread_mutex_lock(&ctx->display_mode_mutex);
display_mode = ctx->display_mode;
pthread_mutex_unlock(&ctx->display_mode_mutex);
if (ctx->cur_frame && ctx->cur_frame->seekid < 0)
deliver_event(ctx, time, ftime, frames, 1);
else
deliver_event(ctx, time, ftime, frames, 0);
continue;
}
if (last != ctx->cur_frame || settings_changed) {
tparams.sigma = settings.blur / 100.0;
if (settings.canny) {
tparams.mode = OL_TRACE_CANNY;
tparams.threshold = settings.threshold;
tparams.threshold2 = settings.threshold2;
bg_white = -1;
} else {
tparams.mode = OL_TRACE_THRESHOLD;
if (settings.splitthreshold) {
int edge_off = mind * settings.offset / 100;
int bsum = 0;
int cnt = 0;
int c;
for (c = edge_off; c < (ctx->width-edge_off); c++) {
bsum += ctx->cur_frame->data[c+edge_off*ctx->cur_frame->stride];
bsum += ctx->cur_frame->data[c+(ctx->height-edge_off-1)*ctx->cur_frame->stride];
cnt += 2;
}
for (c = edge_off; c < (ctx->height-edge_off); c++) {
bsum += ctx->cur_frame->data[edge_off+ctx->cur_frame->stride];
bsum += ctx->cur_frame->data[(c+1)*ctx->cur_frame->stride-1-edge_off];
cnt += 2;
}
bsum /= cnt;
if (bg_white == -1)
bg_white = bsum > ((settings.darkval + settings.lightval)/2);
if (bg_white && bsum < settings.darkval)
bg_white = 0;
if (!bg_white && bsum > settings.lightval)
bg_white = 1;
if (bg_white)
tparams.threshold = settings.threshold2;
else
tparams.threshold = settings.threshold;
} else {
tparams.threshold = settings.threshold;
}
}
olTraceReInit(trace_ctx, &tparams);
olTraceFree(&result);
printf("Trace\n");
olTrace(trace_ctx, ctx->cur_frame->data, ctx->cur_frame->stride, &result);
printf("Trace done\n");
inf++;
last = ctx->cur_frame;
}
int i, j;
for (i = 0; i < result.count; i++) {
OLTraceObject *o = &result.objects[i];
olBegin(OL_POINTS);
OLTracePoint *p = o->points;
for (j = 0; j < o->count; j++) {
if (j % settings.decimation == 0)
olVertex(p->x, p->y, C_WHITE);
p++;
}
olEnd();
}
float ftime = olRenderFrame(80);
OLFrameInfo info;
olGetFrameInfo(&info);
frames++;
time += ftime;
printf("Frame time: %.04f, Cur FPS:%6.02f, Avg FPS:%6.02f, Drift: %7.4f, "
"In %4d, Out %4d Thr %3d/%3d Bg %3d Pts %4d",
ftime, 1/ftime, frames/time, 0.0, inf, frames,
tparams.threshold, tparams.threshold2, 0, info.points);
if (info.resampled_points)
printf(" Rp %4d Bp %4d", info.resampled_points, info.resampled_blacks);
if (info.padding_points)
printf(" Pad %4d", info.padding_points);
printf("\n");
deliver_event(ctx, time, ftime, frames, 0);
pthread_mutex_lock(&ctx->display_mode_mutex);
display_mode = ctx->display_mode;
pthread_mutex_unlock(&ctx->display_mode_mutex);
}
olTraceDeinit(trace_ctx);
for(i = 0; i < OL_FRAMES_BUF; i++)
olRenderFrame(80);
olShutdown();
return NULL;
}
