btcamera.cpp

蓝牙

#include <stdlib.h>
#include <sys/mman.h>
#include "btcamera.h"
#include "byjpeg.h"
#include "bycmd.h"
#include "webcamclient.h"
#include "btrmtdevmgr.h"
#include "inifile.h"
#include "global.h"
#include "xlog.h"
#include "btsocket.h"
#include "bthandsfree.h"

extern int g_nCamDataPos;

extern std::string g_strPeerJjtId;

// 摄像头
BTCONNHDL g_hSppCamera = BTSDK_INVALID_HANDLE;
BTDEVHDL g_hDevCamera = BTSDK_INVALID_HANDLE;
BTUINT8 g_nComCamera = 0xFF;
char g_szCameraNo[128] = "0001";
bool g_bCameraConnected = false;
BTUINT8 g_szCameraAddr[BTSDK_BDADDR_LEN];
BTUINT8 g_szOldCameraAddr[BTSDK_BDADDR_LEN];

extern char EIMCode[10];
extern int localx;
extern int localy;
extern int localwidth;
extern int localheight;
extern int remotex;
extern int remotey;
extern int remotewidth;
extern int remoteheight;

bool g_bCamSend = false;
int g_nSendType = 0;
#define CAM_WIDTH (320/2)
#define CAM_HEIGHT (240/2)

WebCamClient g_webCamClient;

bool g_bTestUdp = false;

char g_camDestAddr[128] = "127.0.0.1";

#define VF_BYTES_PER_PIXEL 2
#define FB_DEVICE "/dev/fb0"
static int fd_fb = -1;
static unsigned short *fb_map = NULL;
#define VF_IMAGE_SIZE (CAM_WIDTH * CAM_HEIGHT * VF_BYTES_PER_PIXEL)

unsigned char* g_rgb888 = NULL;
unsigned char* g_rgb565 = NULL;

void rgb888_to_rgb565(int nx, int ny, unsigned char* rgb888, unsigned char* rgb565)
{
	unsigned char* src = rgb888;
	unsigned char* dst = rgb565;
	unsigned char* posSrc;
	unsigned char* posDst;
	unsigned char r, g, b;

	for (int i = 0; i < ny; i++)
	{
		posSrc = src;
		posDst = dst;
		for (int j = 0; j < nx; j++)
		{
			// fix me，要不然红蓝反了
			r = *posSrc++;
			g = *posSrc++;
			b = *posSrc++;
			*((unsigned short*)posDst) = (unsigned short)(((r >> 3) << 11) | ((g >> 2) << 5)| ((b >> 3) << 0));
			posDst += 2;
		}
		src += nx * 3;
		dst += nx * 2;
	}
}

void display_jpeg(const char* jpeg, int len)
{
	if (!jpeg)
	{
		printf("jpeg is NULL!!!!\n");
		return;
	}

	if (!jpeg_to_rgb(jpeg, len, (char*)g_rgb888, CAM_WIDTH * CAM_HEIGHT * 3, CAM_WIDTH, CAM_HEIGHT))
	{
		printf("jpeg_to_rgb failed\n");
		DisconnectCamera();
		return;
	}

	rgb888_to_rgb565(CAM_WIDTH, CAM_HEIGHT, g_rgb888, g_rgb565);

	int i, j;
	unsigned short* pfb = fb_map;
	int x = (640 - CAM_WIDTH) / 2;
	int y = (480 - CAM_HEIGHT) / 2;

	for (i = 0; i < CAM_HEIGHT; i++)
	{
		pfb = fb_map + (CAM_HEIGHT - i - 1 + y) * 640 + x;
		for (j = 0; j < CAM_WIDTH; j++)
		{
			*((unsigned short*)pfb + j)=*((unsigned short*)g_rgb565 + CAM_WIDTH*i + j);
		}
	}
}

void display_jpeg_dynamic(const char* jpeg, int len,int xpos,int ypos,int width,int height)
{
	if (!jpeg)
	{
		printf("jpeg is NULL!!!!\n");
		return;
	}

	if (!jpeg_to_rgb(jpeg, len, (char*)g_rgb888, width * height * 3, width,height))
	{
		printf("jpeg_to_rgb failed\n");
		DisconnectCamera();
		return;
	}

	rgb888_to_rgb565(width,height,g_rgb888, g_rgb565);

	int i, j;
	unsigned short* pfb = fb_map;
	int x = xpos;
	int y = ypos;

	for (i = 0; i < height; i++)
	{
		pfb = fb_map + (height - i - 1 + y) * 640 + x;
		for (j = 0; j < width; j++)
		{
			*((unsigned short*)pfb + j)=*((unsigned short*)g_rgb565 + width*i + j);
		}
        }
}

bool ConnectToWebCamServer()
{
	if (g_webCamClient.m_bConnected)
		return true;

	IniFile ini;
	ini.Open("minibox.conf");

	std::string ip = ini.Read("camera", "web_camera_ip", "");
	std::string port = ini.Read("camera", "web_camera_port", "");
	// std::string web_cam_no = ini.Read("camera", "web_camera_user_no", "");
	std::string web_cam_no = ini.Read("BYIM", "jjtid", "");

	printf("%s:%s, %s\n", ip.c_str(), port.c_str(), web_cam_no.c_str());

	g_webCamClient.Close();
	g_webCamClient.Create();
	g_webCamClient.m_bConnected = false;

        if (g_webCamClient.Connect(ip.c_str(), atoi(port.c_str())))
	{
		g_webCamClient.m_bConnected = true;
		char head[9];
		int n;

		strcpy(head, "0001");
		n = g_webCamClient.Send("0001", 4);
                if(n>0)
		{
		        printf("3333333333333333333333333333333333333333333333333333333333333333333333333333333\n");
         	}	

		strcpy(head, "000008");
		n += g_webCamClient.Send("000008", 6);
          
                if(n>0)
		{
		        printf("4444444444444444444444444444444444444444444444444444444444444444444444444444444\n");
         	}	
	
		n += g_webCamClient.Send(web_cam_no.c_str(), web_cam_no.length());
                if(n>0)
                {
		        printf("5555555555555555555555555555555555555555555555555555555555555555555555555555555\n");
		}	
         	printf("%d\n", n);
		return true;
	}

	return false;
}

bool ConnectToCamera(int n)
{
	if (g_rgb565)
	{
		delete[] g_rgb565;
		g_rgb565 = NULL;
	}
	g_rgb565 = new unsigned char[CAM_WIDTH * CAM_HEIGHT * 2];

	if (g_rgb888)
	{
		delete[] g_rgb888;
		g_rgb888 = NULL;
	}
	g_rgb888 = new unsigned char[CAM_WIDTH * CAM_HEIGHT * 3];

	if (fd_fb == -1)
	{
		if ((fd_fb = open(FB_DEVICE, O_RDWR)) <= 0)
		{
			printf("Frame buffer %s open error!\n", FB_DEVICE);
		}
		else
		{
			printf("Use %s as frame buffer device.\n", FB_DEVICE);
			if (fb_map == NULL)
			{
				if ((fb_map = (unsigned short*)mmap(0, 640 * 480 * 2, PROT_READ | PROT_WRITE, MAP_SHARED, fd_fb, 0)) == 0)
				{
					printf("Error: failed to map framebuffer device %s.\n", FB_DEVICE);
					close(fd_fb);
					fd_fb = -1;
				}
			}
		}
	}

	DisconnectCamera();
	BtSdkSPPConnParamStru comstru;
	comstru.size = sizeof(BtSdkSPPConnParamStru);
	comstru.mask = 0;
	comstru.com_index = 7;

	char no[128];
	sprintf(no, "addr%d", n);
	sprintf(g_szCameraNo, "%04d", n);

	IniFile ini;
	ini.Open("minibox.conf");
	std::string addr = ini.Read("camera", no, "");
	if (addr.empty())
	{
		printf("摄像头地址为空\n");
		return false;
	}
	ParseBtAddr(addr.c_str(), g_szCameraAddr);
	memcpy(g_szOldCameraAddr, g_szCameraAddr, sizeof(g_szCameraAddr));

	OutputBtAddr(g_szCameraAddr);
	printf("%s %s\n", no, g_szCameraNo);

	g_hDevCamera = Btsdk_AddRemoteDevice(g_szCameraAddr);
	BTINT32 result = Btsdk_StartClientEx(g_hDevCamera, BTSDK_CLS_SERIAL_PORT, 0, &g_hSppCamera);
	// BtSdkConnectionPropertyStru conn_prop;
	// Btsdk_GetConnectionProperty(g_hSppCamera, &conn_prop);

	g_bCameraConnected = false;

	g_nCamDataPos = 0;
        if (result == BTSDK_OK)
        {
		LOG(DEBUG, "ConnectToCamera 成功\n");
		g_bCameraConnected = true;
		g_nComCamera = Btsdk_GetClientPort(g_hSppCamera);

        	std::string count = ini.Read("camera", "frames_per_second", "1");
		printf("%s\n", count.c_str());

		IpcPacket o(CAM_START);
		o.Write32(atoi(count.c_str()));
		RcvSdrvData(g_nComCamera, (char*)o.GetPtr(), o.GetSize());
	}
	else if (result == BTSDK_ER_CONNECTION_EXIST)
	{
		LOG(DEBUG, "ConnectToCameraConnection exist\n");
		g_bCameraConnected = true;
	}
    else
	{
		LOG(DEBUG, "ConnectToCamera %lu\n", result);
        g_bCameraConnected = false;
    }

	return g_bCameraConnected;
}


void StopCameraSend()
{
	IpcPacket o(CAM_STOP);
	RcvSdrvData(g_nComCamera, (char*)o.GetPtr(), o.GetSize());
}

void DisconnectCamera()
{
	if (g_hSppCamera != BTSDK_INVALID_HANDLE)
	{
		StopCameraSend();
		BTINT32 result = Btsdk_Disconnect(g_hSppCamera);
		if (result == BTSDK_OK)
		{
			LOG(DEBUG, "断开 SPP 连接成功\n");
			g_nComCamera = 0xFF;
                        
/*			char head[128] = { 0 };
		        int n;
			strcpy(head,"0007");
		        n = g_webCamClient.Send(head, 4);
		        sprintf(head, "%06d", 4);
			n = g_webCamClient.Send(head, 6);                        
                        strcpy(head, g_szCameraNo); 
                        n = g_webCamClient.Send(head, 4);
	         	printf("rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr\n");*/
		}
		else
		{
			LOG(DEBUG, "断开 SPP 连接失败\n");
		}
	}
	if (g_rgb888)
	{
		delete[] g_rgb888;
		g_rgb888 = NULL;
	}
	if (g_rgb565)
	{
		delete[] g_rgb565;
		g_rgb565 = NULL;
	}

	g_nCamDataPos = 0;
	g_hSppCamera = BTSDK_INVALID_HANDLE;
	g_bCameraConnected = false;
}

void ProcessCamData(const IpcPacket& in)
{
	static char buf[50 * 1024] = { 0 };
 	int n ;       
        int size; 
	size = in.ReadData(buf);
	// printf("ProcessCamData, %d, %d, %d\n", in.GetSize(), g_bCamSend, size);
	if (g_bCamSend && g_nSendType == 0)
	{
		if (fd_fb != -1 && fb_map)
		{
			if (!g_rgb565)
				g_rgb565 = new unsigned char[CAM_WIDTH * CAM_HEIGHT * 2];

			if (!g_rgb888)
				g_rgb888 = new unsigned char[CAM_WIDTH * CAM_HEIGHT * 3];

			display_jpeg(buf, size);
		}
		else
			printf("Can not display jpeg\n");

		 if (g_bTestUdp)
		 {
		 	IpcPacket o(in.GetCmd());
		 	o.WriteData(buf, size);
		 	g_btSock.SendTo(o, BY_MAIN_PORT, g_camDestAddr);
		 }
	}

	if (g_bCamSend && g_nSendType == 1)
	{
		if (fd_fb != -1 && fb_map)
		{
			if (!g_rgb565)
				g_rgb565 = new unsigned char[localwidth * localheight* 2];

			if (!g_rgb888)
				g_rgb888 = new unsigned char[localwidth * localheight* 3];

                        display_jpeg_dynamic(buf, size,localx,localy,localwidth,localheight);

			printf("%d\n",localx);
			printf("%d\n",localy);
			printf("%d\n",localwidth);
			printf("%d\n",localheight);

		}
		else
			printf("Can not display jpeg\n");

		if (g_bTestUdp)
		{
		 	IpcPacket o(in.GetCmd());
		 	o.WriteData(buf, size);
		 	g_btSock.SendTo(o, BY_MAIN_PORT, g_camDestAddr);
		}
        }

	if (g_webCamClient.m_bConnected)
	{
		char head[128] = { 0 };
		int n;

		if (g_nSendType == 1)
                { 
			strcpy(head, "0041");
                }
		else
			strcpy(head,"0002");
		// printf("%s\n", head);
		n = g_webCamClient.Send(head, 4);

                if (g_nSendType == 0)
		{
                        size+=4; 
			sprintf(head, "%06d", size);
			n = g_webCamClient.Send(head, 6);
                }
                if (g_nSendType == 1)
                {
                        size+=12;
			sprintf(head, "%06d", size);
			n = g_webCamClient.Send(head, 6);
                }
		strcpy(head, g_szCameraNo); // 摄像头编号
		n = g_webCamClient.Send(head, 4);

                if (g_nSendType == 1)
		{
			n = g_webCamClient.Send(EIMCode,8);
			printf("%s\n",EIMCode);
		}

                if (g_nSendType == 1)
		{
                        size-=12;
                        n = g_webCamClient.Send(buf, size);
                        if(n!=size)
                 		printf("send failed, len = %d, n = %d\n", size, n);
			else
				printf("send ok\n");
                }

                if (g_nSendType == 0)
		{
                        size-=4;
                        n = g_webCamClient.Send(buf, size);
                        if(n!=size)
                 		printf("send failed, len = %d, n = %d\n", size, n);
			else
				printf("send ok\n");
                }

	}
}