grabber.c

以feith智能嵌入式相机为终端的linux-windows系统间通信

				*phelp++ = (BYTE)(*g++);			// green
				*phelp++ = (BYTE)(*r++ /wb_red);	// adjust red
								
			}
			else
			{
				*phelp++ = *b++;	// blue
				*phelp++ = *g++;	// green
				*phelp++ = *r++;	// red
			}

			   
		  }
	}

}

DWORD WINAPI ThreadLive(LPVOID lpv)
{
	HDC lDC;
	static BYTE *PPixel,*temppix;
	char s_str[150];
	BYTE error;
	WORD x1,x2,y1,y2;
	DWORD  ptradr, mem_s, lhelp;
	HPALETTE	  OldPal=NULL,hPal;
	PPARAMS pparams ;
	BYTE *PRed[1024],*PGreen[1024],*PBlue[1024];	
	GLOBALHANDLE HRed,HGreen,HBlue;
	BYTE *Pcfa[1024];	
	int img_size,i,j,max1,max2;
	
    int count=0,all=5;
   
    int huidu[256]={0};
    int yuzhi=0;
    int allcount=width*height;


	LARGE_INTEGER llnHPTimerFreq;	// High Performance Timer: Frequency
	LARGE_INTEGER llnHPT1;			// High Performance Timer: Time 1
	LARGE_INTEGER llnHPT2;			// High Performance Timer: Time 2
	LARGE_INTEGER llnT_uSec;		// Time in microseconds


	QueryPerformanceFrequency(&llnHPTimerFreq);

	pparams = (PPARAMS) lpv;
			
	get_video_window(camera,&x1,&y1,&x2,&y2);
	width = x2 - x1 +1;
	height = y2 - y1+1;

	if(img_cnt > 1)
		height = (fpga_mem_offset * (int)(img_cnt)) / width;

	img_size = width * height;

	get_memory_size(camera,&mem_s);

	if(mem_s < (DWORD)img_size)
		set_memory_size(camera,img_size);

	error = get_pixel_ptr(camera,0, &ptradr);          // Pixel Pointer

	BitmapInfo->bmiHeader.biWidth = width;
	BitmapInfo->bmiHeader.biHeight = height;

	if(sensor_type == 0)
	{
		BitmapInfo->bmiHeader.biBitCount = 8;
		BitmapInfo->bmiHeader.biSizeImage = (DWORD)BitmapInfo->bmiHeader.biWidth *
													(DWORD)BitmapInfo->bmiHeader.biHeight;
		BitmapInfo->bmiHeader.biClrUsed = 256;
		BitmapInfo->bmiHeader.biClrImportant = 256;

		PPixel = (BYTE *)ptradr;				 
	}
	if(sensor_type == 1)
	{
		BitmapInfo->bmiHeader.biBitCount = 24;
		BitmapInfo->bmiHeader.biSizeImage = (DWORD)(BitmapInfo->bmiHeader.biWidth * (DWORD)3) *
														(DWORD)BitmapInfo->bmiHeader.biHeight;
		BitmapInfo->bmiHeader.biClrUsed = 0;
		BitmapInfo->bmiHeader.biClrImportant = 0;

		HRed = GlobalAlloc(GHND, img_size);
		PRed[0] = (BYTE *)GlobalLock(HRed);

		HGreen = GlobalAlloc(GHND, img_size);
		PGreen[0] = (BYTE *)GlobalLock(HGreen);

		HBlue = GlobalAlloc(GHND, img_size);
		PBlue[0] = (BYTE *)GlobalLock(HBlue);

		PPixel = Prgb;

		Pcfa[0] = (BYTE *)ptradr;
		j = width;
		for(i = 1;i < height;i++)
		{
			PRed[i] = PRed[0] + j;
			PGreen[i] = PGreen[0] + j;
			PBlue[i] = PBlue[0] + j;
			Pcfa[i] = Pcfa[0] + j;
			j += width;
		}

	}
	BitmapInfo->bmiHeader.biHeight = -height;
			
	debug_info(camera,0);
			
	lDC = GetDC(pparams->hwnd);
			
	
	if(sensor_type == 0)
		OldPal = SetBMPPalette(lDC,pparams->hwnd,&hPal);   // Set black/white Palette 
	
	//if (hardware_version == 2)
	//	set_grab_param(camera,1024,1280);

	if (trigger_role == 0)
		error = grab_image(camera,0,0);	
	else
		error = grab_sync_image_on_trigger(camera,0,1);			//Bild grabben mit Sync-Signal			
	while (!pparams->bKill)
	{
		QueryPerformanceCounter(&llnHPT1);

		if (trigger_role == 0)
			error = grab_image(camera,0,0);	
		else
			error = grab_sync_image_on_trigger(camera,0,1);			//Bild grabben mit Sync-Signal			
		if(error)
		{
			pparams->bKill = TRUE;
			break;
		}

		
    

 


       temppix=PPixel;
       for(i=0;i<width;i++)
	   {
		for(j=0;j<height;j++)
		{  if(*(temppix+i*height+j)>128)
		       *(temppix+i*height+j)=255;
	     	else
		    	*(temppix+i*height+j)=0;
		}
	   }
 
		//custom specific preprocessing in FPGA
		//mark specific pixels
		/*
		for (i=0;i<1024;i++)
		{
			write_fpga(camera,0x0070, (DWORD)i);
			read_fpga(camera,0x0070, &lhelp);
			PPixel[(i*1280)+lhelp] = 0xff;
		}
		*/
		QueryPerformanceCounter(&llnHPT2);
		if(sensor_type == 1)
			make_rgb(PPixel,Pcfa,PRed,PGreen,PBlue);
	
		SetDIBitsToDevice(lDC,0,0,width,height,hPos,0,vPos,height,
								PPixel,(LPBITMAPINFO)BitmapInfo,DIB_RGB_COLORS);
		

		llnT_uSec.QuadPart = ( (llnHPT2.QuadPart - llnHPT1.QuadPart) * // Time Delta
				                    ((LONGLONG)1E9/llnHPTimerFreq.QuadPart) ) / 
								         (LONGLONG)1E3; // could divide by 1E9 for Time in Sec
		sprintf(s_str,"%3d Sec: %03d mSec: %03d  uSec\n", 
				llnT_uSec.LowPart/(LONG)1E6, (llnT_uSec.LowPart/(LONG)1E3)%(1000), 
				(llnT_uSec.LowPart)%(1000));

			
		set_status_bar(0,s_str);
	}
			
	if(error)
	{
		sprintf(s_str,"Error = %d",error);
		MessageBox(pparams->hwnd,s_str,"ERROR",MB_OK);
	}
		
	debug_info(camera,1);

	if(sensor_type == 0)
		SelectPalette(lDC, OldPal, FALSE);    // Alte Palette wieder setzen
	
	if(sensor_type == 1)
	{
		GlobalUnlock(HRed);
		GlobalFree(HRed);

		GlobalUnlock(HGreen);
		GlobalFree(HGreen);

		GlobalUnlock(HBlue);
		GlobalFree(HBlue);
	}
	
	ReleaseDC(pparams->hwnd,lDC);
	DeleteObject(hPal);

	set_status_bar(0,"");

	return(0);
}

BYTE SaveBmp(char *fname)
{
	FILE *hfile;
	BYTE *buf;
	DWORD ptradr;
	HCURSOR OldCursor;
	BITMAPFILEHEADER bmpfilehdr;
	int i,offset,rgb_h;
			
			
	OldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
			
	if ((hfile = fopen(fname,"wb" )) == NULL)
	{
		SetCursor(OldCursor);
		return(1);
	}
			
	if(sensor_type == 0)
	{
		offset = 256 * sizeof(RGBQUAD);
		rgb_h = 1;
	}
	if(sensor_type == 1)
	{
		offset = 0;
		rgb_h = 3;
	}
	// build bmp headers
	bmpfilehdr.bfType = 0x4D42;                 // "BM"
	bmpfilehdr.bfSize = BitmapInfo->bmiHeader.biSizeImage + sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER) + offset;
	bmpfilehdr.bfReserved1 = 0;
	bmpfilehdr.bfReserved2 = 0;
	bmpfilehdr.bfOffBits = sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER) + offset;
		
	// write the BMP FILE Headers
	if(fwrite(&bmpfilehdr, sizeof(BITMAPFILEHEADER),1,hfile) == 0)
	{
		SetCursor(OldCursor);
		return(2);
	}
	BitmapInfo->bmiHeader.biHeight = abs(BitmapInfo->bmiHeader.biHeight);
			
	// write the BMP INFO Header
	if(fwrite(BitmapInfo, sizeof(BITMAPINFOHEADER) + offset,1,hfile) == 0)
	{
		SetCursor(OldCursor);
		return(2);
	}
			
	if(sensor_type == 0)
	{
		get_pixel_ptr(camera,0, &ptradr);
		buf = (BYTE *)ptradr;
	}
	if(sensor_type == 1)
	{
		buf = (BYTE *)Prgb;
	}

	buf = buf + ((BitmapInfo->bmiHeader.biWidth * rgb_h) * (BitmapInfo->bmiHeader.biHeight - 1));
	for(i = BitmapInfo->bmiHeader.biHeight -1 ;i >= 0;i--)
	{
				
		if(fwrite((BYTE *)buf,BitmapInfo->bmiHeader.biWidth * rgb_h,1,hfile) == 0)
		{
			SetCursor(OldCursor);
			return(2);
		}
		buf -= BitmapInfo->bmiHeader.biWidth * rgb_h;
	}
	BitmapInfo->bmiHeader.biHeight = -BitmapInfo->bmiHeader.biHeight;
	fclose(hfile);
	SetCursor(OldCursor);
	return 0;
} // save_bmp



void SetLUT(BYTE mode)
{
	int i;
	BYTE val, val_normal, val_low_light;

	// attention!!! we must disable debug infos
	debug_info(camera,0);

	for(i = 0;i < 1024;i++)
	{
		val_normal = (BYTE)(i / 4);
		if (i<256)
			val_low_light = (BYTE)i;
		else
			val_low_light = 255;

		if(mode == 0)
			val = val_normal;
		if(mode == 1)
			val = ~val_normal;
		if(mode == 2)
			val = val_low_light;
		if(mode == 3)
			val = ~val_low_light;
		
		set_lut(camera,(WORD)i,val);
	}
	// enable debug infos
	debug_info(camera,1);
}


void CAN_Demo(BYTE mode)
{
	int i;
	BYTE buf[8],error,len;
	char l_str[200];
	DWORD id;
	WORD flags;


	error = init_can(camera,125,0x7ff);	
	if(error)
	{
		sprintf(l_str,"init can error %d",error);
		MessageBox(NULL ,l_str,"test",MB_OK);
		return;
	}

	if(mode == 0)	
	{
		// send message
		buf[0] = 0;
		buf[1] = 1;
		buf[2] = 2;
		buf[3] = 3;
		buf[4] = 4;
		buf[5] = 5;
		buf[6] = 6;
		buf[7] = 7;

		error = send_can(camera,100,8,0,buf);
		if(error)
		{
			sprintf(l_str,"send error %d",error);
			MessageBox(NULL ,l_str,"test",MB_OK);
		}
	}
	else		
	{
		// receive message
		error = receive_can(camera,&id,&len,&flags,buf);
		if(error)
		{
			sprintf(l_str,"receive error %d",error);
			MessageBox(NULL ,l_str,"test",MB_OK);
		}
		else
		{
			if(len == 0)
				sprintf(l_str,"no message available");
			else
				sprintf(l_str,"id = %ld\nlen = %d\nflags = %d\nb0 = %d\nb1 = %d\nb2 = %d\nb3 = %d\nb4 = %d\nb5 = %d\nb6 = %d\nb7 = %d\n",
										id,len,flags,buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7]);

			MessageBox(NULL ,l_str,"test",MB_OK);

		}
	}
	close_can(camera);
}