基于ARM的网络图像传输

介绍基于ARM的网络图像传输技术 一段程序，两个线程：一个完成usb摄像头图像的采集，另一个借助网络实现远程传输。图像采集线程通过调用获取图像的程序完成采集任务；网络传输就是socket编程了。

/*******************************************************
* Filename: soket_image.c
* Description:Send image by gprs
* Author: ly44770
* History: 1.0
* Date: 07/06/27
*******************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
//#include <sys/ipc.h>
#include <semaphore.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <netdb.h>
//#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#include <sys/wait.h>
#define TRUE 1
#define FALSE 0
#define SERVPORT 9009
#define SERVER_IP "192.168.1.202"
//#define SERVER_IP "192.168.0.21"
typedef char BOOL;
BOOL bDataOK;
#define SIZE_PACKET 512
#define STR_HEAD "MY_IMG"
#define GH_DBNAME "MY_IMG_ARM"
#define Group_Devide_Flag "|"
#define STR_TAIL "AT91RM"
#define NAME_LEN strlen(GH_DBNAME)
typedef struct
{
unsigned short ID; // Command ID
char Parameter1; // Parameter1
char Parameter2; // Parameter2
char Parameter3; // Parameter3
char Parameter4; // Parameter4
} _comedia_CMD;
//_comedia_CMD comedia_CMD;
_comedia_CMD comedia_CMD2;

typedef struct
{
unsigned short ID;
unsigned short DataSize;
char data[506];
unsigned short VerifyCode;
} _PKG;
_PKG PKG;
_PKG PKG2;
#pragma pack(1)
typedef struct
{
char BufHead[6];
char BufDevide1[1];
char BufDbName[NAME_LEN];
char BufDevide2[1];
_PKG m_Pkg;
char BufDevide3[1];
char BufTail[4];
} GH_PKG ;
#pragma pack()
GH_PKG SendPkg;
//unsigned long ulImageBuffer;
//unsigned long ulIndex;
void InitPackage()
{
memset(SendPkg.BufHead,'/0',6);
memcpy(SendPkg.BufHead,STR_HEAD,strlen(STR_HEAD));
memset(SendPkg.BufDevide1,'/0',1);
memcpy(SendPkg.BufDevide1,Group_Devide_Flag,strlen(Group_Devide_Flag));
memset(SendPkg.BufDbName,'/0',11);
memcpy(SendPkg.BufDbName,GH_DBNAME,strlen(GH_DBNAME));
memset(SendPkg.BufDevide2,'/0',1);
memcpy(SendPkg.BufDevide2,Group_Devide_Flag,strlen(Group_Devide_Flag));
memcpy(&SendPkg.m_Pkg,&PKG2,sizeof(_PKG));
memset(SendPkg.BufDevide3,'/0',1);
memcpy(SendPkg.BufDevide3,Group_Devide_Flag,strlen(Group_Devide_Flag));
memset(SendPkg.BufTail,'/0',4);
memcpy(SendPkg.BufTail,STR_TAIL,strlen(STR_TAIL));
}

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t get_img,send_img;
void consumer(void *arg);
void productor(void *arg);

int main(int argc, char *argv[])
{
int ret;
pthread_t id1,id2;

pthread_mutex_init(&mutex,NULL);
if(ret!=0)
{
perror("mutex_init");
}

ret=sem_init(&get_img,0,0);
if(ret!=0)
{
perror("get_img_sem_init");
}

ret=sem_init(&send_img,0,1);
if(ret!=0)
{
perror("send_img_sem_init");
}

// InitPackage();
while(1){
ret=pthread_create(&id1,NULL,(void *)productor, NULL);
if(ret!=0)
perror("pthread cread1");

ret=pthread_create(&id2,NULL,(void *)consumer, NULL);
if(ret!=0)
perror("pthread cread2");

pthread_join(id1,NULL);
pthread_join(id2,NULL);
}
exit(0);
}
void productor(void *arg)
{
// int i,nwrite;

while(1)
{
sem_wait(&send_img);
if(pthread_mutex_lock(&mutex)!=0){
perror("pthread_mutex_lock");
exit(1);

}
printf("get image pthread start/n");
if(fork() == 0)
{
if(execl("/home/a/vgrabbj","vgrabbj","-f ./1.jpg", "-d /dev/v4l/video0",NULL) < 0)
perror("execl error!/n");
printf("get image ok");
}
wait(0);
if(pthread_mutex_unlock(&mutex)!=0){
perror("pthread_mutex_unlock");
}
else
printf("get image pthread stop/n");
sem_post(&get_img);
sleep(1);
//pthread_exit(0);
}
}
void consumer(void *arg)
{
int i,img_fd;
int sockfd,sendbytes;
struct sockaddr_in serv_addr;
void *img_addr = NULL;
int img_index;
void *img_addr2 = NULL;
int img_index2;
struct stat sb;
int Pkg_num,DataSize,LastDataSize;
BOOL bDone;
int iIndex,iTemp;
// bDone = FALSE;
// iIndex = 0;
while(1)
{
sem_wait(&get_img);
if(pthread_mutex_lock(&mutex)!=0){
perror("pthread_mutex_lock");
}
else
{
printf("send image pthread start/n");
img_fd = open("/home/work/mywork/image/1.jpg",O_RDONLY);
if(img_fd < 0)
{ perror("open the image");
exit(1);
}
fstat(img_fd,&sb);
img_addr = mmap(NULL,sb.st_size,PROT_READ,MAP_PRIVATE,img_fd,0);
if(img_addr == MAP_FAILED)
{ perror("map the image");
exit(1);
}
LastDataSize = sb.st_size % 506;
if(LastDataSize == 0)
Pkg_num = sb.st_size / 506 ;
else
Pkg_num = sb.st_size / 506 + 1;
//LastDataSize = sb.st_size % 506;
DataSize = Pkg_num * 512;
//DataSize = sb.st_size;
img_addr2 = malloc(DataSize);
if(img_addr2 == NULL)
printf("malloc error /n");
img_index = 0;
img_index2 = 0;
if(LastDataSize == 0)
{for(i = 0; i < Pkg_num; i++)
{
PKG.ID = i;
PKG.DataSize = 506;
memcpy(PKG.data,img_addr + img_index,506);
memcpy(img_addr2 + img_index2,&PKG,sizeof(_PKG));
img_index += 506;
img_index2 += sizeof(_PKG);
}
}else{
for(i = 0; i < (Pkg_num-1); i++)
{
PKG.ID = i;
PKG.DataSize = 506;
memcpy(PKG.data,img_addr + img_index,506);
memcpy(img_addr2 + img_index2,&PKG,sizeof(_PKG));
img_index += 506;
img_index2 += sizeof(_PKG);
}
//img_index += 506;
//img_index2 += sizeof(_PKG);
PKG.ID = Pkg_num - 1;
PKG.DataSize = LastDataSize;
memcpy(PKG.data,img_addr + img_index,LastDataSize);
memcpy(img_addr2 + img_index2,&PKG,sizeof(_PKG));
}
#if 0
fd2 = open("/home/work/mywork/image/2.jpg",O_CREAT|O_RDWR);
if(fd2 < 0)
{ perror("open the image2");
exit(1);
}
write(fd2,img_add,sb.st_size);
memcpy(a,img_add,5);
printf("%c/n",a[1]);
printf("%x/n",b[0]);
printf("%x/n",b[1]);
#endif
munmap(img_addr,sb.st_size);
close(img_fd);
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1){
perror("socket");
exit(1);
}
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(SERVPORT);
serv_addr.sin_addr.s_addr=inet_addr(SERVER_IP);
bzero(&(serv_addr.sin_zero),8);

if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(struct sockaddr))==-1){
perror("connect");
exit(1);
}

comedia_CMD2.ID = 0x0aaa;
comedia_CMD2.Parameter1 = 0x05;
comedia_CMD2.Parameter2 = ( char )( sb.st_size );
comedia_CMD2.Parameter3 = ( char )( sb.st_size / 256 );
comedia_CMD2.Parameter4 = ( char )( sb.st_size / 256 / 256 );

printf("DataSize=%d/n",DataSize);
printf("PKG.DataSize=%d/n",PKG.DataSize);
printf("Pkg_num=%d/n",Pkg_num);
printf("LastDataSize=%d/n",LastDataSize);
printf("comedia_CMD2.ID=%d/n",comedia_CMD2.ID);
printf("comedia_CMD2.Parameter1=%d/n",comedia_CMD2.Parameter1);
printf("comedia_CMD2.Parameter2=%d/n",comedia_CMD2.Parameter2);
printf("comedia_CMD2.Parameter3=%d/n",comedia_CMD2.Parameter3);
printf("comedia_CMD2.Parameter4=%d/n",comedia_CMD2.Parameter4);

InitPackage();
if((sendbytes=send(sockfd,&comedia_CMD2,sizeof(_comedia_CMD),0))==-1){
perror("send");
exit(1);
}
printf("send %d bytes/n",sendbytes);
// static BOOL bDone;
// static int iIndex,iTemp;
bDone = FALSE;
iIndex = 0;
while(!bDone)
{
printf("start to receive/n");
if((iTemp=recv(sockfd,&comedia_CMD2,sizeof(_comedia_CMD),0))==-1)
{
bDone = TRUE;
perror("recv");
printf("/ntcp read error!/n");
exit(1);
}
printf("recv %d bytes/n",iTemp);
iIndex += iTemp;
if( iIndex >= 6 )
{
iIndex = 0;
if( comedia_CMD2.ID == 0x0eaa )
{
if( comedia_CMD2.Parameter3 == (char)0xf0
&& comedia_CMD2.Parameter4 == (char)0xf0 )
{
//bDataOK = FALSE;
printf( "/nsend Image id = %d./n", PKG2.ID );
bDone = TRUE;
}
else
{
if( TRUE )
{
printf( "/nsend Image id = %d./n", comedia_CMD2.Parameter3 );
memcpy(&PKG2,img_addr2 + comedia_CMD2.Parameter3 * 512, sizeof( _PKG ) );
memcpy(&SendPkg.m_Pkg,&PKG2,sizeof(_PKG));
printf("/nGH_PKG size= %d/n",sizeof(GH_PKG));
printf("/n_PKG size= %d/n",sizeof(_PKG));
if((iTemp=send(sockfd,&SendPkg,sizeof(GH_PKG),0))==-1){
printf("/ntcp write error!/n");
perror("send");
exit(1);
}
}
}
}
}
}
close(sockfd);
free(img_addr2);
img_addr2 = NULL;
if(pthread_mutex_unlock(&mutex)!=0){
perror("pthread_mutex_unlock");
}
else
printf("send image pthread stop/n");
sem_post(&send_img);
sleep(1);
//pthread_exit(0);
}
}
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zouwen198317/archive/2010/08/21/5829361.aspx