usbvision.c

这是一个Linux下的USB摄像头捕捉程序

int scratch_get_extra(struct usb_usbvision *usbvision, unsigned char *data, int *ptr, int len)
{
	int len_part;
	if (*ptr + len < scratch_buf_size) {
		memcpy(data, usbvision->scratch + *ptr, len);
		*ptr += len;
	}
	else {
		len_part = scratch_buf_size - *ptr;
		memcpy(data, usbvision->scratch + *ptr, len_part);
		if (len == len_part) {
			*ptr = 0;							/* just set the y_ptr to zero */
		}
		else {
			memcpy(data + len_part, usbvision->scratch, len - len_part);
			*ptr = len - len_part;
		}
	}

	PDEBUG(DBG_SCRATCH, "len=%d, new ptr=%d\n", len, *ptr);

	return len;
}


/* This sets the scratch extra read pointer */
void scratch_set_extra_ptr(struct usb_usbvision *usbvision, int *ptr, int len)
{
	*ptr = (usbvision->scratch_read_ptr + len)%scratch_buf_size;

	PDEBUG(DBG_SCRATCH, "ptr=%d\n", *ptr);
}


/*This increments the scratch extra read pointer */
void scratch_inc_extra_ptr(int *ptr, int len)
{
	*ptr = (*ptr + len) % scratch_buf_size;

	PDEBUG(DBG_SCRATCH, "ptr=%d\n", *ptr);
}


/* This gets data from the buffer */
int scratch_get(struct usb_usbvision *usbvision, unsigned char *data, int len)
{
	int len_part;
	if (usbvision->scratch_read_ptr + len < scratch_buf_size) {
		memcpy(data, usbvision->scratch + usbvision->scratch_read_ptr, len);
		usbvision->scratch_read_ptr += len;
	}
	else {
		len_part = scratch_buf_size - usbvision->scratch_read_ptr;
		memcpy(data, usbvision->scratch + usbvision->scratch_read_ptr, len_part);
		if (len == len_part) {
			usbvision->scratch_read_ptr = 0;				/* just set the read_ptr to zero */
		}
		else {
			memcpy(data + len_part, usbvision->scratch, len - len_part);
			usbvision->scratch_read_ptr = len - len_part;
		}
	}

	PDEBUG(DBG_SCRATCH, "len=%d, new read_ptr=%d\n", len, usbvision->scratch_read_ptr);

	return len;
}


/* This sets read pointer to next header and returns it */
int scratch_get_header(struct usb_usbvision *usbvision,struct usbvision_frame_header *header)
{
	int errCode = 0;

	PDEBUG(DBG_SCRATCH, "from read_ptr=%d", usbvision->scratch_headermarker_read_ptr);

	while (usbvision->scratch_headermarker_write_ptr -
		usbvision->scratch_headermarker_read_ptr != 0) {
		usbvision->scratch_read_ptr =
			usbvision->scratch_headermarker[usbvision->scratch_headermarker_read_ptr];
		usbvision->scratch_headermarker_read_ptr += 1;
		usbvision->scratch_headermarker_read_ptr %= USBVISION_NUM_HEADERMARKER;
		scratch_get(usbvision, (unsigned char *)header, USBVISION_HEADER_LENGTH);
		if ((header->magic_1 == USBVISION_MAGIC_1)
			 && (header->magic_2 == USBVISION_MAGIC_2)
			 && (header->headerLength == USBVISION_HEADER_LENGTH)) {
			errCode = USBVISION_HEADER_LENGTH;
			header->frameWidth  = header->frameWidthLo  + (header->frameWidthHi << 8);
			header->frameHeight = header->frameHeightLo + (header->frameHeightHi << 8);
			break;
		}
	}

	return errCode;
}


/*This removes len bytes of old data from the buffer */
void scratch_rm_old(struct usb_usbvision *usbvision, int len)
{

	usbvision->scratch_read_ptr += len;
	usbvision->scratch_read_ptr %= scratch_buf_size;
	PDEBUG(DBG_SCRATCH, "read_ptr is now %d\n", usbvision->scratch_read_ptr);
}


/*This resets the buffer - kills all data in it too */
void scratch_reset(struct usb_usbvision *usbvision)
{
	PDEBUG(DBG_SCRATCH, "\n");

	usbvision->scratch_read_ptr = 0;
	usbvision->scratch_write_ptr = 0;
	usbvision->scratch_headermarker_read_ptr = 0;
	usbvision->scratch_headermarker_write_ptr = 0;
	usbvision->isocstate = IsocState_NoFrame;
}



/* Here comes the OVERLAY stuff */

/* Tell the interrupt handler what to to.  */
static
void usbvision_cap(struct usb_usbvision* usbvision, int on)
{
	DEBUG(printk(KERN_DEBUG "usbvision_cap: overlay was %d, set it to %d\n", usbvision->overlay, on);)

	if (on) {
		usbvision->overlay = 1;
	}
	else {
		usbvision->overlay = 0;
	}
}




/* append a new clipregion to the vector of video_clips */
static
void usbvision_new_clip(struct video_window* vw, struct video_clip* vcp, int x, int y, int w, int h)
{
	vcp[vw->clipcount].x = x;
	vcp[vw->clipcount].y = y;
	vcp[vw->clipcount].width = w;
	vcp[vw->clipcount].height = h;
	vw->clipcount++;
}


#define mark_pixel(x,y)  usbvision->clipmask[((x) + (y) * MAX_FRAME_WIDTH)/32] |= 0x00000001<<((x)%32)
#define clipped_pixel(index) usbvision->clipmask[(index)/32] & (0x00000001<<((index)%32))

static
void usbvision_built_overlay(struct usb_usbvision* usbvision, int count, struct video_clip *vcp)
{
	usbvision->overlay_win = usbvision->overlay_base +
		(signed int)usbvision->vid_win.x * usbvision->vid_buf.depth / 8 +
		(signed int)usbvision->vid_win.y * usbvision->vid_buf.bytesperline;

		IODEBUG(printk(KERN_DEBUG "built_overlay base=%p, win=%p, bpl=%d, clips=%d, size=%dx%d\n",
					usbvision->overlay_base, usbvision->overlay_win,
					usbvision->vid_buf.bytesperline, count,
					usbvision->vid_win.width, usbvision->vid_win.height);)


	/* Add here generation of clipping mask */
{
	int x_start, x_end, y_start, y_end;
	int clip_index, x, y;

	memset(usbvision->clipmask, 0, USBVISION_CLIPMASK_SIZE);

	OVDEBUG(printk(KERN_DEBUG "clips = %d\n", count);)

	for(clip_index = 0; clip_index < count; clip_index++) {
		OVDEBUG(printk(KERN_DEBUG "clip: %d,%d,%d,%d\n", vcp[clip_index].x,
				vcp[clip_index].y,
				vcp[clip_index].width,
				vcp[clip_index].height);)

		x_start = vcp[clip_index].x;
		if(x_start >= (int)usbvision->vid_win.width) {
			OVDEBUG(printk(KERN_DEBUG "x_start=%d\n", x_start);)
			continue; //clipping window is right of overlay window
		}
		x_end	= x_start + vcp[clip_index].width;
		if(x_end <= 0) {
			OVDEBUG(printk(KERN_DEBUG "x_end=%d\n", x_end);)
			continue; //clipping window is left of overlay window
		}

		y_start = vcp[clip_index].y;
		if(y_start >= (int)usbvision->vid_win.height) {
			OVDEBUG(printk(KERN_DEBUG "y_start=%d\n", y_start);)
			continue; //clipping window is below overlay window
		}
		y_end   = y_start + vcp[clip_index].height;
		if(y_end <= 0) {
			OVDEBUG(printk(KERN_DEBUG "y_end=%d\n", y_end);)
			continue; //clipping window is above overlay window
		}

		//clip the clipping window
		if (x_start < 0) {
			x_start = 0;
		}
		if (x_end > (int)usbvision->vid_win.width) {
			x_end = (int)usbvision->vid_win.width;
		}
		if (y_start < 0) {
			y_start = 0;
		}
		if (y_end > (int)usbvision->vid_win.height) {
			y_end = (int)usbvision->vid_win.height;
		}

		OVDEBUG(printk(KERN_DEBUG "clip_o: %d,%d,%d,%d\n", x_start,	y_start, x_end, y_end);)



		for(y = y_start; y < y_end; y++) {
			for(x = x_start; x < x_end; x++) {
				mark_pixel(x,y);
			}
		}
	}
}

}



void usbvision_osd_char(struct usb_usbvision *usbvision,
			struct usbvision_frame *frame, int x, int y, int ch)
{
	static const unsigned short digits[16] = {
		0xF6DE,		/* 0 */
		0x2492,		/* 1 */
		0xE7CE,		/* 2 */
		0xE79E,		/* 3 */
		0xB792,		/* 4 */
		0xF39E,		/* 5 */
		0xF3DE,		/* 6 */
		0xF492,		/* 7 */
		0xF7DE,		/* 8 */
		0xF79E,		/* 9 */
		0x77DA,		/* a */
		0xD75C,		/* b */
		0xF24E,		/* c */
		0xD6DC,		/* d */
		0xF34E,		/* e */
		0xF348		/* f */
	};
	unsigned short digit;
	int ix, iy;

	if ((usbvision == NULL) || (frame == NULL))
		return;

	if (ch >= '0' && ch <= '9')
		ch -= '0';
	else if (ch >= 'A' && ch <= 'F')
		ch = 10 + (ch - 'A');
	else if (ch >= 'a' && ch <= 'f')
		ch = 10 + (ch - 'a');
	else
		return;
	digit = digits[ch];

	for (iy = 0; iy < 5; iy++) {
		for (ix = 0; ix < 3; ix++) {
			if (digit & 0x8000) {
			//	USBVISION_PUTPIXEL(frame, x + ix, y + iy,
			//			0xFF, 0xFF, 0xFF);
			}
			digit = digit << 1;
		}
	}
}


void usbvision_osd_string(struct usb_usbvision *usbvision,
			  struct usbvision_frame *frame,
			  int x, int y, const char *str)
{
	while (*str) {
		usbvision_osd_char(usbvision, frame, x, y, *str);
		str++;
		x += 4;		/* 3 pixels character + 1 space */
	}
}

/*
 * usb_usbvision_osd_stats()
 *
 * On screen display of important debugging information.
 *
 */
void usbvision_osd_stats(struct usb_usbvision *usbvision,
			 struct usbvision_frame *frame)
{
	const int y_diff = 8;
	char tmp[16];
	int x = 10;
	int y = 10;

	sprintf(tmp, "%8x", usbvision->frame_num);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->isocUrbCount);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->urb_length);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->isocDataCount);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->header_count);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->scratch_ovf_count);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->isocSkipCount);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8lx", usbvision->isocErrCount);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8x", usbvision->vpic.colour);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8x", usbvision->vpic.hue);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8x", usbvision->vpic.brightness >> 8);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8x", usbvision->vpic.contrast >> 12);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;

	sprintf(tmp, "%8d", usbvision->vpic.whiteness >> 8);
	usbvision_osd_string(usbvision, frame, x, y, tmp);
	y += y_diff;
}

/*
 * usbvision_testpattern()
 *
 * Procedure forms a test pattern (yellow grid on blue background).
 *
 * Parameters:
 * fullframe:   if TRUE then entire frame is filled, otherwise the procedure
 *	        continues from the current scanline.
 * pmode	0: fill the frame with solid blue color (like on VCR or TV)
 *	        1: Draw a colored grid
 *
 */
void usbvision_testpattern(struct usb_usbvision *usbvision, int fullframe,
			int pmode)
{
	static const char proc[] = "usbvision_testpattern";
	struct usbvision_frame *frame;
	unsigned char *f;
	int num_cell = 0;
	int scan_length = 0;
	static int num_pass = 0;

	if (usbvision == NULL) {
		printk(KERN_ERR "%s: usbvision == NULL\n", proc);
		return;
	}