prograssiveexample.c

德州仪器新推出的达芬奇技术dm355的源代码

	return 0;
}

/* ************************************************************************/
static void StreamOnOff(int VideoOn)
{
	int i;
	enum v4l2_buf_type type;

	if (VideoOn == 1) {
		for (i = 0; i < nBuffers; i++) {
			struct v4l2_buffer buf;

			CLEAR(buf);
			buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
			buf.memory = V4L2_MEMORY_MMAP;
			buf.index = i;
			printf("Queing buffer:%d\n", i);

			if (-1 == ioctl(fdCapture, VIDIOC_QBUF, &buf)) {
				printf
				    ("1StartStreaming:ioctl:VIDIOC_QBUF: \n");
			}
		}
		printf("After QBUF \n");
		type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		if (-1 == ioctl(fdCapture, VIDIOC_STREAMON, &type)) {
			printf("StopStreaming:ioctl:VIDIOC_STREAMOFF\n");
		}
	} else if (VideoOn == 0) {
		type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		if (-1 == ioctl(fdCapture, VIDIOC_STREAMOFF, &type)) {
			printf("StopStreaming:ioctl:VIDIOC_STREAMOFF\n");
		}
	}
}

/* ************************************************************************/
int mmap_vid1()
{
	int i;
  	vid1_size =
    	vid1_fixInfo.line_length * vid1_varInfo.yres;
	/* Map the video0 buffers to user space */
	vid1_display[0] = (char *) mmap(NULL,
					vid1_size * VIDEO_NUM_BUFS,
					PROT_READ | PROT_WRITE,
					MAP_SHARED, fd_vid1, 0);

	if (vid1_display[0] == MAP_FAILED) {
		printf("\nFailed mmap on %s", FBVID1_DEVICE);
		return FAILURE;
	}

	for (i = 0; i < VIDEO_NUM_BUFS - 1; i++) {
		vid1_display[i + 1] = vid1_display[i] + vid1_size;
		printf("Display buffer %d mapped to address %#lx\n", i + 1,
		       (unsigned long) vid1_display[i + 1]);
	}
}


/* ************************************************************************/
int mmap_osd0()
{
	int i;
  	osd0_size =
    		osd0_fixInfo.line_length * osd0_varInfo.yres;
	/* Map the osd0 buffers to user space */
	osd0_display[0] = (char *) mmap(NULL,
					osd0_size * OSD_NUM_BUFS,
					PROT_READ | PROT_WRITE,
					MAP_SHARED, fd_osd0, 0);

	if (osd0_display[0] == MAP_FAILED) {
		printf("\nFailed mmap on %s", OSD0_DEVICE);
		return FAILURE;
	}

	for (i = 0; i < OSD_NUM_BUFS - 1; i++) {
		osd0_display[i + 1] = osd0_display[i] + osd0_size;
		printf("Display buffer %d mapped to address %#lx\n", i + 1,
		       (unsigned long) osd0_display[i + 1]);
	}
}

/* ************************************************************************/
int mmap_osd1()
{
	int i;
  	osd1_size =
    		osd1_fixInfo.line_length * osd1_varInfo.yres;
	/* Map the osd1 buffers to user space */
	osd1_display[0] = (char *) mmap(NULL,
					osd1_size * OSD_NUM_BUFS,
					PROT_READ | PROT_WRITE,
					MAP_SHARED, fd_osd1, 0);

	if (osd1_display[0] == MAP_FAILED) {
		printf("\nFailed mmap on %s", OSD0_DEVICE);
		return FAILURE;
	}

	for (i = 0; i < OSD_NUM_BUFS - 1; i++) {
		osd1_display[i + 1] = osd1_display[i] + osd1_size;
		printf("Display buffer %d mapped to address %#lx\n", i + 1,
		       (unsigned long) osd1_display[i + 1]);
	}
}

/* ************************************************************************/
int unmap_and_disable(char id)
{

	switch (id) {
	case VID1:

		if (munmap(vid1_display[0], vid1_size * VIDEO_NUM_BUFS) ==
		    -1) {
			printf("\nFailed munmap on %s", FBVID1_DEVICE);
			return FAILURE;
		}
		break;
	case OSD0:
		if (munmap(osd0_display[0], osd0_size * OSD_NUM_BUFS) ==
		    -1) {
			printf("\nFailed munmap on %s", OSD0_DEVICE);
			return FAILURE;
		}
		break;
	case OSD1:
		if (munmap(osd1_display[0], osd1_size * OSD_NUM_BUFS) ==
		    -1) {
			printf("\nFailed munmap on %s", OSD1_DEVICE);
			return FAILURE;
		}
		break;
	default:
		break;
	}
}

/******************************************************************************
 * flipDisplayBuffers
 ******************************************************************************/
static int flipBuffers(int fd, int displayIdx)
{
	struct fb_var_screeninfo vInfo;

	if (ioctl(fd, FBIOGET_VSCREENINFO, &vInfo) == -1) {
		printf("Failed FBIOGET_VSCREENINFO (%s)\n");
		return FAILURE;
	}

	vInfo.yoffset = vInfo.yres * displayIdx;

	/* Swap the working buffer for the displayed buffer */
	if (ioctl(fd, FBIOPAN_DISPLAY, &vInfo) == -1) {
		printf("Failed FBIOPAN_DISPLAY (%s)\n");
		return FAILURE;
	}

	return SUCCESS;
}

/******************************************************************************/

int init_osd1_device(int fd_osd1, struct fb_var_screeninfo *pvarInfo)
{
	vpbe_window_position_t pos;

	if (ioctl(fd_osd1, FBIOGET_FSCREENINFO, &osd1_fixInfo) < 0) {
		printf("\nFailed FBIOGET_FSCREENINFO osd1");
		return FAILURE;
	}

	/* Get Existing var_screeninfo for vid0 window */
	if (ioctl(fd_osd1, FBIOGET_VSCREENINFO, pvarInfo) < 0) {
		printf("\nFailed FBIOGET_VSCREENINFO");
		return FAILURE;
	}
	prev_osd1_var = *pvarInfo;
	printf("xres = %d yres = %d bpp = %d\n", prev_osd1_var.xres,
	       prev_osd1_var.yres, prev_osd1_var.bits_per_pixel);
	/* Modify the resolution and bpp as required */
	pvarInfo->xres = test_data.osd1_width;
	pvarInfo->yres = test_data.osd1_height;
	pvarInfo->bits_per_pixel = test_data.osd1_bpp;

	/* Set vid0 window format */
	if (ioctl(fd_osd1, FBIOPUT_VSCREENINFO, pvarInfo) < 0) {
		printf("\nFailed FBIOPUT_VSCREENINFO");
		return FAILURE;
	}

	/* Set attribute  window */
	if (ioctl(fd_osd1, FBIO_ENABLE_DISABLE_ATTRIBUTE_WIN, VPBE_DISABLE)
	    < 0) {
		printf("\nFailed  FBIO_ENABLE_DISABLE_ATTRIBUTE_WIN");
		return FAILURE;
	}

	/* Set window position */
	pos.xpos = test_data.osd1_xpos;
	pos.ypos = test_data.osd1_ypos;

	if (ioctl(fd_osd1, FBIO_SETPOS, &pos) < 0) {
		printf("\nFailed  FBIO_SETPOS");
		return FAILURE;
	}

	return SUCCESS;
}

/******************************************************************************/

int init_osd0_device(int fd_osd0, struct fb_var_screeninfo *pvarInfo)
{
	vpbe_window_position_t pos;

	if (ioctl(fd_osd0, FBIOGET_FSCREENINFO, &osd0_fixInfo) < 0) {
		printf("\nFailed FBIOGET_FSCREENINFO osd0");
		return FAILURE;
	}

	/* Get Existing var_screeninfo for vid0 window */
	if (ioctl(fd_osd0, FBIOGET_VSCREENINFO, pvarInfo) < 0) {
		printf("\nFailed FBIOGET_VSCREENINFO");
		return FAILURE;
	}

	prev_osd0_var = *pvarInfo;
	/* Modify the resolution and bpp as required */
	pvarInfo->xres = test_data.osd0_width;
	pvarInfo->yres = test_data.osd0_height;
	pvarInfo->bits_per_pixel = test_data.osd0_bpp;
	pvarInfo->vmode = test_data.osd0_vmode;

	/* Set vid0 window format */
	if (ioctl(fd_osd0, FBIOPUT_VSCREENINFO, pvarInfo) < 0) {
		printf("\nFailed FBIOPUT_VSCREENINFO");
		return FAILURE;
	}


	/* Set window position */
	pos.xpos = test_data.osd0_xpos;
	pos.ypos = test_data.osd0_ypos;

	if (ioctl(fd_osd0, FBIO_SETPOS, &pos) < 0) {
		printf("\nFailed  FBIO_SETPOS");
		return FAILURE;
	}

	return SUCCESS;
}

/******************************************************************************/

int init_vid1_device(int fd, struct fb_var_screeninfo *pvarInfo)
{
	vpbe_window_position_t pos;

	if (ioctl(fd, FBIOGET_FSCREENINFO, &vid1_fixInfo) < 0) {
		printf("\nFailed FBIOGET_FSCREENINFO vid1");
		return FAILURE;
	}

	/* Get Existing var_screeninfo for vid0 window */
	if (ioctl(fd, FBIOGET_VSCREENINFO, pvarInfo) < 0) {
		printf("\nFailed FBIOGET_VSCREENINFO");
		return FAILURE;
	}

	prev_vid1_var = *pvarInfo;
	/* Modify the resolution and bpp as required */
	pvarInfo->xres = test_data.vid1_width;
	pvarInfo->yres = test_data.vid1_height;
	pvarInfo->bits_per_pixel = test_data.vid1_bpp;

	/* Set vid0 window format */
	if (ioctl(fd, FBIOPUT_VSCREENINFO, pvarInfo) < 0) {
		printf("\nFailed FBIOPUT_VSCREENINFO");
		return FAILURE;
	}
	
	/* Set window position */
	pos.xpos = test_data.vid1_xpos;
	pos.ypos = test_data.vid1_ypos;

	if (ioctl(fd_vid1, FBIO_SETPOS, &pos) < 0) {
		printf("\nFailed  FBIO_SETPOS");
		return FAILURE;
	}

	return SUCCESS;
}

/* ************************************************************************
 * Example to show VID1 in YUV format, OSD0 in 8 bit bitmap format and  
 * OSD1 also in 8 bit bitmap format.
* ************************************************************************/
int vpbe_UE_2()
{
	int ret = 0;
	int i;
	vpbe_mode_info_t mode_info;
	rgb565_enable = 2;	/* To disaplay 8 bit image on osd */
	rgb565_enable_osd1 = 2;	/* To disaplay 8 bit image on osd */

	DBGENTER;


	test_data.vid1_width = 720;
	test_data.vid1_height = 480;
	test_data.vid1_bpp = 16;
	test_data.vid1_vmode = FB_VMODE_NONINTERLACED;

	test_data.osd0_bpp = 8;
	test_data.osd0_width = 100;
	test_data.osd0_height = 100;
	test_data.osd0_vmode = FB_VMODE_NONINTERLACED;

	test_data.osd1_bpp = 8;
	test_data.osd1_width = 100;
	test_data.osd1_height = 100;
	test_data.osd1_vmode = FB_VMODE_NONINTERLACED;

	test_data.osd0_xpos = 50;
	test_data.osd0_ypos = 50;
	test_data.osd1_xpos = 450;
	test_data.osd1_ypos = 350;
	test_data.vid1_xpos = 0;
	test_data.vid1_ypos = 0;
	test_data.display_interface = COMPONENT;
	test_data.display_mode = P525;

	Initialize_Capture();

	if (ioctl(fd_vid1, FBIO_ENABLE_DISPLAY, VPBE_DISABLE) < 0) {
		printf("\nFailed  FBIO_ENABLE_DISPLAY");
		return FAILURE;
	}
	mode_info.interface = test_data.display_interface;
	mode_info.mode_idx = test_data.display_mode;

	if (ioctl(fd_vid1, FBIO_QUERY_TIMING, &mode_info) < 0) {
		printf("\nFailed  FBIO_QUERY_TIMING");
		return FAILURE;
	}

	if (!strcmp(mode_info.vid_mode.name, "\0")) {
		printf("mode not supported %d %d \n", test_data.display_interface, test_data.display_mode);
		return FAILURE;
	}
	/* Set MODE */
	if (ioctl(fd_vid1, FBIO_SET_TIMING, &mode_info.vid_mode) < 0) {
		printf("\nFailed  FBIO_SET_TIMING");
		return FAILURE;
	}
	if ((init_vid1_device(fd_vid1, &vid1_varInfo)) < 0) {
		printf("\nFailed to init vid1 window ");
		return FAILURE;
	}

	if ((init_osd0_device(fd_osd0, &osd0_varInfo)) < 0) {
		printf("\nFailed to init osd0 window ");
		return FAILURE;
	}

	if ((init_osd1_device(fd_osd1, &osd1_varInfo)) < 0) {
		printf("\nFailed to init osd1 window ");
		return FAILURE;
	}

	if (ioctl(fd_vid1, FBIO_ENABLE_DISPLAY, VPBE_ENABLE) < 0) {
		printf("\nFailed  FBIO_ENABLE_DISPLAY");
		return FAILURE;
	}
	if (mmap_vid1() == FAILURE)
		return FAILURE;

	if (mmap_osd0() == FAILURE)
		return FAILURE;

	if (mmap_osd1() == FAILURE)
		return FAILURE;

	StartLoop();

	/* unmap video buffers */
	if (unmap_and_disable(VID1) < 0)
		return FAILURE;
	if (unmap_and_disable(OSD0) < 0)
		return FAILURE;
	if (unmap_and_disable(OSD1) < 0)
		return FAILURE;

	DBGEXIT;
	return ret;
}

/******************************************************************************/

void usage()
{
	printf("\n usageeg -n number in test case\n");

}

close_all_windows()
{
	if (fd_vid1)
		close(fd_vid1);
	if (fd_osd0)
		close(fd_osd0);
	if (fd_osd1)
		close(fd_osd1);
}

int open_all_windows()
{
	int result = 0;

	if ((fd_vid1 = open(FBVID1_DEVICE, O_RDWR)) < 0)
		goto open_all_exit;
	if ((fd_osd0 = open(OSD0_DEVICE, O_RDWR)) < 0)
		goto open_all_exit;
	if ((fd_osd1 = open(OSD1_DEVICE, O_RDWR)) < 0)
		goto open_all_exit;

	return 0;
      open_all_exit:
	close_all_windows();
	return -1;
}

/******************************************************************************/
/* main function */
int main(int argc, char *argv[])
{
	char shortoptions[] = "n:";
	char type;
	int testcase, no, index, c, ret = 0;
	DBGENTER;

	if (open_all_windows() != 0) {
		printf("Test fail\n");
		return 0;
	}
	ret = vpbe_UE_2();
	restore_config();
	close_all_windows();
	DBGEXIT;
	return 0;
}