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 ("StartStreaming:ioctl:VIDIOC_QBUF:\n");
	}
    }
  /* all done , get set go */
  type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  if (-1 == ioctl (fdCapture, VIDIOC_STREAMON, &type))
    {
      printf ("StartStreaming:ioctl:VIDIOC_STREAMON:\n");
    }

  return 0;
}

void *getDisplayBuffer(int fd)
{
	int ret, i;
	struct v4l2_buffer buf;

	memset(&buf, 0, sizeof(buf));
	buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
	ret = ioctl(fd, VIDIOC_DQBUF, &buf);
	if (ret < 0) {
		perror("VIDIOC_DQBUF\n");
		for (i = 0; i < 3; i++)
			munmap(disp_buff_info[i].start,
				disp_buff_info[i].length);
		close(fd);
		return NULL;
	}
#if 0
	printf("getDisplayBuffer, index = %d, sec = %d, uSec = %d",buf.index, buf.timestamp.tv_sec,buf.timestamp.tv_usec);
#endif
	return disp_buff_info[buf.index].start;
}

int putDisplayBuffer(int fdx,void *addr)
{
	struct v4l2_buffer buf;
	int i, index = 0, found = 0;
	int ret;

	if (addr == NULL)
		return -1;
	memset(&buf, 0, sizeof(buf));

	for (i = 0; i < 3; i++) {
		if (addr == disp_buff_info[i].start) {
			index = disp_buff_info[i].index;
			break;
		}
	}

	buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
	buf.memory = V4L2_MEMORY_MMAP;
	buf.index = index;
	ret = ioctl(fdx, VIDIOC_QBUF, &buf);

	if (ret)
		return ret;

	return 0;
}

/* ************************************************************************/
static int
DisplayFrame (int fdz, void *ptrBuffer)
{
  int y,i;
  int xres, yres;
  int fd;
  void *buf_new;
  int ret;
  unsigned int *f;
  unsigned int lp;
  unsigned int a1,a2;
  struct timeval tv;
  struct timezone zone;
  char *src, *dest;
  unsigned int line_length = 720*2;


  buf_new = getDisplayBuffer(fdz);

  if (buf_new == NULL)
  {
	printf("Error in getting display buffer\n");
	exit(0);
  }

      

#if 0
	  bzero((void *)&zone, sizeof (struct timezone));
	  gettimeofday(&tv,&zone);
	  printf("before memcpy sec=%d,usec=%d\n",tv.tv_sec,tv.tv_usec);
#endif
//      memcpy(buf_new,ptrBuffer,720*480*2);

	  src = ptrBuffer;
	  dest = buf_new;
	  for (i=0; i < 576; i++)
	  {
		  memcpy (dest,src,(720*2));
		  dest += line_length;
		  src += line_length;
      }
		 
#if 0
	  gettimeofday(&tv,&zone);
	  printf("after memcpy sec=%d,usec=%d\n",tv.tv_sec,tv.tv_usec);
#endif
      
#if 0

//changes to flip the buffer
	if(format==0)
        { 
	f=(unsigned int *)&buf_new[0];

        for(lp=0;lp<720*240;lp=lp+1)
		{
		
                 a1=*(f+lp);
                 a2=a1;
                 a1=a1&0x00ff00ff;
    
                 a2=a2&0xff00ff00;

                 a1=a1<<8;


                 a2=a2>>8;
                // a2=a2&0xffffff;


                 a1=a1|a2;
		 *(f+lp)=a1;
		}
	}

#endif

	ret=putDisplayBuffer(fdz,buf_new); 

  	if (ret < 0)
  	{
		printf("Error in put display buffer\n");
		return ret;
  	}
  	return 0;
}

/* ************************************************************************/
int
FlipBitmapBuffers (int fd, int nBufIndex)
{
  struct fb_var_screeninfo vInfo;
  int dummy;
  if (ioctl (fd, FBIOGET_VSCREENINFO, &vInfo) < -1)
    {
      printf ("FlipbitmapBuffers:FBIOGET_VSCREENINFO\n");
      printf ("\n");
      return -1;
    }

  vInfo.yoffset = vInfo.yres * nBufIndex;
  /* Swap the working buffer for the displayed buffer */
  if (ioctl (fd, FBIOPAN_DISPLAY, &vInfo) < -1)
    {
      printf ("FlipbitmapBuffers:FBIOPAN_DISPLAY\n");
      printf ("\n");
      return -1;
    }

  return 0;
}

/* ************************************************************************/
int
FlipVideoBuffers (int fd, int nBufIndex)
{
  struct fb_var_screeninfo vInfo;
  if (ioctl (fd, FBIOGET_VSCREENINFO, &vInfo) < -1)
    {
      printf ("FlipVideoBuffers:FBIOGET_VSCREENINFO\n");
      printf ("\n");
      return -1;
    }

  vInfo.yoffset = vInfo.yres * nBufIndex;
  /* Swap the working buffer for the displayed buffer */
  if (ioctl (fd, FBIOPAN_DISPLAY, &vInfo) < -1)
    {
      printf ("FlipVideoBuffers:FBIOPAN_DISPLAY\n");
      printf ("\n");
      return -1;
    }

  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 init_vid_device(int fd)
{
	struct v4l2_requestbuffers req;
	struct v4l2_buffer buf;
	int a, ret, i,j;
	struct v4l2_format fmt;
	struct v4l2_standard standard;
	v4l2_std_id std_id;
	struct v4l2_output output;


	/* Set output for composite Video */
	output.index = 0;
	output.type = V4L2_OUTPUT_TYPE_ANALOG;
 	ret = ioctl(fd, VIDIOC_S_OUTPUT, &output);

	if (ret) {
		perror("VIDIOC_S_OUTPUT\n");
		close(fd);
		exit(0);
	}

	std_id = V4L2_STD_625_50; // for PAL
	ret = ioctl(fd, VIDIOC_S_STD, &std_id);
	if (ret) {
		perror("VIDIOC_S_STD\n");
		close(fd);
		exit(0);
	}

	if (-1 == ioctl (fd, VIDIOC_G_STD, &std_id)) {
	/* Note when VIDIOC_ENUMSTD always returns EINVAL this
	is no video device or it falls under the USB exception,
	and VIDIOC_G_STD returning EINVAL is no error. */
	perror ("VIDIOC_G_STD");
	exit (EXIT_FAILURE);
	}
	memset (&standard, 0, sizeof (standard));
	standard.index = 0;
	while (0 == ioctl (fd, VIDIOC_ENUMSTD, &standard)) {
	if (standard.id & std_id) {
	printf ("Current video standard: %s\n", standard.name);
	//exit (EXIT_SUCCESS);
	}
	standard.index++;
	}
	req.count = 3;
	req.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
	req.memory = V4L2_MEMORY_MMAP;

	printf("Initializing Display Device\n");
	ret = ioctl(fd, VIDIOC_REQBUFS, &req);
	if (ret) {
		perror("cannot allocate memory\n");
		close(fd);
		exit(0);

	}


	disp_buff_info =
		(struct buffer *) malloc(sizeof(struct buffer ) * req.count);
	if (!disp_buff_info) {
		printf("cannot allocate memory for buff_info\n");
		close(fd);
		exit(0);
	}

	for (i = 0; i < req.count; i++) {
		buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
		buf.index = i;
		ret = ioctl(fd, VIDIOC_QUERYBUF, &buf);
		if (ret) {
			perror("VIDIOC_QUERYCAP\n");
			for (j = 0; j < i; j++)
				munmap(disp_buff_info[j].start,
						disp_buff_info[j].length);
			close(fd);
			exit(0);
		}
		disp_buff_info[i].length = buf.length;
		disp_buff_info[i].index= buf.index;

		disp_buff_info[i].start =
			mmap(NULL, buf.length, PROT_READ | PROT_WRITE,
					MAP_SHARED, fd, buf.m.offset);

		if ((unsigned int) disp_buff_info[i].start ==
				MAP_SHARED) {
			printf("Cannot mmap = %d buffer\n", i);
			for (j = 0; j < i; j++)
				munmap(disp_buff_info[j].start,
						disp_buff_info[j].length);
			close(fd);
			exit(0);
		}
	}

	fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
//	fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;	
	fmt.fmt.pix.width = 720;
	fmt.fmt.pix.height = 576;
	fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

if(format==0)
  {
  fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
  }
  else
  { 
  fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
  }





	ret = ioctl(fd, VIDIOC_S_FMT, &fmt);
	if (ret) {
		perror("VIDIOC_S_FMT\n");
		close(fd);
		exit(0);
	}


	/* Enqueue buffers */
	for (i = 0; i < req.count; i++) {
		buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
		buf.index = i;
		buf.memory = V4L2_MEMORY_MMAP;
		ret = ioctl(fd, VIDIOC_QBUF, &buf);
		if (ret) {
			perror("VIDIOC_QBUF\n");
			for (j = 0; j < req.count; j++)
				munmap(disp_buff_info[j].start,
						disp_buff_info[j].length);
			exit(0);
		}
	}

	a = 0;
	ret = ioctl(fd, VIDIOC_STREAMON, &a);
	if (ret < 0) {
		perror("VIDIOC_STREAMON\n");
		for (i = 0; i < req.count; i++)
			munmap(disp_buff_info[i].start, disp_buff_info[i].length);
		exit(0);
	}
	printf("Enabled streaming on display device\n");
		
}

/******************************************************************************
 * 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;

  DBGENTER;

  Initialize_Capture ();

  test_data.vid1_width = 720;
  test_data.vid1_height = 480;
  test_data.vid1_xpos = 0;
  test_data.vid1_ypos = 0;
  test_data.vid1_hzoom = 0;	
  test_data.vid1_vzoom = 0;

  if ((init_vid_device (fdglobal)) < 0)
    {
      printf ("\nFailed to init vid1 window ");
      return FAILURE;
    }

#if 0
  if (mmap_vid1 () == FAILURE)
    return FAILURE;
#endif

  StartLoop ();

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

  DBGEXIT;
  return ret;
}

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

close_all_windows ()
{

close(fdglobal);
}

int
open_all_windows (int s1)
{
  int result = 0;

  if(s1==0)
  {
  	if ((fdglobal = open (V4L2VID0_DEVICE, O_RDWR)) < 0)
    	{
		goto open_all_exit;
	}
  }
  else if(s1==1)
  {

  	if ((fdglobal = open (V4L2VID1_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[] = "c:n:t:";
    char type;
    int testcase, no, index, c, ret = 0,d;
    int mode = O_RDWR;
    
    DBGENTER;

	
  	for (;;) 
	{
		d = getopt_long(argc, argv, shortoptions, (void *) NULL,
				&index);
		if (-1 == d)
			break;
		switch (d) {
			case 0:
				break;
			case 'c':
			case 'C':
				ch_no = atoi(optarg);
				break;
			case 'N':
			case 'n':
				numbuffers = atoi(optarg);
				break;
		        case 'T':
			case 't':
				format = atoi(optarg);
				break;

			default:
				usage();
				exit(1);
		}
	}
	
	if (!IS_VALID_CHANNEL(ch_no)) {
		printf("Invalid channel id \n");
		exit(0);
	}
	if (numbuffers < 0) {
		printf("Invalid numbufers \n");
		exit(0);
	}

        if((format < 0)||(format > 1))
        {
		printf("Invalid Format \n");
                exit(0);
        }


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

    /* Process command line parameters */
    ret = vpbe_UE_1();

    
    close_all_windows ();
    DBGEXIT;
    return 0;
}