Subversion Repositories pentevo

Rev

Rev 905 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed | ?url?

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <errno.h>
  4. #include <unistd.h>
  5.  
  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <arpa/inet.h>
  9.  
  10. #if defined(_MSC_VER)
  11. #include "SDL.h"
  12. #else
  13. #include "SDL/SDL.h"
  14. #endif
  15.  
  16. SDL_Surface *plane;
  17.  
  18.  
  19. void net_init(void);
  20. void net_recv(void);
  21. void parse_recv_data(char * buf,int bytes_read);
  22. void bufrender(void);
  23.  
  24. void render(void);
  25.  
  26. void exitt(int);
  27.  
  28. #define SIZEX 896
  29. #define SIZEY 640
  30. #define BITSIZE 32
  31.  
  32. #define ZXSIZEX 1792
  33. #define ZXSIZEY 320
  34.  
  35. char zxbuf[ZXSIZEX*ZXSIZEY*4];
  36.  
  37.  
  38. // Entry point
  39. int main(int argc, char *argv[])
  40. {
  41.         // Initialize SDL's subsystems - in this case, only video.
  42.         if ( SDL_Init(SDL_INIT_VIDEO) < 0 )
  43.         {
  44.                 fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
  45.                 exit(1);
  46.         }
  47.  
  48.         // Register SDL_Quit to be called at exit; makes sure things are
  49.         // cleaned up when we quit.
  50.         atexit(SDL_Quit);
  51.    
  52.         // Attempt to create a window with 32bit pixels.
  53.         plane = SDL_SetVideoMode(SIZEX, SIZEY, BITSIZE, SDL_SWSURFACE);
  54.  
  55.         // If we fail, return error.
  56.         if ( plane == NULL )
  57.         {
  58.                 fprintf(stderr, "Unable to set 896x640 video: %s\n", SDL_GetError());
  59.                 exit(1);
  60.         }
  61.  
  62.        
  63.         net_init();  
  64.  
  65.  
  66.         // Main loop: loop forever.
  67.         while (1)
  68.         {
  69.                 net_recv();
  70.  
  71.                 render();
  72.  
  73.                 // Poll for events, and handle the ones we care about.
  74.                 SDL_Event event;
  75.                 while (SDL_PollEvent(&event))
  76.                 {
  77.                         switch (event.type)
  78.                         {
  79.                         case SDL_KEYDOWN:
  80.                                 break;
  81.                         case SDL_KEYUP:
  82.                                 // If escape is pressed, return (and thus, quit)
  83.                                 if (event.key.keysym.sym == SDLK_ESCAPE)
  84.                                         return 0;
  85.                                 break;
  86.                         case SDL_QUIT:
  87.                                 return(0);
  88.                         }
  89.                 }
  90.         }
  91.         return 0;
  92. }
  93.  
  94.  
  95.  
  96.  
  97.  
  98.  
  99. int sock=(-1), listener=(-1);
  100. struct sockaddr_in addr;
  101.  
  102.  
  103.  
  104.  
  105. void net_init(void)
  106. {
  107.         listener = socket(AF_INET, SOCK_STREAM, 0);
  108.         if(listener < 0)
  109.         {
  110.                 perror("socket init error");
  111.                 exit(1);
  112.         }
  113.        
  114.         int tr=1;
  115.        
  116.         setsockopt(listener,SOL_SOCKET,SO_REUSEADDR,&tr,sizeof(int));
  117.    
  118.         addr.sin_family = AF_INET;
  119.         addr.sin_port = htons(12345);
  120.         addr.sin_addr.s_addr = htonl(INADDR_ANY);
  121.         if(bind(listener, (struct sockaddr *)&addr, sizeof(addr)) < 0)
  122.         {
  123.                 perror("bind error");
  124.                 exit(2);
  125.         }
  126.  
  127.         listen(listener, 1);
  128.    
  129.         sock = accept(listener, NULL, NULL);
  130.         if(sock < 0)
  131.         {
  132.                 perror("accept error");
  133.                 exitt(3);
  134.         }
  135. }
  136.  
  137.  
  138.  
  139.  
  140.  
  141. void net_recv(void)
  142. {
  143. #define BUFSIZE 10240
  144.         char buf[BUFSIZE];
  145.  
  146.        
  147.         int bytes_read;
  148.  
  149.  
  150.  
  151.         bytes_read = recv(sock,buf,BUFSIZE, MSG_DONTWAIT);
  152. //      bytes_read = recv(sock,buf,BUFSIZE, 0);
  153.  
  154.         if( bytes_read<0 )
  155.         {
  156.                 if( ! ((errno==EAGAIN) || (errno==EWOULDBLOCK)) )
  157.                 {
  158.                         printf("recv failed - error %d!\n",errno);
  159.                         exitt(1);
  160.                 }
  161.         }
  162.         else if( bytes_read==0 )
  163.         {
  164.                 printf("recv failed - closed! errno=%d\n",errno);
  165.                 exitt(1);
  166.         }
  167.         else // >0
  168.         {
  169.                 parse_recv_data(buf,bytes_read);
  170.         }
  171.  
  172. //      if( 4!=sscanf(buf,"%X<=%X:%X with %X",&addr,&dat_hi,&dat_lo,&sel) )
  173. }
  174.  
  175.  
  176.  
  177.  
  178.  
  179. void parse_recv_data(char * buf,int bytes_read)
  180. {
  181. #define PBUF_SIZE 63
  182.         char pbuf[PBUF_SIZE+1];
  183.  
  184.         static int parsed = 0;
  185.  
  186.  
  187.         int i;
  188.         char c;
  189.         char r,g,b;
  190.         char * pix;
  191.  
  192.         int xcoord,ycoord,color;
  193.  
  194.  
  195.         i=0;
  196.  
  197.         while( bytes_read>0 )
  198.         {
  199.                 c = *(buf++);
  200.  
  201.                 if(c=='\n')
  202.                 {
  203.                         pbuf[parsed]=0;
  204.                         parsed=0;
  205.  
  206.                         if( (*pbuf)=='p' )
  207.                         {
  208.                                 //printf("%s\n",pbuf+1);
  209.  
  210.                                 if( 3==sscanf(pbuf+1,"%X,%X,%X",&xcoord,&ycoord,&color) )
  211.                                 {
  212.                                         if( (0<=xcoord)&&(xcoord<ZXSIZEX)&&
  213.                                             (0<=ycoord)&&(ycoord<ZXSIZEY) )
  214.                                         {
  215.                                                 pix = zxbuf + ( xcoord*4 + (ycoord*ZXSIZEX*4) );
  216.                                                
  217.                                                 r = (color<<2);
  218.                                                 g = (color<<4);
  219.                                                 b = (color<<6);
  220.  
  221.                                                 r &= 0xC0;
  222.                                                 g &= 0xC0;
  223.                                                 b &= 0xC0;
  224.  
  225.                                                 r |= r>>2;
  226.                                                 g |= g>>2;
  227.                                                 b |= b>>2;
  228.  
  229.                                                 r |= r>>4;
  230.                                                 g |= g>>4;
  231.                                                 b |= b>>4;
  232.  
  233.                                                 *(pix+0) = b;
  234.                                                 *(pix+1) = g;
  235.                                                 *(pix+2) = r;
  236.                                         }
  237.                                 }
  238.                         }
  239.                 }
  240.                 else
  241.                 {
  242.                         if(parsed>=PBUF_SIZE)
  243.                         {
  244.                                 printf("too long string in network data!\n");
  245.                                 exitt(1);
  246.                         }
  247.                         pbuf[parsed++]=c;
  248.                 }
  249.  
  250.                 bytes_read--;
  251.         }
  252. }
  253.  
  254.  
  255.  
  256.  
  257.  
  258. void bufrender(void)
  259. {
  260.  
  261.         int bx,by;
  262.  
  263.         int * la1, * la2;
  264.  
  265.         unsigned char * za;
  266.  
  267.         int r,g,b;
  268.         int value;
  269.  
  270.  
  271.         for(by=0;by<ZXSIZEY;by++)
  272.         {
  273.                 la1 = ((int *)plane->pixels) + by*((plane->pitch)>>2)*2;
  274.                 la2 = la1 + ((plane->pitch)>>2);
  275.  
  276.                 za = (unsigned char *)zxbuf + (by*ZXSIZEX*4);
  277.  
  278.                 for(bx=0;bx<(ZXSIZEX/2);bx++)
  279.                 {
  280.                         r = *(za+2);
  281.                         g = *(za+1);
  282.                         b = *(za+0);
  283.  
  284.                         r += *(za+6);
  285.                         g += *(za+5);
  286.                         b += *(za+4);
  287.  
  288.                         r <<= 15;
  289.                         g <<= 7;
  290.                         b >>= 1;
  291.  
  292.                         r &= 0x00FF0000;
  293.                         g &= 0x0000FF00;
  294.                         b &= 0x000000FF;
  295.  
  296.                         za += 8;
  297.  
  298.                         value = r|g|b;
  299.  
  300.                         *(la1++) = value;
  301.                         *(la2++) = value;
  302.                 }
  303.         }
  304. }
  305.  
  306.  
  307.  
  308.  
  309.  
  310.  
  311.  
  312.  
  313.  
  314.  
  315. void render()
  316. {  
  317.         // Lock surface if needed
  318.         if( SDL_MUSTLOCK(plane) )
  319.                 if (SDL_LockSurface(plane) < 0)
  320.                         return;
  321.  
  322.         // Ask SDL for the time in milliseconds
  323.         int tick = SDL_GetTicks();
  324.  
  325.         // Unlock if needed
  326.         if( SDL_MUSTLOCK(plane) )
  327.                 SDL_UnlockSurface(plane);
  328.  
  329.         //render picture
  330.         bufrender();
  331.  
  332.         // Tell SDL to update the whole plane
  333.         SDL_UpdateRect(plane, 0, 0, SIZEX, SIZEY);
  334. }
  335.  
  336.  
  337.  
  338.  
  339.  
  340.  
  341.  
  342.  
  343. void exitt(int a)
  344. {
  345.  
  346.         if( sock>=0 ) close(sock);
  347.  
  348.         if( listener>=0 ) close(listener);
  349.  
  350.         exit(a);
  351.  
  352.  
  353.  
  354.  
  355.  
  356. }
  357.  
  358.