servfox解析

b02330224

于 2013-08-18 10:59:45 发布

阅读量723

点赞数

CC 4.0 BY-SA版权

分类专栏：移植servfox

本文链接：https://blog.youkuaiyun.com/b02330224/article/details/10042953

移植servfox 专栏收录该内容

10 篇文章

订阅专栏

main()
{
init_videoIn(&videoIn, videodevice, width, height, format,grabmethod)
pthread_create (&w1, NULL, (void *) grab, NULL)) //   grab线程抓取图像数据，转换格式

serv_sock = open_sock(serverport);
printf("Waiting .... for connection. CTrl_c to stop !!!! \n");
while (videoIn.signalquit)
    {
          sin_size = sizeof(struct sockaddr_in);
         if ((new_sock = accept(serv_sock, (struct sockaddr *)&their_addr, &sin_size)) == -1)
         {
         continue;
         }
        printf("Got connection from %s\n",inet_ntoa(their_addr.sin_addr));
        pthread_create(&server_th, NULL, (void *)service, &new_sock); //service线程，先读取客户端的message消息，设置摄像头的参数，再向客户端先发送frame_t的headerframe图像信息，再发送图像数据
     }
pthread_join (w1, NULL);
close(serv_sock);
close_v4l (&videoIn);

}

int init_videoIn (struct vdIn *vd, char *device, int width, int height,int format, int grabmethod)
{

vd->signalquit = 1;
vd->hdrwidth = width;
vd->hdrheight = height;
vd->formatIn = format;
vd->bppIn = GetDepth (vd->formatIn);
vd->grabMethod = grabmethod;  //mmap or read
vd->pFramebuffer = NULL;
init_v4l (vd);
/* allocate the 4 frames output buffer */
for (i = 0; i < OUTFRMNUMB; i++)
    {
      vd->ptframe[i] = NULL;
      vd->ptframe[i] =
       (unsigned char *) realloc (vd->ptframe[i], sizeof(struct frame_t) + (size_t) vd->framesizeIn );
      vd->framelock[i] = 0;
    }
   vd->frame_cour = 0;
   pthread_mutex_init (&vd->grabmutex, NULL);

}

static int init_v4l (struct vdIn *vd)
{

if (vd->grabMethod)
    {
      printf (" grabbing method default MMAP asked \n");
      memset (&(vd->videombuf), 0, sizeof (vd->videombuf));
      ioctl (vd->fd, VIDIOCGMBUF, &(vd->videombuf))
     printf ("VIDIOCGMBUF size %d frames %d offets[0]=%d offsets[1]=%d\n",
     vd->videombuf.size, vd->videombuf.frames,
     vd->videombuf.offsets[0], vd->videombuf.offsets[1]);
      vd->pFramebuffer =(unsigned char *) mmap (0, vd->videombuf.size, PROT_READ | PROT_WRITE,MAP_SHARED, vd->fd, 0);
      vd->mmapsize = vd->videombuf.size;
      vd->vmmap.height = vd->hdrheight;
      vd->vmmap.width = vd->hdrwidth;
      vd->vmmap.format = vd->formatIn;
      for (f = 0; f < vd->videombuf.frames; f++)
     {
       vd->vmmap.frame = f;
       ioctl (vd->fd, VIDIOCMCAPTURE, &(vd->vmmap))
        vd->vmmap.frame = 0;
      }
    }
else
    {
      /* read method */
      /* allocate the read buffer */
      vd->pFramebuffer =(unsigned char *) realloc (vd->pFramebuffer, (size_t) vd->framesizeIn);
      printf (" grabbing method READ asked \n");
      ioctl (vd->fd, VIDIOCGWIN, &(vd->videowin)
      vd->videowin.height = vd->hdrheight;
      vd->videowin.width = vd->hdrwidth;
      ioctl (vd->fd, VIDIOCSWIN, &(vd->videowin)
    }
   vd->frame_cour = 0;
}

void grab (void)
{
for (;;)
    {
           v4lGrab(&videoIn);
           break;
   }

}

int v4lGrab (struct vdIn *vd )

{
   if (vd->grabMethod)
   {
      ioctl (vd->fd, VIDIOCSYNC,&vd->vmmap.frame);
      jpegsize= convertframe(vd->ptframe[vd->frame_cour]+ sizeof(struct frame_t), vd->pFramebuffer + vd->videombuf.offsets[vd->vmmap.frame],vd->hdrwidth,vd->hdrheight,vd->formatIn,qualite);
      headerframe=(struct frame_t*)vd->ptframe[vd->frame_cour];
     snprintf(headerframe->header,5,"%s","SPCA");
     headerframe->seqtimes = ms_time();
     headerframe->deltatimes=(int)(headerframe->seqtimes-timecourant);
     headerframe->w = vd->hdrwidth;
     headerframe->h = vd->hdrheight;
     headerframe->size = (( jpegsize < 0)?0:jpegsize);
     headerframe->format = vd->formatIn;
     headerframe->nbframe = frame++;
     ioctl (vd->fd, VIDIOCMCAPTURE, &(vd->vmmap)；
     vd->vmmap.frame = (vd->vmmap.frame + 1) % vd->videombuf.frames;
     vd->frame_cour = (vd->frame_cour +1) % OUTFRMNUMB;
}
else
{
           len = read (vd->fd, vd->pFramebuffer, size);
           jpegsize= convertframe(vd->ptframe[vd->frame_cour]+ sizeof(struct frame_t), vd->pFramebuffer ,vd->hdrwidth,vd->hdrheight,vd->formatIn,qualite);
           headerframe=(struct frame_t*)vd->ptframe[vd->frame_cour];
            snprintf(headerframe->header,5,"%s","SPCA");
            headerframe->seqtimes = ms_time();
            headerframe->deltatimes=(int)(headerframe->seqtimes-timecourant);
            headerframe->w = vd->hdrwidth;
            headerframe->h = vd->hdrheight;
            headerframe->size = (( jpegsize < 0)?0:jpegsize);;
            headerframe->format = vd->formatIn;
            headerframe->nbframe = frame++;
            vd->frame_cour = (vd->frame_cour +1) % OUTFRMNUMB;


   }

}

void   service (void *ir)
{
     for (;;)
        {
          memset(&message,0,sizeof(struct client_t));
         ret = read(sock,(unsigned char*)&message,sizeof(struct client_t));

         if(ret && (message.message[0] != 'O')) break;

         if (message.updobright){
         switch (message.updobright){
        case 1:
          bright = upbright(&videoIn);
        break;
        case 2: bright = downbright(&videoIn);
        break;
        }
        ack = 1;
         } else if (message.updocontrast){
         switch (message.updocontrast){
        case 1: contrast = upcontrast(&videoIn);
        break;
        case 2: contrast = downcontrast(&videoIn);
        break;
        }
        ack = 1;
        } else if (message.updoexposure){
         switch (message.updoexposure){
        case 1: spcaSetAutoExpo(&videoIn);
        break;
        case 2:;
        break;
        }
        ack = 1;
        } else if (message.updosize){ //compatibility FIX chg quality factor ATM
         switch (message.updosize){
        case 1: qualityUp(&videoIn);
        break;
        case 2: qualityDown(&videoIn);
        break;
        }
        ack = 1;
        } else if (message.fps){
         switch (message.fps){
        case 1: timeDown(&videoIn);
        break;
        case 2: timeUp(&videoIn);
        break;
        }
        ack = 1;
        } else if (message.sleepon){
        if(fd){
          switch (message.sleepon){
          case 1:
           wakeup = !wakeup; //1;
          break;
          case 2:
          cmd = 1;
          break;
          }
        }
        ack = 1;
         } else ack =0;

redo:
       while ((frameout == videoIn.frame_cour) && videoIn.signalquit) usleep(1000);
       if (videoIn.signalquit)
       {
               videoIn.framelock[frameout]++;
              headerframe = (struct frame_t *) videoIn.ptframe[frameout];
              headerframe->acknowledge = ack;
               headerframe->bright = bright;
               headerframe->contrast = contrast;
               headerframe->wakeup = wakeup;
               if(headerframe->size == 0)
               {

               videoIn.framelock[frameout]--;
                frameout = (frameout+1)% OUTFRMNUMB;
                 goto redo;
               }

               write_sock(sock, (unsigned char *)headerframe, sizeof(struct frame_t)) ;
               write_sock(sock,(unsigned char*)(videoIn.ptframe[frameout]+sizeof(struct frame_t)),headerframe->size);
               videoIn.framelock[frameout]--;
               frameout = (frameout+1)% OUTFRMNUMB;
                close_sock(sock);
                pthread_exit(NULL);

   }
}