vcctest.c

linux 嵌入式原代码

/*
 *  Sample program for FR400 Companion Chip VCC axLinux driver.
 *  
 *  Copyright (C) 2002  AXE,Inc.
 *
 */
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <linux/hdreg.h>
#include <linux/fs.h>
#include <sys/ioctl.h>

#include <sys/time.h>
#include <unistd.h>
#include <errno.h>

#include <linux/fr400cc_vcc.h>

#define REGIO_TEST	1	/* 2003/Jan/27 */
#define CFGCHK		1	/* 2002/Dec/20 */
#define C2		1	/* 2002/Oct/22 */

#if REGIO_TEST
#include <linux/fr400cc_io.h>
#endif

#define NORMAL		0
#define QUARTER		1	/* not yet test */
#define QUARTER_ALT	2	/* not yet test */

#define USE_SELECT
#if C2
	/* cut */
#else
#define SHOW_DEBUG_INFO
#endif

#if VCC_TIMEREC
#undef SHOW_DEBUG_INFO
#endif

#if VCC_TIMEREC
#if 1
#define CAPTURE_SIZE	NORMAL
#else
#define CAPTURE_SIZE	QUARTER
#endif
#else
/*#define CAPTURE_SIZE	NORMAL*/
#define CAPTURE_SIZE	QUARTER
#endif

#if (CAPTURE_SIZE==NORMAL)
#define FILESIZE (720 * 480 * 2)
#else
#define FILESIZE (320 * 240 * 2)
#endif

/*
 *   [memory map]
 *   0x00000000 - 0x01000000	kernel
 *   0x01000000 - 0x01c00000    vcctest.c
 *   0x01c00000 - 0x03c00000	(don't use, broken??)
 *   0x03c00000 - 0x04000000    romdisk
 */
#define TMPBUF_BASE   0x01000000
#define TMPBUF_SIZE   0x02c00000

#define TMPBUF_LEN   (TMPBUF_SIZE/FILESIZE)
unsigned char *tmpbuf=(unsigned char *)TMPBUF_BASE;
int tmpbuf_n=0;

unsigned char *frame_base;
struct fr400cc_vcc_mbuf vcc_mbuf;

#ifdef SHOW_DEBUG_INFO
struct fr400cc_vcc_info vcc_info[TMPBUF_LEN];
struct fr400cc_vcc_frame_info vcc_frame_info[TMPBUF_LEN];
struct fr400cc_vcc_read vcc_read[TMPBUF_LEN];
#else
struct fr400cc_vcc_read vcc_read_dummy;
#endif

#if CFGCHK

static int verbose = 0;

static void
config_show_vcc(struct fr400cc_vcc_config *cfg)
{
	printf("encoding:%d , interlace:%d , skipbf:%d\n",
	       cfg->encoding, cfg->interlace, cfg->skipbf);
	printf("fw:%d , fh:%d\n", cfg->fw, cfg->fh);

	printf("rhtcc:0x%08x , rhcc:0x%08x , rhbc:0x%08x, rvcc:0x%08x\n",
	       cfg->rhtcc, cfg->rhcc, cfg->rhbc, cfg->rvcc);
	printf("rvbc:0x%08x , rhr:0x%08x , rvr:0x%08x\n",
	       cfg->rvbc, cfg->rhr, cfg->rvr);
	printf("rssp:0x%08x , rsep:0x%08x\n", cfg->rssp, cfg->rsep);
	printf("rcc_fdts:0x%08x , rcc_ifi:0x%08x\n", cfg->rcc_fdts, cfg->rcc_ifi);
	printf("rhyf0:0x%08x , rhyf1:0x%08x , rhyf2:0x%08x\n",
	       cfg->rhyf0, cfg->rhyf1, cfg->rhyf2);
	printf("rhcf0:0x%08x , rhcf1:0x%08x , rhcf2:0x%08x\n",
	       cfg->rhcf0, cfg->rhcf1, cfg->rhcf2);
	printf("rvf0:0x%08x , rvf1:0x%08x\n", cfg->rvf0, cfg->rvf1);
}

static int
ioctl_start_vcc(int fd, int prm)
{
	if(verbose){
		struct fr400cc_vcc_config cfg;
		if(ioctl(fd, VCCIOCGCFG, &cfg) != 0){
			fprintf(stderr, "ioctl vcc get cfg err\n");
			return -1;
		}
		printf("VCC config\n");
		config_show_vcc(&cfg);
		printf("\n");
	}
	return ioctl(fd, VCCIOCSTART, prm);
}

#endif /* CFGCHK */

int mode;

static void memcpy_4b_align(unsigned *dst, unsigned *src, int len)
{
    int i;

    for( i=0; i<len; i+=sizeof(unsigned) )
	*dst++=*src++;
}

static int frame_write_ram(char *addr, int nomsg)
{
    int len;

    len = FILESIZE;

    if( tmpbuf_n < TMPBUF_LEN ){
	if( !nomsg ){
	    printf("Use RAM(%d) %08x-%08x (from:%08x)\n",
		   tmpbuf_n, tmpbuf+tmpbuf_n*FILESIZE,
		   tmpbuf+(tmpbuf_n+1)*FILESIZE, addr);
	}
#if 0
	memcpy(tmpbuf+tmpbuf_n*FILESIZE, addr, FILESIZE);
#else
	/* memcpy in libc is very slow.  (2002/JUN/11)*/
	memcpy_4b_align((unsigned *)(tmpbuf+tmpbuf_n*FILESIZE),
			(unsigned *)addr, FILESIZE);
#endif
	tmpbuf_n++;
	return 0;
    }else{
	if( !nomsg )
	    printf("no buffer on RAM\n");
	return -1;
    }
}

static void write_file_frame(char *name, char *addr)
{
    int len, fd;

    len = FILESIZE;

    fd = open(name, O_WRONLY|O_CREAT|O_TRUNC, 0644);
    if( fd == -1 ){
	printf("error: open %s\n", name);
	return;
    }

    printf("write: name:%s,size:%d ...\n", name, len);
    if( write(fd, addr, FILESIZE) != len ){
	printf("error: write %s\n", len);
	close(fd);
	return;
    }
    close(fd);
}

static void memcpy_time_check(unsigned char *frame,
			      struct fr400cc_vcc_mbuf *mbuf)
{
    struct timeval st, ed;
    int msec, usec, i, try;

    if( gettimeofday(&st, NULL) == -1 ){
	printf("error: gettimeofday()\n");
	return;
    }
    try = 4;

    for( i=0; i<try; i++){
	frame_write_ram(frame + mbuf->offsets[i%mbuf->frames], 0);
    }
    if( gettimeofday(&ed, NULL) == -1 ){
	printf("error: gettimeofday()\n");
	return;
    }
    msec = ((ed.tv_sec - st.tv_sec) * 1000) +
	ed.tv_usec / 1000 - st.tv_usec / 1000;
    usec = (int)(ed.tv_usec % 1000 - st.tv_usec % 1000);
    if( usec < 0 ){
	msec -= 1;
	usec += 1000;
    }
    printf("memory copy: %dbytes * %d frames, %d.%03dmsec",
	   FILESIZE, try, msec, usec);
    printf("  (1frame, %d.%03dmsec)\n",
	   (msec * 1000 + usec) / try / 1000,
	   (msec * 1000 + usec) / try % 1000);
    tmpbuf_n = 0;
}

static unsigned tvusec(struct timeval *from, struct timeval *to)
{
    unsigned usec;

    usec = (to->tv_sec - from->tv_sec) * 1000000;
    usec += to->tv_usec - from->tv_usec;
    return usec;
}

static int setup_vcc(char *devname)
{
    int dev, i, retval;
    struct fr400cc_vcc_config vcc_conf;

    dev = open(devname, O_RDONLY);
    if( dev == -1 ){
	printf("error: open %s\n", devname);
	return -1;
    }

#if VCC_TIMEREC
    if(ioctl(dev, __VCCIOCTIMEREC, 'S')){
	printf("time rec start NG '%s'\n", devname);
    }
#endif
    if (ioctl (dev, VCCIOCGMBUF, &vcc_mbuf)) {
	printf("unable to get vcc mbuf '%s'\n", devname);
	return -1;
    }

    if ((frame_base=mmap(0,vcc_mbuf.size,PROT_READ|PROT_WRITE, MAP_SHARED,dev,0)) == (void *)-1) {
	printf("mmap error\n");
	return -1;
    }

    if ( (retval = ioctl (dev, VCCIOCGCFG, &vcc_conf)) ) {
	printf("unable to get vcc conf '%s' (retval %d, errno %d)\n", devname, retval, errno);
	return -1;
    }

    printf("vcc_conf(default): enc=%d, interlace=%d skipbf=%d frame=(%d,%d)\n"
	   "          rhtcc=%d, rhcc=%d, rhbc=%d, rvcc=%d, rvbc=%d\n"
	   "          rcc_fdts=%d, rcc_ifi=%d\n",
	   vcc_conf.encoding, vcc_conf.interlace, vcc_conf.skipbf,
	   vcc_conf.fw, vcc_conf.fh,
	   vcc_conf.rhtcc, vcc_conf.rhcc, vcc_conf.rhbc,
	   vcc_conf.rvcc, vcc_conf.rvbc,
	   vcc_conf.rcc_fdts, vcc_conf.rcc_ifi);

    vcc_conf.rcc_fdts = 0;	/* 0 */
    vcc_conf.rcc_ifi = 0;	/* 0 */

#if (CAPTURE_SIZE == NORMAL)
    vcc_conf.fw = 720;	/* 720 */
    vcc_conf.fh = 480;	/* 480 */
    vcc_conf.skipbf = 0;	/* 0:capture top and bottom field
				   1:capture top field onry */
    vcc_conf.rhcc = 720;	/* 720 */
    vcc_conf.rvcc = 240;	/* 240 */

    vcc_conf.rhr = 0x100;	/* 0x100 */
    vcc_conf.rvr = 0x100;	/* 0x100 */
#endif

#if (CAPTURE_SIZE == QUARTER)
    vcc_conf.fw = 320;	/* 720 */
    vcc_conf.fh = 240;	/* 480 */
    vcc_conf.skipbf = 1;	/* 0:capture top and bottom field
				   1:capture top field onry */
    vcc_conf.rhcc = 720;	/* 720 */
    vcc_conf.rvcc = 240;	/* 240 */

    vcc_conf.rhr = 0x240;	/* 0x100 */
    vcc_conf.rvr = 0x100;	/* 0x100 */
#endif

#if (CAPTURE_SIZE == QUARTER_ALT)
    vcc_conf.fw = 320;	/* 720 */
    vcc_conf.fh = 240;	/* 480 */
    vcc_conf.skipbf = 0;	/* 0:capture top and bottom field
				   1:capture top field onry */
    vcc_conf.rhcc = 720;	/* 720 */
    vcc_conf.rvcc = 240;	/* 240 */

    vcc_conf.rhr = 0x240;	/* 0x100 */
    vcc_conf.rvr = 0x200;	/* 0x100 */
#endif

    printf("vcc_conf: enc=%d, interlace=%d skipbf=%d frame=(%d,%d)\n"
	   "          rhtcc=%d, rhcc=%d, rhbc=%d, rvcc=%d, rvbc=%d\n"
	   "          rcc_fdts=%d, rcc_ifi=%d\n",
	   vcc_conf.encoding, vcc_conf.interlace, vcc_conf.skipbf,
	   vcc_conf.fw, vcc_conf.fh,
	   vcc_conf.rhtcc, vcc_conf.rhcc, vcc_conf.rhbc,
	   vcc_conf.rvcc, vcc_conf.rvbc,
	   vcc_conf.rcc_fdts, vcc_conf.rcc_ifi);

    if (ioctl (dev, VCCIOCSCFG, &vcc_conf)) {
	printf("unable to set vcc conf '%s'\n", devname);
	return -1;
    }

    printf("frame base=0x%08x\n", frame_base);
    printf("vcc_mbuf: size=%08x, frames=%d", vcc_mbuf.size, vcc_mbuf.frames);
    for (i=0; i<vcc_mbuf.frames; i++)
	printf(" [%08x]", vcc_mbuf.offsets[i]);
    printf("\n");
    return dev;
}

static int
opt_chk(int ac, char **av, char *key)
{
	int i;
	for(i=1; i<ac; i++){
		if(strcmp(av[i], key) == 0) return i;
	}
	return 0;
}

#if REGIO_TEST

static int
opt_chk_str(int ac, char **av, char *key, char **re)
{
	int i;
	i = opt_chk(ac, av, key);
	if(i!=0 && i+1<ac){
		*re = av[i+1];
		return 0;
	}
	return -1;
}

static int
s2val(char *s, unsigned *re)
{
	unsigned v;
	int cnt, neg, d;

	if(s == NULL) return -2;
	if(strncmp(s, "0x", 2) == 0){
		if((cnt = sscanf(s, "0x%x", &v)) != 1) return -1;
		*re = v;
		return 0;
	}
	neg = 0;
	if(s[0] == '-'){
		neg = 1;		
		s++;
	}
	if((cnt = sscanf(s, "%d", &d)) != 1) return -1;
	if(neg) d = -d;
	*re = (unsigned)d;
	return 0;
}

static int
opt_chk_val(int ac, char **av, char *key, unsigned *re)
{
	char *str;
	if(opt_chk_str(ac, av, key, &str) != 0) return -1;
	if(s2val(str, re) != 0) return -2;
	return 0;
}

#endif

#if VCC_TIMEREC

static int
save(char *name, unsigned char *p, int n)
{
	FILE *fp;
	int x;

	fp = fopen(name, "w");
	if(fp == NULL) return -1;

	while(n>0){
		x = fwrite(p, 1, n, fp);
		if(x < 0){
			fprintf(stderr, "fwrite x=%d\n", x);
			fclose(fp);
			return -1;
		}
		p += x;
		n -= x;
	}
	fclose(fp);
	return 0;
}

static char *tmo_fn = "tmrec.dat";

static void
time_rec_save(int fd)
{
	int tmcnt, sz, sz2, i, x;

#if VCC_TIMEREC_2
	Tmrec rec;
	FILE *fp;
#else
	Tmrec *tmrecs;
#endif
	char *cp;

	if(ioctl(fd, __VCCIOCTIMEREC, 'E')){
		printf("time rec end NG.\n");