예제 #1
0
파일: genlock.c 프로젝트: nasa/QuIP
static u_long delta_usecs()
{
	if( tvp == NULL ){
		gettimeofday(&tv0,&tz);
		tvp = &tv0;
		return(0);
	}
	gettimeofday(&tv1,&tz);
	return( compute_latency(&tv1,&tv0) );
}
예제 #2
0
Pf *
orbsources2pf( double atime, Orbsrc *sources, int nsources )
{
	Orbsrc	*asource;
	Pf 	*pf;
	Pf	*pfsources;
	Pf	*sourcepf;
	int	isource;
	double 	kbaud;
	double	latency_sec;

	pf = pfnew( PFFILE );

	pfput_time( pf, "source_when", atime );

	pfsources = pfnew( PFARR );

	for( isource = 0; isource < nsources; isource++ ) {

		sourcepf = pfnew( PFARR );

		asource = &sources[isource];

		pfput_time( sourcepf, "slatest_time", asource->slatest_time );
		pfput_time( sourcepf, "soldest_time", asource->soldest_time );

		pfput_int( sourcepf, "nbytes", asource->nbytes );
		pfput_int( sourcepf, "npkts", asource->npkts );
		pfput_int( sourcepf, "slatest", asource->slatest );
		pfput_int( sourcepf, "soldest", asource->soldest );

		pfput_boolean( sourcepf, "active", asource->active );
		
		if( ( kbaud = compute_kbaud( asource ) ) >= 0 ) {

			pfput_double( sourcepf, "kbaud", kbaud );
		}

		latency_sec = compute_latency( atime, asource );

		pfput_double( sourcepf, "latency_sec", latency_sec );

		pfput( pfsources, asource->srcname, sourcepf, PFPF );
	}

	pfput( pf, "sources", pfsources, PFPF );

	return pf;
}
예제 #3
0
파일: genlock.c 프로젝트: nasa/QuIP
void genlock_vblank(Genlock_Info *glip)
{
	int original_pp_value, current_pp_value;
	int original_vbl_state[MAX_HEADS], current_vbl_state[MAX_HEADS];
	int in_blanking[MAX_HEADS];
	int i;
	struct timeval tv_now;
	struct timezone tz;
	long prev_latency;
	int all_in_blanking;
#ifdef THREAD_SAFE_QUERY
	Query_Stack *qsp=glip->gli_qsp;
#endif // THREAD_SAFE_QUERY

	if( ! genlock_active ){
		WARN("genlock_vblank:  genlock is not initialized");
		return;
	}

	original_pp_value = read_parport_status(glip->gli_ppp) & PARPORT_SYNC_MASK;
	all_in_blanking=0;
	for(i=0;i<glip->gli_n_heads;i++){
		original_vbl_state[i] = read_vbl_state(QSP_ARG  glip->gli_fbip[i]->fbi_fd);
		in_blanking[i]=0;
	}

	while( ! all_in_blanking ){
		current_pp_value = read_parport_status(glip->gli_ppp) & PARPORT_SYNC_MASK;
		if( current_pp_value != original_pp_value ){
			gettimeofday(&tv_now,&tz);
			if( current_pp_value == 0 ){
				/* beginning of negative pulse */
				glip->gli_tv_pp[0] = tv_now;
				for(i=0;i<glip->gli_n_heads;i++){
					glip->gli_pp_latency[i] = compute_latency(&tv_now,&glip->gli_tv_fb[i][0]);
				}
			}
			else
				glip->gli_tv_pp[1] = tv_now;
			original_pp_value = current_pp_value;
		}
		for(i=0;i<glip->gli_n_heads;i++){
			current_vbl_state[i] = read_vbl_state(QSP_ARG  glip->gli_fbip[i]->fbi_fd);
			if( current_vbl_state[i] != original_vbl_state[i] ){
				gettimeofday(&tv_now,&tz);
				if( current_vbl_state[i] == 0 )
					/* end of vblank pulse */
					glip->gli_tv_fb[i][1] = tv_now;
				else {
					long drift;

					/* beginning of vblank pulse */
					glip->gli_tv_fb[i][0] = tv_now;
					prev_latency = glip->gli_fb_latency[i];
					glip->gli_fb_latency[i] = compute_latency(&tv_now,&glip->gli_tv_pp[0]);
					if( prev_latency > 0 ){
						drift = glip->gli_fb_latency[i] - prev_latency;
						if( drift > 10000 )
							drift -= 16666;
						if( drift < -10000 )
							drift += 16666;
						/* fading average */
						glip->gli_drift[i] =
							DRIFT_MEMORY * glip->gli_drift[i] +
							(1-DRIFT_MEMORY) * drift;
						glip->gli_refractory[i] --;
						if( glip->gli_refractory[i] <= 0 )
							adjust_genlock(QSP_ARG  glip,i);
					}
					in_blanking[i]=1;
				}
				original_vbl_state[i] = current_vbl_state[i];
			}
		}

		all_in_blanking = 1;
		for(i=0;i<glip->gli_n_heads;i++)
			all_in_blanking &= in_blanking[i];
	}
}
예제 #4
0
파일: genlock.c 프로젝트: nasa/QuIP
static void *genlock_daemon(void *argp)
{
	Genlock_Info *glip;
	int original_pp_value, current_pp_value;
	int original_vbl_state[MAX_HEADS], current_vbl_state[MAX_HEADS];
	int i;
	struct timeval tv_now;
	struct timezone tz;
	long prev_latency;
	Query_Stack *qsp;

	glip = (Genlock_Info *) argp;
	qsp = glip->gli_qsp;

	original_pp_value = read_parport_status(glip->gli_ppp) & PARPORT_SYNC_MASK;
	for(i=0;i<glip->gli_n_heads;i++)
		original_vbl_state[i] = read_vbl_state(QSP_ARG  glip->gli_fbip[i]->fbi_fd);

	while(genlock_active){
		current_pp_value = read_parport_status(glip->gli_ppp) & PARPORT_SYNC_MASK;
		if( current_pp_value != original_pp_value ){
			gettimeofday(&tv_now,&tz);
			if( current_pp_value == 0 ){
				/* beginning of negative pulse */
				glip->gli_tv_pp[0] = tv_now;
				for(i=0;i<glip->gli_n_heads;i++){
					glip->gli_pp_latency[i] = compute_latency(&tv_now,&glip->gli_tv_fb[i][0]);
				}
			}
			else
				glip->gli_tv_pp[1] = tv_now;
			original_pp_value = current_pp_value;
		}
		for(i=0;i<glip->gli_n_heads;i++){
			current_vbl_state[i] = read_vbl_state(QSP_ARG  glip->gli_fbip[i]->fbi_fd);
			if( current_vbl_state[i] != original_vbl_state[i] ){
				gettimeofday(&tv_now,&tz);
				if( current_vbl_state[i] == 0 )
					/* end of vblank pulse */
					glip->gli_tv_fb[i][1] = tv_now;
				else {
					long drift;

					/* beginning of vblank pulse */
					glip->gli_tv_fb[i][0] = tv_now;
					prev_latency = glip->gli_fb_latency[i];
					glip->gli_fb_latency[i] = compute_latency(&tv_now,&glip->gli_tv_pp[0]);
					if( prev_latency > 0 ){
						drift = glip->gli_fb_latency[i] - prev_latency;
						if( drift > 10000 )
							drift -= 16666;
						if( drift < -10000 )
							drift += 16666;
/*
printf("drift = %ld\n",drift);
fflush(stdout);
*/
						/* fading average */
						glip->gli_drift[i] =
							DRIFT_MEMORY * glip->gli_drift[i] +
							(1-DRIFT_MEMORY) * drift;
						glip->gli_refractory[i] --;
						if( glip->gli_refractory[i] <= 0 )
							adjust_genlock(QSP_ARG  glip,i);
					}
				}
				original_vbl_state[i] = current_vbl_state[i];
			}
		}
	}
	return(NULL);
}