display.c

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>		/* low-level i/o */
#include <unistd.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 <pthread.h>
#include <time.h>
#include <linux/videodev.h>
#include <media/davinci_vpfe.h>	/*kernel header file, prefix path comes from
				   makefile */
#include <video/davincifb.h>
#include "ipipe_example.h"
#include "display.h"

#define V4L2VID0_DEVICE    "/dev/video2"
#define V4L2VID1_DEVICE    "/dev/video3"

static int fdDisplay = -1;

struct buffer *disp_buff_info = NULL;



void restore_display_config()
{
	close(fdDisplay);
}

int InitDisplayDevice(void)
{
	struct v4l2_requestbuffers req;
	struct v4l2_buffer buf;
	int a, ret, i,j;
	struct v4l2_format fmt;
	req.count = 3;
	req.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
	req.memory = V4L2_MEMORY_MMAP;
	v4l2_std_id std_id;

  	if ((fdDisplay = open (V4L2VID1_DEVICE, O_RDWR)) < 0)
    	{
		return -1;
	}
	std_id = V4L2_STD_525_60; // for PAL
	ret = ioctl(fdDisplay, VIDIOC_S_STD, &std_id);
	if (ret) {
		printf("VIDIOC_S_STD\n");
		close(fdDisplay);
		exit(0);
	}
	printf("Initializing Display Device\n");
	ret = ioctl(fdDisplay, VIDIOC_REQBUFS, &req);
	if (ret) {
		printf("cannot allocate memory\n");
		close(fdDisplay);
		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(fdDisplay);
		exit(0);
	}

	for (i = 0; i < req.count; i++) {
		buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
		buf.index = i;
		ret = ioctl(fdDisplay, VIDIOC_QUERYBUF, &buf);
		if (ret) {
			printf("VIDIOC_QUERYCAP\n");
			for (j = 0; j < i; j++)
				munmap(disp_buff_info[j].start,
						disp_buff_info[j].length);
			close(fdDisplay);
			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, fdDisplay, 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(fdDisplay);
			exit(0);
		}
		memset(disp_buff_info[i].start, 0, 720*480*2);
	}

	fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
	fmt.fmt.pix.width = 720;
	fmt.fmt.pix.height = 480;
	fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

	//fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
	fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;

	ret = ioctl(fdDisplay, VIDIOC_S_FMT, &fmt);
	if (ret) {
		printf("VIDIOC_S_FMT\n");
		close(fdDisplay);
		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(fdDisplay, VIDIOC_QBUF, &buf);
		if (ret) {
			printf("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(fdDisplay, VIDIOC_STREAMON, &a);
	if (ret < 0) {
		printf("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");
	
	return 0;
}


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

	memset(&buf, 0, sizeof(buf));
	buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
	ret = ioctl(fdDisplay, VIDIOC_DQBUF, &buf);
	if (ret < 0) {
		printf("VIDIOC_DQBUF\n");
		for (i = 0; i < 3; i++)
			munmap(disp_buff_info[i].start,
				disp_buff_info[i].length);
		close(fdDisplay);
		return NULL;
	}
	return disp_buff_info[buf.index].start;
}

int putDisplayBuffer(void *addr)
{
	struct v4l2_buffer buf;
	int i, index = 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(fdDisplay, VIDIOC_QBUF, &buf);

	if (ret)
		return ret;

	return 0;
}
int DisplayFrame(void *ptrBuffer,int src_width, int src_height)
{
	static int xoffset = 0;
	static int yoffset = 0;
	int i;
	char *dst, *temp;
	char *src;

	int width = src_width > D1_WIDTH ? D1_WIDTH : src_width;
	int height = src_height > D1_HEIGHT ? D1_HEIGHT : src_height;

	src = ptrBuffer + xoffset * 2  + yoffset * ((src_width * 2 + 31 ) & (~31));
	temp = dst = getDisplayBuffer();

	for (i = 0; i < height; i++) {
		memcpy(dst, src, width * 2);
		dst += 720*2;
		src +=  (src_width * 2 + 31 ) & (~31);
	}
	if(src_width > width) {
		xoffset = (xoffset + 8) % (src_width - width);
	}
	if(xoffset == 0 && src_height > height) {
		yoffset = (yoffset + 8) % (src_height - height);
	}

	return putDisplayBuffer(temp); 
}