Ejemplo n.º 1
0
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();
}
Ejemplo n.º 2
0
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();
}
Ejemplo n.º 3
0
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();
}
Ejemplo n.º 4
0
int main (int argc, char *argv[])
{
	OLRenderParams params;
	AVFrame *frame;
	int i;

	// Register all formats and codecs
	av_register_all();

	memset(&params, 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(&params);

	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);
}
Ejemplo n.º 5
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;
}
Ejemplo n.º 6
0
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);
}	
Ejemplo n.º 8
0
int main (int argc, char *argv[])
{
	OLRenderParams params;

	memset(&params, 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(&params);

	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);
}
Ejemplo n.º 9
0
static VALUE
ol_end(VALUE self)
{
  olEnd();
  return Qnil;
}
Ejemplo n.º 10
0
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(&params);

	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;

	}
}
Ejemplo n.º 11
0
void render_cubes(float time)
{
	int i;

	OLRenderParams mpar;

	memcpy(&mpar, &params, 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(&params);
	olResetColor();
}
Ejemplo n.º 12
0
void *display_thread(void *arg)
{
	PlayerCtx *ctx = arg;
	int i;

	OLRenderParams params;
	memset(&params, 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(&params);

	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(&params);

		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;
}