pal_loopback.c

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

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

#if 1
int
mmap_vid0 ()
{
  int i;
  vid0_size =
    vid0_fixInfo.line_length * vid0_varInfo.yres;
  /* Map the video0 buffers to user space */
  vid0_display[0] = (char *) mmap (NULL,
				   vid0_size * VIDEO_NUM_BUFS,
				   PROT_READ | PROT_WRITE,
				   MAP_SHARED, fd_vid0, 0);

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

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

#endif

/* ************************************************************************/
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
unmap_and_disable (char id)
{

  switch (id)
    {
    case VID0:
      if (munmap (vid0_display[0], vid0_size * VIDEO_NUM_BUFS) == -1)
	{
	  printf ("\nFailed munmap on %s", FBVID1_DEVICE);
	  return FAILURE;
	}
      break;
    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_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 */
	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 window parameters */
	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 */
	if (ioctl(fd, FBIOGET_VSCREENINFO, pvarInfo) < 0) {
		printf("\nFailed FBIOGET_VSCREENINFO");
		return FAILURE;
	}

	prev_vid0_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 window parameters */
	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;
}

#if 0
int init_vid0_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 */
	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.vid0_width;
	pvarInfo->yres = test_data.vid0_height;
	pvarInfo->bits_per_pixel = test_data.vid0_bpp;

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

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

	return SUCCESS;
}

#endif


/******************************************************************************
 * Example to show vid1 in YUV format,OSD0 in RGB565 format and OSD1 is attribute
 * format.
 ******************************************************************************/
int
vpbe_UE_1()
{
  int ret = 0;
  int i, retval;
  struct fb_fillrect frect;

  rgb565_enable = 1;
  rgb565_enable_osd1 = 0;

  Initialize_Capture ();

  test_data.vid1_width = PALWIDTH;
  test_data.vid1_height = PALHEIGHT;

  test_data.vid1_bpp = 16;
  test_data.vid1_vmode = FB_VMODE_INTERLACED;
  test_data.vid1_xpos = 0;
  test_data.vid1_ypos = 0;
  test_data.vid1_hzoom = 0;	
  test_data.vid1_vzoom = 0;

  test_data.osd0_width = 150;
  test_data.osd0_height = 150;
  test_data.osd0_bpp = 16;
  test_data.osd0_hzoom = 0;
  test_data.osd0_vzoom = 0;
  test_data.osd0_xpos = 10;
  test_data.osd0_ypos = 10;

  if ((init_vid1_device (fd_vid1, &vid1_varInfo)) < 0)
    {
      printf ("\nFailed to init vid1 window ");
      return FAILURE;
    }
  else printf ("\nInitialized vid1 window");

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

  if (mmap_vid1 () == FAILURE)
    return FAILURE;

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


 /* August 7, 2006. Mahesh. 
    Blending to set osd0 to invisible and vid1 to visible.
    Otherwise the loopback test run with the osd plane obscuring the vid display    You can restore the settings before closing the test.
   */
 

 frect.dx=0;
 frect.dy=0;
 frect.width=test_data.vid1_width;
 frect.height=test_data.vid1_height;
 frect.color= 0;

 fd_osd1 = open("/dev/fb/2",O_RDWR);

 if (fd_osd1 > 0){ printf("\n Setting Blend to 0\n");
  if ((retval=(ioctl(fd_osd1, FBIO_SETATTRIBUTE, &frect)))<0 )
 {
	printf("retval =%d\n",retval);
        return retval;
 }
 }


  StartLoop ();

  /* Now make OSD visible and VID invisible.*/
  
 frect.color = 7;
    fd_osd1 = open("/dev/fb/2",O_RDWR);

     if (fd_osd1 > 0){ printf("Setting Blend to 7\n");
          if ((retval=(ioctl(fd_osd1, FBIO_SETATTRIBUTE, &frect)))<0 )
         {
        	printf("retval =%d\n",retval);
                return retval;
         }
         }

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

 // DBGEXIT;
  return ret;
}

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

close_all_windows ()
{
  if (fd_vid0){
    if (close (fd_vid0) < 0)
       printf ("Unable to close vid0\n");
       printf("Succesfully closed vid0\n");
      }
  if (fd_vid1){ 
   if (close (fd_vid1) < 0)
      printf ("Unable to close vid1\n");
       printf("Succesfully closed vid1\n");
      }
  if (fd_osd0){
    if (close (fd_osd0) < 0)
    printf ("Unable to close osd0\n");
       printf("Succesfully closed osd0\n");
      }
  if (fd_osd1){
    if (close (fd_osd1) < 0)
    printf ("Unable to close osd1\n");
       printf("Succesfully closed osd1\n");
    }
}

int
open_all_windows ()
{
  int result = 0;

  if ((fd_vid0 = open (FBVID0_DEVICE, O_RDWR)) < 0)
    goto open_all_exit;
  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;
}

void usage()
{

printf("Usage: ntscloop -[OPTION] [VALUE]\n");
printf("\n\t\t -s : Use Svideoinput instead of composite");
printf("\n\t\t -c : Run the loopback test 'c' times (-1 for stress test)\n");
printf("\t\t      Default c=100 times \n");

}


/******************************************************************************/
/* main function */
int
main (int argc, char *argv[])
{
    char shortoptions[] = "n:";
    char type;
    int testcase, no, index, c, ret = 0;
    int lpcnt;
    int i;
  
/* Process command line parameters */
     if (argc == 0) { usage();return 0;}
          
  
  for (i = 1; i < argc; i++)
  {

   	if (argv[i][0] == '-'){

          switch (argv[i][1]) {

           case 's': svideoinput = TRUE;
                     break;
 
           case 'c': lpcnt = atoi(argv[++i]); 
                     if (lpcnt == -1) {
                                      stress_test = 1;
                                      }
                      else {
                            startLoopCnt = lpcnt;
                           }
                     break;
          
           case 'h':
                   usage();
                   return 0;
                   break;

           default: usage(); 
                    return 0;
                    break;
         } // End of switch
        } // End of if
       } // End of for

    if (open_all_windows () != 0)
    {
        printf ("Test fail\n");
        return 0;
    }

    
    
    ret = vpbe_UE_1();

    if ( ret < 0) {
                   printf("\nSomething failed here\n");
                   return 0;
                  }

    restore_config();

    close_all_windows ();
    return 0;
}