pal_loopback.c

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

/* Header files */
#include <stdio.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>
#include <getopt.h>

#include <sys/types.h>
#include <sys/mman.h>


#include <linux/fb.h>

#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/fb.h>
#include <asm/types.h>		/* for videodev2.h */
#include <time.h>
#include <media/dm355_vpfe.h>	/*kernel header file, prefix path comes from makefile */

#include <video/dm355fb.h>
#include "osd16.h"
#include "test_8.h"

/* True of false enumeration */
#define TRUE            1
#define FALSE           0

/* S-video input */

int svideoinput = FALSE;
struct buffer
{
  void *start;
  size_t length;
};

#define     CAPTURE_DEVICE  "/dev/video0"


// Aug 6 2007: Mahesh 
#define PALWIDTH 720
#define PALHEIGHT 576

#define MIN_BUFFERS 2

#define UYVY_BLACK          0x10801080

/* Device parameters */
#define OSD0_DEVICE      "/dev/fb/0"
#define OSD1_DEVICE      "/dev/fb/2"
#define FBVID0_DEVICE    "/dev/fb/1"
#define FBVID1_DEVICE    "/dev/fb/3"



/* Function error codes */
#define SUCCESS         0
#define FAILURE         -1
/* Bits per pixel for video window */
#define YUV_422_BPP          16
#define BITMAP_BPP_8         8

#define DISPLAY_INTERFACE	COMPOSITE
#define DISPLAY_MODE	NTSC

#define round_32(width) ((((width) + 31) / 32) * 32 )

/* D1 screen dimensions */
#define VID0_WIDTH 		720
#define VID0_HEIGHT		576
#define VID0_BPP		16
#define VID0_FRAME_SIZE		(VID0_WIDTH*VID0_HEIGHT)
#define VID0_VMODE	FB_VMODE_INTERLACED

#define VID1_WIDTH 		720
#define VID1_HEIGHT		576
#define VID1_BPP		16
#define VID1_FRAME_SIZE		(VID1_WIDTH*VID1_HEIGHT)
#define VID1_VMODE	FB_VMODE_INTERLACED

#define OSD0_BPP		4
#define	OSD0_WIDTH		(round_32(240*OSD0_BPP/8) * 8/OSD0_BPP)	
#define	OSD0_HEIGHT		120
#define OSD0_FRAME_SIZE		(OSD0_WIDTH*OSD0_HEIGHT)
#define OSD0_VMODE	FB_VMODE_INTERLACED

#define OSD1_BPP		8
#define	OSD1_WIDTH		(round_32(240*OSD1_BPP/8) * 8/OSD1_BPP)
#define	OSD1_HEIGHT		120
#define OSD1_FRAME_SIZE		(OSD1_WIDTH*OSD1_HEIGHT)
#define OSD1_VMODE	FB_VMODE_INTERLACED

//position 
#define	OSD0_XPOS		0	
#define	OSD0_YPOS		0
#define	OSD1_XPOS		300
#define	OSD1_YPOS		250
#define	VID0_XPOS		0
#define	VID0_YPOS		0
#define	VID1_XPOS		0
#define	VID1_YPOS		0

// Zoom Params
#define	OSD0_HZOOM		0
#define	OSD0_VZOOM		0
#define	OSD1_HZOOM		0
#define	OSD1_VZOOM		0
#define	VID0_HZOOM		0
#define	VID0_VZOOM		0
#define	VID1_HZOOM		0
#define	VID1_VZOOM		0

//OSd window blend factor
#define OSD1_WINDOW_BF		0
#define OSD1_WINDOW_CK		0
#define OSD1_CK			0
#define OSD0_WINDOW_BF		3
#define OSD0_WINDOW_CK		0
#define OSD0_CK			0

#define VIDEO_NUM_BUFS		3
#define OSD_NUM_BUFS		2
#define RED_COLOR 		249
#define BLUE_COLOR 		140	//blue color
#define RAM_CLUT_IDX 		0xFF
#define BITMAP_COLOR		0x11

#define CURSOR_XPOS		100
#define CURSOR_YPOS		100
#define CURSOR_XRES		50
#define CURSOR_YRES		50
#define CURSOR_THICKNESS	1
#define CURSOR_COLOR		0xF9

#define ATTR_BLINK_INTERVAL	1
#define ATTR_BLEND_VAL 		0xaa


struct vpbe_test_info
{
  int vid0_width;
  int vid0_height;
  int vid0_bpp;
  int vid0_frame_size;
  int vid0_vmode;

  int vid1_width;
  int vid1_height;
  int vid1_bpp;
  int vid1_frame_size;
  int vid1_vmode;

  int osd0_bpp;
  int osd0_width;
  int osd0_height;
  int osd0_frame_size;
  int osd0_vmode;

  int osd1_bpp;
  int osd1_width;
  int osd1_height;
  int osd1_frame_size;
  int osd1_vmode;

  //POSITION 
  int osd0_xpos;
  int osd0_ypos;
  int osd1_xpos;
  int osd1_ypos;
  int vid0_xpos;
  int vid0_ypos;
  int vid1_xpos;
  int vid1_ypos;

  // Zoom Params
  int osd0_hzoom;
  int osd0_vzoom;
  int osd1_hzoom;
  int osd1_vzoom;
  int vid0_hzoom;
  int vid0_vzoom;
  int vid1_hzoom;
  int vid1_vzoom;

  //OSD window blend factor
  int osd1_window_bf;
  int osd1_window_ck;
  int osd1_ck;
  int osd0_window_bf;
  int osd0_window_ck;
  int osd0_ck;

  int display_interface;
  int display_mode;

  int osd0_coloridx;
  int osd1_coloridx;
  int ram_clut_idx;
  int bitmap_color;

  int cursor_xpos;
  int cursor_ypos;
  int cursor_xres;
  int cursor_yres;
  int cursor_thickness;
  int cursor_color;

  int attr_blink_interval;
  int attr_blend_val;
};

static struct vpbe_test_info test_data = {
  VID0_WIDTH,
  VID0_HEIGHT,
  VID0_BPP,
  VID0_FRAME_SIZE,
  VID0_VMODE,

  VID1_WIDTH,
  VID1_HEIGHT,
  VID1_BPP,
  VID1_FRAME_SIZE,
  VID1_VMODE,

  OSD0_BPP,
  OSD0_WIDTH,
  OSD0_HEIGHT,
  OSD0_FRAME_SIZE,
  OSD0_VMODE,

  OSD1_BPP,
  OSD1_WIDTH,
  OSD1_HEIGHT,
  OSD1_FRAME_SIZE,
  OSD1_VMODE,

  OSD0_XPOS,
  OSD0_YPOS,
  OSD1_XPOS,
  OSD1_YPOS,
  VID0_XPOS,
  VID0_YPOS,
  VID1_XPOS,
  VID1_YPOS,

  OSD0_HZOOM,
  OSD0_VZOOM,
  OSD1_HZOOM,
  OSD1_VZOOM,
  VID0_HZOOM,
  VID0_VZOOM,
  VID1_HZOOM,
  VID1_VZOOM,

  OSD1_WINDOW_BF,
  OSD1_WINDOW_CK,
  OSD1_CK,
  OSD0_WINDOW_BF,
  OSD0_WINDOW_CK,
  OSD0_CK,

  DISPLAY_INTERFACE,
  DISPLAY_MODE,

  BLUE_COLOR,
  RED_COLOR,
  RAM_CLUT_IDX,
  BITMAP_COLOR,

  CURSOR_XPOS,
  CURSOR_YPOS,
  CURSOR_XRES,
  CURSOR_YRES,
  CURSOR_THICKNESS,
  CURSOR_COLOR,

  ATTR_BLINK_INTERVAL,
  ATTR_BLEND_VAL,
};

#define DEBUG

#ifdef DEBUG
#define DBGENTER  		printf("%s : E", __FUNCTION__);
#define DBGEXIT			printf("%s : L", __FUNCTION__);
#define PREV_DEBUG(x)		printf("DEBUG:%s:%s:%s",__FUNCTION__,__LINE__,x);
#else
#define DBGENTER
#define DBGEXIT
#define PREV_DEBUG(x)
#endif

#define CLEAR(x) memset (&(x), 0, sizeof (x))

/* ************************************************************************/
//Globals
/* ************************************************************************/
static int fdCapture = -1;
static int fdDisplay = -1;
struct buffer *buffers = NULL;
static int nBuffers = 0;
static int nWidthFinal = 0;
static int nHeightFinal = 0;
struct fb_var_screeninfo var;
struct fb_fix_screeninfo fix;
static int quit = 0;
char *vid0_display[VIDEO_NUM_BUFS] = { NULL, NULL, NULL };
char *vid1_display[VIDEO_NUM_BUFS] = { NULL, NULL, NULL };
char *osd0_display[OSD_NUM_BUFS] = { NULL, NULL };
char *osd1_display[OSD_NUM_BUFS] = { NULL, NULL };
int fd_vid0 = 0, fd_vid1 = 0, fd_osd0 = 0, fd_osd1 = 0;
struct fb_var_screeninfo vid0_varInfo, vid1_varInfo, osd0_varInfo,
  osd1_varInfo, prev_vid1_var, prev_vid0_var, prev_osd0_var, prev_osd1_var;
struct fb_fix_screeninfo vid0_fixInfo, vid1_fixInfo, osd0_fixInfo,
  osd1_fixInfo;
int vid0_size, vid1_size, osd0_size, osd1_size;
zoom_params_t zoom;
int stress_test = 0;// 1-default Abhishek;		//Flag to indicate currently stress test is going on
int startLoopCnt = 100;
int rgb565_enable = 0;		//Flag to indicate currently testing osd in rgb565 mode
int rgb565_enable_osd1 = 0;	//Flag to indicate currently testing osd in rgb565 mode
vpbe_bitmap_blend_params_t blend_info;

extern int errno;
int StartLoop (void);
static int InitCaptureDevice (void);
static int SetDataFormat ();
static int InitCaptureBuffers (void);
static int StartStreaming (void);
static void Initialize_Capture ();
static int DisplayFrame (char, void *);
static int Displaybitmap (char);
static int Displaybitmaposd0(void);
static int Displaybitmaposd1(void);
int unmap_and_disable (char);

void restore_config()
{
	vpbe_mode_info_t mode_info;
	vpbe_window_position_t pos;
	struct fb_cursor cursor_info;
	cursor_info.enable = VPBE_DISABLE;
	cursor_info.image.dx = CURSOR_XPOS;
	cursor_info.image.dy = CURSOR_YPOS;
	cursor_info.image.width = CURSOR_XRES;
	cursor_info.image.height = CURSOR_YRES;
	cursor_info.image.depth = CURSOR_THICKNESS;
	cursor_info.image.fg_color = CURSOR_COLOR;

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

        // We are restoring after the test. So do not need to make any changes here.
	mode_info.interface = COMPOSITE;
	mode_info.mode_idx = PAL;

	if (ioctl(fd_vid1, FBIO_QUERY_TIMING, &mode_info) < 0) {
		printf("\nFailed  FBIO_QUERY_TIMING");
		close(fd_vid1);
		return;
	}
        
	if (!strcmp(mode_info.vid_mode.name, "\0")) {
		printf("mode not supported\n");
		close(fd_vid1);
		return;
	}
	/* Set MODE */
	if (ioctl(fd_vid1, FBIO_SET_TIMING, &mode_info.vid_mode) < 0) {
		printf("\nFailed  FBIO_SET_TIMING");
		close(fd_vid1);
		return;
	}

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

        /* Modify the resolution and bpp as required */
        osd0_varInfo.bits_per_pixel = 16;

        /* Set vid0 window format */
        if (ioctl(fd_osd0, FBIOPUT_VSCREENINFO, &osd0_varInfo) < 0) {
                printf("\nFailed FBIOPUT_VSCREENINFO");
                return;
        }
	
	osd0_display[0] = (char *) mmap(NULL,
                                        osd0_fixInfo.line_length * osd0_varInfo.yres_virtual,
                                        PROT_READ | PROT_WRITE,
                                        MAP_SHARED, fd_osd0, 0);

	osd1_display[0] = (char *) mmap(NULL,
                                        osd1_fixInfo.line_length * osd1_varInfo.yres_virtual,
                                        PROT_READ | PROT_WRITE,
                                        MAP_SHARED, fd_osd1, 0);
	vid1_display[0] = (char *) mmap(NULL,
                                        vid1_fixInfo.line_length * vid1_varInfo.yres_virtual,
                                        PROT_READ | PROT_WRITE,
                                        MAP_SHARED, fd_vid1, 0);


           memset(osd0_display[0], 0x00, osd0_fixInfo.line_length * osd0_varInfo.yres_virtual);
	memset(osd1_display[0], 0x11, osd1_fixInfo.line_length * osd1_varInfo.yres_virtual);
	memset(vid1_display[0], 0x80, vid1_fixInfo.line_length * vid1_varInfo.yres_virtual);
	
	munmap(osd0_display[0], osd0_fixInfo.line_length * osd0_varInfo.yres_virtual);
	munmap(osd1_display[0], osd1_fixInfo.line_length * osd1_varInfo.yres_virtual);
	munmap(vid1_display[0], vid1_fixInfo.line_length * vid1_varInfo.yres_virtual);

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

        if (ioctl(fd_osd0, FBIO_ENABLE_DISPLAY, VPBE_ENABLE) < 0) {
                printf("\nFailed  FBIO_ENABLE_DISPLAY");
                close(fd_osd0);
                return ;
        }	
         
}

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

void
Initialize_Capture ()
{
  printf ("initializing capture device\n");
  InitCaptureDevice ();
  printf ("setting data format\n");
  SetDataFormat ();
  printf ("initializing capture buffers\n");
  InitCaptureBuffers ();
  printf ("initializing display device\n");
  StartStreaming ();
}

/* ************************************************************************/
int
StartLoop (void)
{
  struct v4l2_buffer buf;
  static int captFrmCnt = 0;
  char *ptrPlanar = NULL;
  int dummy;

  //StartStreaming();

  ptrPlanar = (char *) calloc (1, nWidthFinal * nHeightFinal * 2);

  while (1)
    {
      fd_set fds;
      struct timeval tv;
      int r;

      if (!stress_test)
	{
	  startLoopCnt--;
	  if (startLoopCnt == 0)
	    {
	      break;
	    }
	}

      FD_ZERO (&fds);
      FD_SET (fdCapture, &fds);

      /* Timeout. */
      tv.tv_sec = 2;
      tv.tv_usec = 0;

      r = select (fdCapture + 1, &fds, NULL, NULL, &tv);

      if (-1 == r)
	{
	  if (EINTR == errno)
	    continue;

	  printf ("StartCameraCaputre:select\n");
	  return -1;
	}

      if (0 == r)
	{
	  continue;
	}

      CLEAR (buf);
      buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      buf.memory = V4L2_MEMORY_MMAP;
      //printf("Debug 6............\n");
      /*determine ready buffer */
      if (-1 == ioctl (fdCapture, VIDIOC_DQBUF, &buf))
	{
	  if (EAGAIN == errno)
	    continue;
	  printf ("StartCameraCaputre:ioctl:VIDIOC_DQBUF\n");
	  return -1;
	}

      //DisplayFrame (VID0, buffers[buf.index].start); /* vid0 is not enabled. Uncomment this line when vid0 is available*/
      DisplayFrame (VID1, buffers[buf.index].start);
      Displaybitmaposd0();
      /* Wait for vertical sync */
      if (ioctl (fd_vid1, FBIO_WAITFORVSYNC, &dummy) < -1)
      {
	      printf ("Failed FBIO_WAITFORVSYNC\n");
	      return -1;
      }

      printf ("time:%d    frame:%u\n", time (NULL), captFrmCnt++);

      //requeue the buffer
      if (-1 == ioctl (fdCapture, VIDIOC_QBUF, &buf))
	{