static void run( const char *input, const char *output )
{
Huint i;
Huint j;
image *img;
clock_t start;
clock_t end;
double ela;
double bytes;
double bandw;
img = read_png_file( input );
start = clock();
send_image( img );
recv_image( img );
end = clock();
write_png_file( output, img );
ela = (double)(end - start);
ela /= 2405516000.0;
bytes = LOOPS * DATA * 8.0;
bandw = bytes / ela;
printf( "Processed %.2f bytes of data in %.2f seconds\n", bytes, ela );
printf( "Bandwidth: %.2f bytes/sec\n", bandw );
}
/* The image cache creates a thread that calls this function. It waits for remote
* images from the image-cache.
*/
void *accept_remote_image_connections(void *port)
{
int fd = *((int *) port);
struct sockaddr_in cli_addr;
socklen_t clilen = sizeof(cli_addr);
char snapshot_id_buf[PATHLEN], path_buf[PATHLEN];
uint64_t size, ret;
int flags, proxy_fd;
struct rimage *rimg;
proxy_fd = accept(fd, (struct sockaddr *) &cli_addr, &clilen);
if (proxy_fd < 0) {
pr_perror("Unable to accept remote image connection from image proxy");
return NULL;
}
while (1) {
ret = read_remote_header(proxy_fd, snapshot_id_buf, path_buf, &flags, &size);
if (ret < 0) {
pr_perror("Unable to receive remote header from image proxy");
return NULL;
}
/* This means that the no more images are coming. */
else if (!ret) {
pr_info("Image Proxy connection closed.\n");
finished = true;
unlock_workers();
return NULL;
}
pr_info("Received %s request for %s:%s\n",
flags == O_RDONLY ? "read" :
flags == O_APPEND ? "append" : "write",
path_buf, snapshot_id_buf);
rimg = prepare_remote_image(path_buf, snapshot_id_buf, flags);
prepare_recv_rimg();
ret = recv_image(proxy_fd, rimg, size, flags, false);
if (ret < 0) {
pr_perror("Unable to receive %s:%s from image proxy",
rimg->path, rimg->snapshot_id);
finalize_recv_rimg(NULL);
return NULL;
} else if (ret != size) {
pr_perror("Unable to receive %s:%s from image proxy (received %lu bytes, expected %lu bytes)",
rimg->path, rimg->snapshot_id, ret, size);
finalize_recv_rimg(NULL);
return NULL;
}
finalize_recv_rimg(rimg);
pr_info("Finished receiving %s:%s (received %lu bytes)\n",
rimg->path, rimg->snapshot_id, ret);
}
}
void VideoThread::run()
{
int size;
// struct sockaddr_in addr;
struct ReqHead head;
uchar frame[320*240*3];
int count=0;
//创建TCP套接字
// sock=socket(PF_INET,SOCK_STREAM,0);
// addr.sin_family = AF_INET;
// addr.sin_port = htons(6666);
// char* ch;
// QByteArray ba = ip.toLatin1();
// ch=ba.data();
// inet_pton(AF_INET,ch,&addr.sin_addr);
// //连接服务器
// if(::connect(sock,(struct sockaddr*)&addr,sizeof(addr)) != 0){
// ::close(sock);
// return;
// }
//发送视频监控请求
head.cmdNo = VIDEO_REQ;
head.bodyLen = HEAD_SIZE;
send(sock,&head,sizeof(head),0);
while(!stopped) {
//接收消息头
if(recv(sock,&head,HEAD_SIZE,0)<=0) {
::close(sock);
break;
}
count = 0;
while(count < head.bodyLen){
if((size = recv(sock,frame+count,head.bodyLen-count,0))<=0 ){
::close(sock);
return;
}
count += size;
}
emit recv_image(frame,count);
}
qDebug()<<"stop";
sleep(1);
// ::close(sock);
stopped = true;
}
recv_pack()
{
memset(getbuf,0, 1024*1000);
tout.tv_sec = 3;
tout.tv_usec = 0;
for(i = 0; i < 4; i++)
{
dtcmr_recv_timeout(sockfd, &recv_buf, 1,&tout);
if(recv_buf == 0x77){
recv_buf = 0;
}else{
usleep(100000);
i = 0;
recv_buf = 0;
}
}
dtcmr_recv_timeout(sockfd, &SEND_CMD, 1,&tout);
switch(SEND_CMD)
{
case CMD_IMAGE:
printf("SEND_CMD = %x\n",SEND_CMD);
ret = dtcmr_recv_timeout(sockfd, &recv_leng, 4,&tout);
printf("recv_leng= %d\n", recv_leng);
if(ret < 0){
printf("recv error");
}
ret = dtcmr_recv_timeout(sockfd, getbuf, recv_leng,&tout);
media_t *tmpinfo=(media_t *)getbuf;
memcpy(&imageinfo.count, &(tmpinfo->count), 4);
printf("imageinfo.count = %d\n",imageinfo.count);
for(i = 0;i <= imageinfo.count; i ++)
{
memcpy(imageinfo.get_info[i].filename,tmpinfo->get_info[i].filename,100);
memcpy(imageinfo.get_info[i].filesize,tmpinfo->get_info[i].filesize,32);
memcpy(imageinfo.get_info[i].filepath,tmpinfo->get_info[i].filepath,500);
}
break;
case CMD_APP:
memset(&appinfo, 0, sizeof(allappinfo_t));
printf("SEND_CMD = %x\n",SEND_CMD);
ret = dtcmr_recv_timeout(sockfd, &recv_leng, 4,&tout);
printf("recv_leng= %d\n", recv_leng);
if(ret < 0){
printf("recv error");
}
memset(getbuf,0, 1024*1000);
ret = dtcmr_recv_timeout(sockfd, getbuf, recv_leng,&tout);
allappinfo_t *apptmpinfo=(allappinfo_t *)getbuf;
memcpy(&appinfo.count, &(apptmpinfo->count), 4);
printf("appinfo.count = %d\n",appinfo.count);
for(i = 0;i <= appinfo.count; i ++)
{
appinfo.get_info[i].apppath = apptmpinfo->get_info[i].apppath;
appinfo.get_info[i].appattribute = apptmpinfo->get_info[i].appattribute;
memcpy(appinfo.get_info[i].appname,apptmpinfo->get_info[i].appname,50);
memcpy(appinfo.get_info[i].apppackname,apptmpinfo->get_info[i].apppackname,100);
memcpy(appinfo.get_info[i].appversion,apptmpinfo->get_info[i].appversion,15);
memcpy(appinfo.get_info[i].appsize,apptmpinfo->get_info[i].appsize,16);
}
OVERSIGN = 1;
REFRESHSIGN = CMD_APP;
SEND_CMD = 0;
break;
case CMD_BOOK:
memset(&bookinfo, 0, sizeof(allbookinfo_t));
printf("SEND_CMD = %x\n",SEND_CMD);
ret = dtcmr_recv_timeout(sockfd, &recv_leng, 4,&tout);
printf("recv_leng= %d\n", recv_leng);
if(ret < 0){
printf("recv error");
}
memset(getbookbuf,0, 1024*1000);
ret = dtcmr_recv_timeout(sockfd, getbookbuf, recv_leng,&tout);
allbookinfo_t *booktmpinfo=(allbookinfo_t *)getbookbuf;
memcpy(&bookinfo.count, &(booktmpinfo->count), 4);
printf("bookinfo.count = %d\n",bookinfo.count);
for(i = 0;i <= bookinfo.count; i ++)
{
memcpy(bookinfo.get_info[i].bookname,booktmpinfo->get_info[i].bookname,20);
// printf("bookname = %s\n",booktmpinfo->get_info[i].bookname);
memcpy(bookinfo.get_info[i].booknumber,booktmpinfo->get_info[i].booknumber,18);
// printf("booknumber = %s\n",bookinfo.get_info[i].booknumber);
}
REFRESHSIGN = CMD_BOOK;
SEND_CMD = 0;
break;
case CMD_STORAGE:
memset(&bookinfo, 0, sizeof(allbookinfo_t));
printf("SEND_CMD = %x\n",SEND_CMD);
ret = dtcmr_recv_timeout(sockfd, &recv_leng, 4,&tout);
printf("recv_leng= %d\n", recv_leng);
if(ret < 0){
printf("recv error");
}
memset(getstoragebuf,0, 200);
ret = dtcmr_recv_timeout(sockfd, getstoragebuf, recv_leng,&tout);
storageinfo_t *storagetmpinfo=(storageinfo_t *)getstoragebuf;
memcpy(storageinfo.sdSize,storagetmpinfo->sdSize,32);
memcpy(storageinfo.sdAvail,storagetmpinfo->sdAvail,32);
memcpy(storageinfo.memorySize,storagetmpinfo->memorySize,32);
memcpy(storageinfo.memoryAvail,storagetmpinfo->memoryAvail,32);
printf("%s,%s,%s,%s",storageinfo.sdSize,storageinfo.sdAvail,storageinfo.memorySize,storageinfo.memoryAvail);
REFRESHSIGN = CMD_STORAGE;
OVERSIGN = 1;
SEND_CMD = 0;
break;
case CMD_CALLPHONE:
printf("SEND_CMD = %x\n",CMD_CALLPHONE);
break;
case CMD_SENDMMS:
printf("SEND_CMD = %x\n",CMD_SENDMMS);
ret = dtcmr_recv_timeout(sockfd, &recv_leng, 4,&tout);
if(recv_leng)
printf("send message success\n");
break;
case CMD_MMS:
memset(&mmsinfo, 0, sizeof(allmmsinfo_t));
memset(getmmsbuf,0, 1024*10000);
printf("RECV_CMD = %x\n",SEND_CMD);
ret = dtcmr_recv_timeout(sockfd, &recv_leng, 4,&tout);
printf("recv_leng= %d\n", recv_leng);
if(ret < 0){
printf("recv error");
}
ret = dtcmr_recv_timeout(sockfd, getmmsbuf, recv_leng,&tout);
allmmsinfo_t *mmstmpinfo=(allmmsinfo_t *)getmmsbuf;
mmsinfo.count = mmstmpinfo->count;
printf("mmsinfo.count = %d\n",mmsinfo.count);
for(i = 0;i <= mmsinfo.count; i ++)
{
memcpy(mmsinfo.get_info[i].mmsname,mmstmpinfo->get_info[i].mmsname,20);
memcpy(mmsinfo.get_info[i].mmsnumber,mmstmpinfo->get_info[i].mmsnumber,18);
memcpy(mmsinfo.get_info[i].mmsbody,mmstmpinfo->get_info[i].mmsbody,1024*2);
// printf("mmsbody = %s\n",mmsinfo.get_info[i].mmsbody);
memcpy(mmsinfo.get_info[i].mmsdate,mmstmpinfo->get_info[i].mmsdate,25);
// printf("mmsdate = %s\n",mmsinfo.get_info[i].mmsdate);
mmsinfo.get_info[i].typeId = mmstmpinfo->get_info[i].typeId;
// printf("mmstypeId = %d\n",mmsinfo.get_info[i].typeId);
}
OVERSIGN = 1;
REFRESHSIGN = CMD_MMS;
SEND_CMD = 0;
break;
case CMD_ALL:
recv_storage();
recv_mms();
recv_book();
recv_app();
recv_image();
OVERSIGN = 1;
REFRESHSIGN = CMD_ALL;
SEND_CMD = 0;
default:
break;
}
}
