vdc.c

linux 嵌入式原代码

	}

#if PIXUT
	pix_pat(PIXUT_PAT_GRAD, NULL, cfg.pix_x, cfg.pix_y, mmap_area, pix_type_rgb(pack), 0, 0);
	ioctl(fd, VDCIOCSDAT, 0);
	pix_pat(PIXUT_PAT_BW, NULL, cfg.pix_x, cfg.pix_y, mmap_area, pix_type_rgb(pack), 0, 0);
	ioctl(fd, VDCIOCSDAT, 1);
#else
	rgb_test_data_set_grad(mmap_area, pack);
	ioctl(fd, VDCIOCSDAT, 0);
	rgb_test_data_set_bw(mmap_area + cfg.buf_unit_sz, pack);
	ioctl(fd, VDCIOCSDAT, 1);
#endif

    }else{
#endif


#if PIXUT
	pix_pat(ac, av, cfg.pix_x, cfg.pix_y, mmap_area, pix_type_rgb(pack), PIXUT_PAT_BW, 0);
#else
	if(opt_chk(ac,av,"-grad")){
		rgb_test_data_set_grad(mmap_area, pack);
	}else if(opt_chk(ac,av,"-cbar")){
		rgb_test_data_set_cbar(mmap_area, pack);
	}else{
		rgb_test_data_set_bw(mmap_area, pack);
	}
#endif


#if RGB_DBL
    }
#endif

#if YUV_TEST_DATA
	}
#endif

	//	cfg.rddl = 0;

#if 0 /* test */
	cfg.hls = 1;
#else
	cfg.hls = 0;
#endif
	cfg.pal = 0;
	cfg.cscv = 0; /* direct */
	cfg.dbls = 0;
	cfg.r601 = 0; /* FIX */
	cfg.tfop = 0;

	cfg.dsm = 0; /* no interlace */

	cfg.dfp = pack ? 0 : 1; 
		/* 0: 4 pix --> 3 word pack ( 12 bytes ) */
		/* 1: 1 pix 1 word */
	opt_chk_int(ac,av,"-dfp", &cfg.dfp);

	cfg.die =1;
	cfg.enop = 0;
	cfg.vsop = 0;
	opt_chk_int(ac,av,"-vsop", &cfg.vsop);
	cfg.hsop = 0;
	opt_chk_int(ac,av,"-hsop", &cfg.hsop);
	cfg.dsr = 0;
#if CSRON_OPT
#else
	cfg.csron = 0;
#endif
	cfg.dpf = 1; /* RGB */
	cfg.dms = 3;

#if RGB_DBL
	cfg.rd_count_buf_idx = 1;
#endif

#if YUV_TEST_DATA
	if(opt_chk(ac,av,"-yuv")){
		cfg.cscv = 2;
		cfg.dfp = 0;
	}
#endif

	if(ioctl(fd, VDCIOCSCFG, &cfg) != 0){
		fprintf(stderr, "ioctl set cfg err\n");
		close(fd);
		return -1;
	}
	if(ioctl(fd, VDCIOCGCFG, &cfg) != 0){
		fprintf(stderr, "ioctl get cfg err\n");
		close(fd);
		return -1;
	}

#if CFGCHK
	/* --> config_show() */
#else
	if(opt_chk(ac,av,"-v")){
		printf("H: %d + %d + %d + %d + %d = %d\n",
			cfg.prm[1], 
			cfg.prm[2], 
			cfg.prm[3], 
			cfg.prm[4], 
			cfg.prm[10], 

			cfg.prm[1]+ 
			cfg.prm[2]+ 
			cfg.prm[3]+ 
			cfg.prm[4]+ 
			cfg.prm[10]);

		printf("V: %d + %d + %d + %d + %d = %d\n",
			cfg.prm[6], 
			cfg.prm[7], 
			cfg.prm[8], 
			cfg.prm[9], 
			cfg.prm[11], 

			cfg.prm[6]+ 
			cfg.prm[7]+ 
			cfg.prm[8]+ 
			cfg.prm[9]+ 
			cfg.prm[11]);

		printf("RCK: %d RDDL: %d\n",
		       cfg.prm[12], cfg.rddl);
	}
#endif

	ioctl(fd, VDCIOCSDAT, 0);
#if CFGCHK
#if REGIO_TEST
	ioctl_start(ac, av, fd, 0);
#else
	ioctl_start(fd, 0);
#endif
#else
	ioctl(fd, VDCIOCSTART, 0);
#endif
#if RGB_DBL
	if(rgb_dbl){
		wait_ut_dbl(fd, sec, pack);
	}else{
		wait_ut(fd, sec);
	}
#else
	wait_ut(fd, sec);
#endif
	ioctl(fd, VDCIOCSTOP, 0);
	return 0;
}

static int
y2rgb(int ac, char **av, int sec)
{
    {
	static int prm[13] = {
		0, /* htc */
		640, /* hdc */
		23, /* hfp */
		96, /* hsc */
		48, /* hbp */

		0, /* vtc */
		480, /* vdc */
		11, /* vfp */
		2, /* vsc */
		32, /* vbp */

		0, /* hip */
		0, /* vip */
		2, /* rck */	/* !!! */
	};

	bcopy(prm, cfg.prm, 4*13);
    }

	cfg.pix_x = cfg.prm[1];
	cfg.pix_y = cfg.prm[6];

	cfg.cscv = 2;
	opt_chk_int(ac,av,"-cscv", &cfg.cscv);

	/*cfg.r601 = 1;*/
	cfg.dsm = 0; /* no interlace */
	cfg.dpf = 1; /* RGB */

	if(ioctl(fd, VDCIOCSCFG, &cfg) != 0){
		fprintf(stderr, "ioctl set cfg err\n");
		close(fd);
		return -1;
	}
	if(ioctl(fd, VDCIOCGCFG, &cfg) != 0){
		fprintf(stderr, "ioctl get cfg err\n");
		close(fd);
		return -1;
	}

	printf("y2rgb start\n");

	ioctl(fd, VDCIOCSDAT, 0);
#if CFGCHK
#if REGIO_TEST
	ioctl_start(ac, av, fd, 0);
#else
	ioctl_start(fd, 0);
#endif
#else
	ioctl(fd, VDCIOCSTART, 0);
#endif
	wait_ut(fd, sec);
	ioctl(fd, VDCIOCSTOP, 0);
	return 0;
}

#endif /* RGB */

static void
#if REGIO_TEST
still_util(int ac, char **av, int sec)
#else
still_util(int sec)
#endif
{
	ioctl(fd, VDCIOCSDAT, 0);
#if REGIO_TEST
	ioctl_start(ac, av, fd, 0);
#else
	ioctl_start(fd, 0);
#endif
	wait_ut(fd, sec);
	ioctl(fd, VDCIOCSTOP, 0);
}

static int
still_mode(int ac, char **av, int sec)
{
	char *name;

	if(opt_chk_str(ac, av, "-f", &name) == -1) return -1;
	if(load_area(name, mmap_area) < 0){
		return -1;
	}

#if RGB
	if(opt_chk(ac,av,"-y2rgb")){
		return y2rgb(ac,av,sec);
	}
#endif /* RGB */

#if REGIO_TEST
	still_util(ac, av, sec);
#else
	still_util(sec);
#endif
	return 0;
}

static int
load_yuvs(int ac, char **av)
{
	int yuvidx, frmcnt, max_frmcnt, i;
	char *fmt, name[64];
	unsigned char *p;

	yuvidx = 0;
	frmcnt = 1;
	opt_chk_int2(ac, av, "-load", &yuvidx, &frmcnt);

	fmt = "cap%03d.yuv";
	opt_chk_str(ac, av, "-fmt", &fmt);

	sprintf(name, fmt, yuvidx);
	if(file_sz(name) < 0){
		fprintf(stderr, "%s ???\n", name);
		return -1;
	}

	max_frmcnt = TMPBUF_SIZE / cfg.buf_unit_sz;
	if(frmcnt > max_frmcnt){
		fprintf(stderr, "no mem frmcnt %d --> %d\n", 
			frmcnt, max_frmcnt);
		frmcnt = max_frmcnt;
	}
	p = local_area;
	for(i=0; i<frmcnt; i++){
		sprintf(name, fmt, yuvidx + i);
		if(load_area(name, p) < 0){
			fprintf(stderr, "load %s err\n", name);
			return -1;
		}
		p += cfg.buf_unit_sz;
	}
	return 0;
}

static int
vsync_test(int ac, char **av, int fd, int nonblock, int sec)
{
	char *name;
	int mode, vfd, run;
	struct timeval tm_sta, tm_now, tm_tmp;
	struct fr400vdc_read inf;
	int x;

	name = "/dev/fr400cc_vdc_vsync";
	mode = O_RDONLY;
	if(nonblock) mode |= O_NONBLOCK;
	
	if((vfd = open(name, mode)) < 0){
		fprintf(stderr, "vsync_test: open %s fd=%d\n", 
			name, vfd);
		return -1;
	}
	
	gettimeofday(&tm_sta, NULL);
	ioctl(fd, VDCIOCVSSTART);

	run = 1;
	while(run){
		if(nonblock){
			fd_set setr;
			FD_ZERO(&setr);
			FD_SET(vfd, &setr);
			x = select(vfd+1, &setr, NULL, NULL, NULL);
			if(x <= 0 || !FD_ISSET(vfd, &setr)) continue;
		}
		
		if((x = read(vfd, (void*)&inf, sizeof(inf))) < sizeof(inf)){
			fprintf(stderr, "vsync_test: read err x=%d\n", x);
		}

		gettimeofday(&tm_now, NULL);
		tm_dif(&tm_now, &tm_sta, &tm_tmp);
		if(tm_tmp.tv_sec >= sec){
			run = 0;
		}
#if TXT_DEBUG
		sprintf(txtbuf_get(), "type=%d cnt=%d sec=%d usec=%d\n", 
			inf.type, inf.count, tm_now.tv_sec, tm_now.tv_usec);
		txtbuf_add();
#endif
#if DBG_MSG
		printf("type=%d cnt=%d sec=%d usec=%d\n", 
			inf.type, inf.count, tm_now.tv_sec, tm_now.tv_usec);
#endif
	}
	ioctl(fd, VDCIOCVSSTOP);
	close(vfd);
#if TXT_DEBUG
	txtbuf_dump();
#endif
	return 0;
}

static int
vsync_test_auto(int ac, char **av)
{
	char *name;
	int mode, vfd, run;
	struct timeval tm_sta, tm_now, tm_tmp;
	struct fr400vdc_read inf;
	int x;

	name = "/dev/fr400cc_vdc_vsync";
	mode = O_RDONLY;
	
	if((vfd = open(name, mode)) < 0){
		fprintf(stderr, "vsync_test: open %s fd=%d\n", 
			name, vfd);
		return -1;
	}
	
	run = 1;
	while(run){
		if((x = read(vfd, (void*)&inf, sizeof(inf))) < sizeof(inf)){
			fprintf(stderr, "vsync_test: read err x=%d\n", x);
		}

		gettimeofday(&tm_now, NULL);
#if TXT_DEBUG
		sprintf(txtbuf_get(), "type=%d cnt=%d sec=%d usec=%d\n", 
			inf.type, inf.count, tm_now.tv_sec, tm_now.tv_usec);
		txtbuf_add();
#endif
#if DBG_MSG
		printf("type=%d cnt=%d sec=%d usec=%d\n", 
			inf.type, inf.count, tm_now.tv_sec, tm_now.tv_usec);
#endif
		/* non stop ... */
	}
	close(vfd);
#if TXT_DEBUG
	txtbuf_dump();
#endif
	return 0;
}

#if OPTCHK
static char *opt_list[] = {
"help","-help","?",

"hdc","hfp","hsc","hbp",
"vdc","vfp","vsc","vbp",
"vsop","hsop",
"hip","vip",
"rck","rddl",
"ats",
"cscv",
"dsm","interlace", "csron",

"load","fmt","cnt","sec","f",
"nonblock","block",

"xga","h320","lcd","qvga","skipbf",
"rgb","y2rgb","yuv",
"pack","grad","cbar","bw","mix","dbl",
"v",
"dma-mode","bit",
"showall-stop",
"vsync-auto","vsync",
"rd_count_buf_idx",

#if REGIO_TEST
"rct1","rct2","csr-x","csr-y","bci","show-rs",
"regio-w","regio-r",
#endif

};

static int
optchk_top(int ac, char **av)
{
	int i, j, n, ret;

	ret = 0;
	n = sizeof(opt_list) / sizeof(opt_list[0]);
	for(i=1; i<ac; i++){
		if(av[i][0] != '-') continue;
		if('0' <= av[i][1] && av[i][1] <= '9') continue;
		for(j=0; j<n; j++){
			if(strcmp(&av[i][1], opt_list[j]) == 0) break;
		}
		if(j<n) continue;
		fprintf(stderr, "ignore option '%s' ?\n", av[i]);
		ret = -1;
	}
	return ret;
}
#endif /* OPTCHK */

main(int ac, char **av)
{
	int nonblock, open_flag, tmp;
	int frmcnt, max_frmcnt, data_set_frm;
	int run, sec, vsync;
	struct fr400vdc_read inf[100];
	struct timeval tm_sta, tm_now, tm_tmp;
	fd_set setr;
	int i, x, n;
	int bit, qvga;

#if OPTCHK
	if(optchk_top(ac,av) != 0) return -1;
#endif

#if CFGCHK
	verbose = (opt_chk(ac,av, "-v") != 0);
#endif

	if(opt_chk(ac,av,"--help") != 0 ||
	   opt_chk(ac,av,"-help") != 0 ||
	   opt_chk(ac,av,"-?") != 0){
		help();
		return 0;
	}

	if(opt_chk(ac, av, "-vsync-auto") != 0){
		return vsync_test_auto(ac, av);
	}

	vsync = (opt_chk(ac, av, "-vsync") != 0);

	nonblock = 1;
	opt_chk_int(ac, av, "-nonblock", &nonblock);
	if(nonblock == 1 && opt_chk(ac, av, "-block") != 0){
		nonblock = 0;
	}
	open_flag = O_RDONLY;
	if(nonblock) open_flag |= O_NONBLOCK;

	if((fd = open("/dev/fr400cc_vdc", open_flag)) < 0){
		fprintf(stderr, "fd=%d\n", fd);
		return -1;
	}

	if(ioctl(fd, VDCIOCGCFG, &cfg) != 0){
		fprintf(stderr, "ioctl get cfg err.\n");
		close(fd);
		return -1;
	}

	bit = 16;
	opt_chk_int(ac,av,"-bit", &bit);
	qvga = opt_chk(ac,av,"-qvga");

	if(qvga){
		cfg.pix_x = 640;
		cfg.prm[1] = 640;
		cfg.prm[10] = (720-640)/2;
	}
	if(bit == 8){
		cfg.dpf = 3;
		cfg.prm[12] = 2;
	}

	cfg.skipbf = 0;
	opt_chk_int(ac, av, "-skipbf", &cfg.skipbf);
	opt_chk_int(ac,av,"-rddl", &cfg.rddl);
#if VDC_CFG_MOD
	opt_chk_int(ac,av,"-ats", &cfg.dma_ats);
	opt_chk_int(ac,av,"-dma-mode", &cfg.dma_mode);
#endif

#if 1 /* test Dec10 */
	opt_chk_int(ac,av,"-dsm", &cfg.dsm);
	opt_chk_int(ac,av,"-interlace", &cfg.dsm);
#endif

#if CSRON_OPT
	opt_chk_int(ac,av,"-csron", &cfg.csron);
#endif
	if(ioctl(fd, VDCIOCSCFG, &cfg) != 0){
		fprintf(stderr, "ioctl set cfg err\n");
		close(fd);
		return -1;
	}
	if(ioctl(fd, VDCIOCGCFG, &cfg) != 0){
		fprintf(stderr, "ioctl get cfg err\n");
		close(fd);
		return -1;
	}

	if(opt_chk(ac,av,"-load") != 0){
		x = load_yuvs(ac, av);
		close(fd);
		return x;
	}
	
	/**/

	if((mmap_area = mmap_fd(fd)) == (void*)-1){
		fprintf(stderr, "mmap err\n");
		close(fd);
		return -1;
	}

	sec = 10;
	opt_chk_int(ac, av, "-sec", &sec);

	if(vsync){
		x = vsync_test(ac, av, fd, nonblock, sec);
		close(fd);
		return x;
	}

	if(opt_chk(ac,av,"-rgb") != 0){
		x = rgb_test(ac, av, sec);
		close(fd);
		return x;
	}
	if(opt_chk(ac,av,"-f") != 0){
		x = still_mode(ac, av, sec);
		close(fd);
		return x;
	}
	if(pix_pat(ac, av, cfg.pix_x, cfg.pix_y, mmap_area, PIXUT_YUV, 0, 1) == 0){
#if REGIO_TEST
		still_util(ac, av, sec);
#else
		still_util(sec);
#endif
		close(fd);
		return 0;
	}	

	frmcnt = 1;
	opt_chk_int(ac, av, "-cnt", &frmcnt);

	max_frmcnt = TMPBUF_SIZE / cfg.buf_unit_sz;
	if(frmcnt > max_frmcnt){
		fprintf(stderr, "no mem -cnt %d --> %d\n",
			frmcnt, max_frmcnt);
		frmcnt = max_frmcnt;
	}

	cfg.stop_immidiate = (opt_chk(ac,av,"-showall-stop") == 0);
	cfg.rd_count_buf_idx = (opt_chk(ac,av,"-rd_count_buf_idx") != 0);

	if(ioctl(fd, VDCIOCSCFG, &cfg) != 0){
		fprintf(stderr, "ioctl set cfg err\n");
		close(fd);
		return -1;
	}
	if(ioctl(fd, VDCIOCGCFG, &cfg) != 0){
		fprintf(stderr, "ioctl get cfg err\n");
		close(fd);
		return -1;
	}

	/**/

	for(i=0; i<cfg.buf_num; i++){
		data_set(local_area, i % frmcnt, mmap_area, i);
		ioctl(fd, VDCIOCSDAT, i);
	}
	data_set_frm = cfg.buf_num;

	gettimeofday(&tm_sta, NULL);

#if CFGCHK
#if REGIO_TEST
	if(ioctl_start(ac, av, fd, 0) != 0){
#else
	if(ioctl_start(fd, 0) != 0){
#endif
#else
	if(ioctl(fd, VDCIOCSTART, 0) != 0){
#endif
		fprintf(stderr, "ioctl start err\n");
		close(fd);
		return -1;
	}

	run = 1;
	while(run){
		if(nonblock){
			FD_ZERO(&setr);
			FD_SET(fd, &setr);
#if TXT_DEBUG
			sprintf(txtbuf_get(), ">sel\n");
			txtbuf_add();
#endif
			x = select(fd+1, &setr, NULL, NULL, NULL);
#if TXT_DEBUG
			sprintf(txtbuf_get(), "<sel x=%d ck=%d\n", x, FD_ISSET(fd, &setr));
			txtbuf_add();
#endif
			if(x <= 0 || !FD_ISSET(fd, &setr)) continue;
		}

		if((x = read(fd, (void*)inf, sizeof(inf))) < 0) continue;

		n = x / sizeof(inf[0]);
		for(i=0; i<n; i++){
			int buf_idx;
#if TXT_DEBUG
			sprintf(txtbuf_get(), "type=%d cnt=%d\n", inf[i].type, inf[i].count);
			txtbuf_add();
#endif
#if DBG_MSG
			printf("type=%d cnt=%d\n", inf[i].type, inf[i].count);
#endif
			if(inf[i].type == FR400CC_VDC_RTYPE_VSYNC){
				continue;
			}
			if(inf[i].type == FR400CC_VDC_RTYPE_ERR_UNDERFLOW){
				fprintf(stderr, "err underflow\n");
				continue;
			}

			buf_idx = data_set_frm % cfg.buf_num;
			data_set(local_area, data_set_frm % frmcnt,
				 mmap_area, buf_idx);
			ioctl(fd, VDCIOCSDAT, buf_idx);
			data_set_frm++;

			gettimeofday(&tm_now, NULL);
			tm_dif(&tm_now, &tm_sta, &tm_tmp);
			if(tm_tmp.tv_sec >= sec){
				run = 0;
			}
		}
	}

	if(ioctl(fd, VDCIOCSTOP, 0) != 0){
		fprintf(stderr, "ioctl stop err\n");
		close(fd);
		return -1;
	}

	if(!cfg.stop_immidiate){
		run = 1;
		while(run){
			if(nonblock){
				FD_ZERO(&setr);
				FD_SET(fd, &setr);
				x = select(fd+1, &setr, NULL, NULL, NULL);
				if(x <= 0 || !FD_ISSET(fd, &setr)) continue;
			}
			if((x = read(fd, (void*)inf, sizeof(inf))) <= 0) break;
			n = x / sizeof(inf[0]);
			for(i=0; i<n; i++){
#if TXT_DEBUG
				sprintf(txtbuf_get(), "rest %d dset %d\n", inf[i].count, data_set_frm);
				txtbuf_add();
#else
				printf("rest %d dset %d\n", inf[i].count, data_set_frm);
#endif
				if(inf[i].count >= data_set_frm - 1){
					run = 0;
					break;
				}
			}
		}
	}

	close(fd);

#if TXT_DEBUG
	txtbuf_dump();
#endif

	return 0;
}

/* EOF */