init_vid1.c

TI dm6446 video subsytem window blending programme

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <asm/page.h>
#include <linux/fb.h>
#include <time.h>
#include <sys/time.h>

#include "davinci_fb.h"

#undef DBG
//#define DBG(x,...)
#define DBG printf

//#define VID1_ZOOM 1
#undef VID1_ZOOM

#define NUM_BUFS 3

/* Scaling factors for the video standards */
#define PAL             12
#define NTSC            10

#define UYVY_BLACK          0x10801080
/* Custom Davinci FBDEV defines */
#define VID0_INDEX 0
#define VID1_INDEX 1

#define ZOOM_1X    0
#define ZOOM_2X    1
#define ZOOM_4X    2

#if defined(VID1_ZOOM)
#define ZOOM_XFAC ZOOM_2X
#define ZOOM_YFAC ZOOM_2X
static int p_X0 = 100, p_Y0 = 50;
#else
#define ZOOM_XFAC ZOOM_1X
#define ZOOM_YFAC ZOOM_1X
static int p_X0 = 0, p_Y0 = 0;
#endif

#define SCREEN_BPP          16

#ifdef SVIDEO_OUTPUT
#  define D1_WIDTH            720
#  define D1_HEIGHT           480
#else
#  define D1_WIDTH            800
#  define D1_HEIGHT           600
#endif

#define D1_LINE_WIDTH       (D1_WIDTH * SCREEN_BPP / 8)
#define D1_FRAME_SIZE       (D1_LINE_WIDTH * D1_HEIGHT)

static int yfactor = 1;
static struct Zoom_Params zoom;

/******************************************************************************
 * initDisplayDevice
 ******************************************************************************/
static int initDisplayDevice(char *displays[])
{
    struct fb_var_screeninfo varInfo;
    unsigned int            *buf;
    int                      fd;
    int                      i;
    int                      std;

    fd = open(FBVID1_DEVICE, O_RDWR);

    if (fd == -1) {
        ERR("Failed to open fb device %s (%s)\n", FBVID1_DEVICE,
			strerror(errno));
        return FAILURE;
    }

    if (ioctl(fd, FBIOGET_VSCREENINFO, &varInfo) == -1) {
        ERR("Failed FBIOGET_VSCREENINFO on %s (%s)\n", FBVID1_DEVICE,
			strerror(errno));
        return FAILURE;
    }

#if 0
    if (ioctl(fd, FBIO_GETSTD, &std) == -1) {
        ERR("Failed to get video standard from display device driver\n");
        return FAILURE;
    }

    if ((std >> 16) == 0x1) {
        yfactor = NTSC;
    }
    else {
        yfactor = PAL;
    }

    /* Make sure there is no zoom */
    zoom.WindowID = VID1_INDEX;
    zoom.Zoom_H = ZOOM_XFAC;
    zoom.Zoom_V = ZOOM_YFAC;

    if (ioctl(fd, FBIO_SETZOOM, &zoom)) {
        ERR("Failed setting zoom parameters\n");
        return FAILURE;
    }

    varInfo.xres = D1_WIDTH;
    varInfo.yres = D1_HEIGHT;
    varInfo.bits_per_pixel = SCREEN_BPP;

    if (ioctl(fd, FBIOPUT_VSCREENINFO, &varInfo) == -1) {
        ERR("Failed FBIOPUT_VSCREENINFO on %s (%s)\n", FBVID1_DEVICE,
			strerror(errno));
        return FAILURE;
    }

    if (ioctl(fd, FBIO_SETPOSX, p_X0) == -1) {
        ERR("Failed FBIO_SETPOSX on %s (%s)\n", FBVID1_DEVICE,
            strerror(errno));
        return FAILURE;
    }

    if (ioctl(fd, FBIO_SETPOSY, p_Y0) == -1) {
        ERR("Failed FBIO_SETPOSX on %s (%s)\n", FBVID1_DEVICE,
            strerror(errno));
        return FAILURE;
    }

    if (varInfo.xres != D1_WIDTH ||
        varInfo.yres != D1_HEIGHT ||
        varInfo.bits_per_pixel != SCREEN_BPP) {
        ERR("Failed to get the requested screen size: %dx%d at %d bpp\n",
            D1_WIDTH, D1_HEIGHT, SCREEN_BPP);
        return FAILURE;
    }
#endif

    /* Map the video buffer to user space */
    displays[0] = (char *) mmap (NULL,
                                 D1_FRAME_SIZE * NUM_BUFS,
                                 PROT_READ | PROT_WRITE,
                                 MAP_SHARED,
                                 fd, 0);

    if (displays[0] == MAP_FAILED) {
        ERR("Failed mmap on %s (%s)\n", FBVID1_DEVICE, strerror(errno));
        return FAILURE;
    }

    /* Clear the video buffers */
    buf = (unsigned int *) displays[0];

	if(1)
	{
		for (i=0; i<D1_FRAME_SIZE * NUM_BUFS / sizeof(unsigned int); i++) {
			buf[i] = UYVY_BLACK;
		}
	}

	for (i=0; i<NUM_BUFS-1; i++) {
		displays[i+1] = displays[i] + D1_FRAME_SIZE;
	}

    return fd;
}

#define YUV_XRES 800
#define YUV_YRES 600
#define YUV_X    0
#define YUV_Y    0

#define MAX_YUVFILE 12
static char *yuvnames[MAX_YUVFILE] = {
	"0", "1", "2",  "3",
    "4", "5", "6",  "7",
    "8", "9", "10", "11" 
};

void process_image(int num, char *flipbuffer)
{
	#define MAX_YUVNAME  1024
	#define YUV_PATHNAME "/opt/vpbe/yuv/"
    #define YUV_SUFFIX   ".yuv"

	char yuvfullname[MAX_YUVNAME] = "";

    DBG("num: %d, max: %d\n", num, MAX_YUVFILE);
	if(num < 0 || num >= MAX_YUVFILE)
		num = 0;

	strcpy(yuvfullname, YUV_PATHNAME);
	strcpy(yuvfullname + strlen(yuvfullname), yuvnames[num]);
	strcpy(yuvfullname + strlen(yuvfullname), YUV_SUFFIX);
	DBG("filename: %s\n", yuvfullname);

	if(1)
	{
		FILE *yuvfp = NULL;
		char *pdisp = NULL;
		int i = 0;

		yuvfp = fopen(yuvfullname, "r");
		if(yuvfp == NULL)
		{
			ERR("Open %s failed!\n", yuvfullname);
			return;
		}
		
		pdisp = flipbuffer + YUV_Y * D1_LINE_WIDTH + YUV_X * 2; 

		for(i = 0; i < YUV_YRES; i++)
		{
			int readnum = 0; 

			if(0)
				DBG("Line %d[%d]: Buffer0ff=%d, FileOff=%d, len=%d\n", 
					i, i + YUV_Y, 
					pdisp - flipbuffer, ftell(yuvfp), YUV_XRES * 2);
			
			readnum = fread(pdisp, 1, 2 * YUV_XRES, yuvfp);

			if( (YUV_XRES * 2) != readnum)
			{
				ERR("Read from file to buffer Error!%d read\n", readnum);
				break;
			}

			fseek(yuvfp, readnum * (i + 1), SEEK_SET);
			pdisp += D1_LINE_WIDTH;
		}
		fclose(yuvfp);
	}
}

static int get_cur_display_idx(int fd)
{
    struct fb_var_screeninfo vInfo;
    int  indx;

    if (ioctl(fd, FBIOGET_VSCREENINFO, &vInfo) == -1) {
        ERR("Failed FBIOGET_VSCREENINFO (%s)\n", strerror(errno));
        return FAILURE;
    }
	
	indx = (vInfo.yoffset < vInfo.yres) ? 0 : 1;
	
	DBG("Current display index = %d\n", indx);
	return indx;
}

static int flipDisplayBuffers(int fd, int displayIdx)
{
    struct fb_var_screeninfo vInfo;
    int                      dummy;

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

    vInfo.yoffset = vInfo.yres * displayIdx;

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

    /* Wait for vertical sync */
    if (ioctl(fd, FBIO_WAITFORVSYNC, &dummy) == -1) {
        ERR("Failed FBIO_WAITFORVSYNC (%s)\n", strerror(errno));
        return FAILURE;
    }

    return SUCCESS;
}

int init_vid1()
{
	int  fbFd;
	char *displays[NUM_BUFS];
	double randnum;
	short randcolor;

	fbFd = initDisplayDevice(displays);
	if (fbFd == FAILURE) 
	{
		return FAILURE;
	}
	
	if(1)
	{
		int picnum = 0;
		int curdispinx = get_cur_display_idx(fbFd);
		int workindex = (curdispinx == 0) ? 1 : 0;
		struct timeval tv;
		gettimeofday(&tv, NULL);

		srandom(tv.tv_usec);
		randnum = random();
		randcolor = 1 + (unsigned char) (255.0 * randnum / (float)(RAND_MAX + 1.0));
		DBG("rand:%f[0x%x], randcolor: %d\n", randnum, RAND_MAX, randcolor);

		if(0)
		{
			memset(displays[workindex], randcolor, D1_FRAME_SIZE);
		}
		else
		{
			int j;
			
			//for(j = 0; j < MAX_YUVFILE; j++)
			{
				if(1)
				{
					picnum = 1 + (unsigned char) (12.0 * randnum / (float)(RAND_MAX + 1.0));
				}
				else
				{
					picnum = j;
				}

				//process_image(picnum, displays[workindex]);
				process_image(0, displays[workindex]);
				flipDisplayBuffers(fbFd, workindex);
			}
		}
	}

	close(fbFd);

	return SUCCESS;
}