BlinkenLib

1) /* BlinkenLib

2)  * version 0.5.1 date 2005-12-14

3)  * Copyright 2004-2005 Stefan Schuermans <1stein@schuermans.info>

4)  * Copyleft: GNU public license - http://www.gnu.org/copyleft/gpl.html
5)  * a blinkenarea.org project
6)  */
7) 
8) #include <stdio.h>
9) #include <stdlib.h>
10) #include <string.h>

11) #include <stdint.h>
12) #include <netinet/in.h>

13) 
14) #include "BlinkenConstants.h"
15) #include "BlinkenFrame.h"
16) #include "Tools.h"
17) 
18) struct sBlinkenFrame
19) {
20)   int height;
21)   int width;
22)   int channels;
23)   int maxval;
24)   int duration;

25)   unsigned char * * ppData;

26) };
27) 

28) //blinken protocol headers
29) typedef struct sBlinkenProtoBlpHdr
30) {
31)   uint32_t magic;
32)   uint32_t frameNo;
33)   uint16_t width;
34)   uint16_t height;
35) } stBlinkenProtoBlpHdr;
36) #define BlinkenProtoBlpMagic 0xDEADBEEF
37) typedef struct sBlinkenProtoEblpHdr
38) {
39)   uint32_t magic;
40)   uint32_t frameNo;
41)   uint16_t width;
42)   uint16_t height;
43) } stBlinkenProtoEblpHdr;
44) #define BlinkenProtoEblpMagic 0xFEEDBEEF
45) typedef struct sBlinkenProtoMcufHdr
46) {
47)   uint32_t magic;
48)   uint16_t height;
49)   uint16_t width;
50)   uint16_t channels;
51)   uint16_t maxval;
52) } stBlinkenProtoMcufHdr;
53) #define BlinkenProtoMcufMagic 0x23542666
54) 

55) stBlinkenFrame * BlinkenFrameNew( int height, int width, int channels, int maxval, int duration )
56) {
57)   stBlinkenFrame * pFrame;
58) 
59)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
60)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
61)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
62)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
63)   if( channels < BlinkenChannelsMin ) channels = BlinkenChannelsMin;
64)   if( channels > BlinkenChannelsMax ) channels = BlinkenMaxvalMax;
65)   if( maxval < BlinkenMaxvalMin ) maxval = BlinkenMaxvalMin;
66)   if( maxval > BlinkenMaxvalMax ) maxval = BlinkenMaxvalMax;
67)   if( duration < BlinkenDurationMin ) duration = BlinkenDurationMin;
68)   if( duration > BlinkenDurationMax ) duration = BlinkenDurationMax;
69) 
70)   pFrame = (stBlinkenFrame *)malloc( sizeof( stBlinkenFrame ) );
71)   if( pFrame == NULL )
72)     return NULL;
73) 
74)   pFrame->height = height;
75)   pFrame->width = width;
76)   pFrame->channels = channels;
77)   pFrame->maxval = maxval;
78)   pFrame->duration = duration;
79) 

80)   pFrame->ppData = (unsigned char * *)malloc2D( height, width * channels, sizeof( unsigned char ) );
81)   if( pFrame->ppData == NULL )

82)   {
83)     free( pFrame );
84)     return NULL;
85)   }
86) 
87)   return pFrame;
88) }
89) 
90) stBlinkenFrame * BlinkenFrameClone( stBlinkenFrame * pSrcFrame )
91) {

92)   int y, x, c, i;

93)   stBlinkenFrame * pFrame;
94) 
95)   if( pSrcFrame == NULL )
96)     return NULL;
97) 
98)   pFrame = BlinkenFrameNew( pSrcFrame->height, pSrcFrame->width,
99)                             pSrcFrame->channels, pSrcFrame->maxval, pSrcFrame->duration );
100)   if( pFrame == NULL )
101)     return NULL;
102) 
103)   for( y = 0; y < pFrame->height; y++ )

104)     for( x = 0, i = 0; x < pFrame->width; x++ )
105)       for( c = 0; c < pFrame->channels; c++, i++ )
106)         pFrame->ppData[y][i] = pSrcFrame->ppData[y][i];

107) 
108)   return pFrame;
109) }
110) 
111) void BlinkenFrameFree( stBlinkenFrame * pFrame )
112) {
113)   if( pFrame == NULL )
114)     return;
115) 

116)   free( pFrame->ppData );

117)   free( pFrame );
118) }
119) 
120) void BlinkenFrameClear( stBlinkenFrame * pFrame )
121) {

122)   int y, x, c, i;

123) 
124)   if( pFrame == NULL )
125)     return;
126) 
127)   for( y = 0; y < pFrame->height; y++ )

128)     for( x = 0, i = 0; x < pFrame->width; x++ )
129)       for( c = 0; c < pFrame->channels; c++, i++ )
130)         pFrame->ppData[y][i] = 0;

131) }
132) 
133) int BlinkenFrameGetHeight( stBlinkenFrame * pFrame )
134) {
135)   if( pFrame == NULL )
136)     return 0;
137) 
138)   return pFrame->height;
139) }
140) 
141) int BlinkenFrameGetWidth( stBlinkenFrame * pFrame )
142) {
143)   if( pFrame == NULL )
144)     return 0;
145) 
146)   return pFrame->width;
147) }
148) 
149) int BlinkenFrameGetChannels( stBlinkenFrame * pFrame )
150) {
151)   if( pFrame == NULL )
152)     return 0;
153) 
154)   return pFrame->channels;
155) }
156) 
157) int BlinkenFrameGetMaxval( stBlinkenFrame * pFrame )
158) {
159)   if( pFrame == NULL )
160)     return 0;
161) 
162)   return pFrame->maxval;
163) }
164) 
165) int BlinkenFrameGetDuration( stBlinkenFrame * pFrame )
166) {
167)   if( pFrame == NULL )
168)     return 0;
169) 
170)   return pFrame->duration;
171) }
172) 
173) void BlinkenFrameSetDuration( stBlinkenFrame * pFrame, int duration )
174) {
175)   if( pFrame == NULL )
176)     return;
177) 
178)   if( duration < BlinkenDurationMin ) duration = BlinkenDurationMin;
179)   if( duration > BlinkenDurationMax ) duration = BlinkenDurationMax;
180) 
181)   pFrame->duration = duration;
182) }
183) 
184) unsigned char BlinkenFrameGetPixel( stBlinkenFrame * pFrame, int y, int x, int c )
185) {
186)   if( pFrame == NULL ||
187)       y < 0 || y >= pFrame->height ||
188)       x < 0 || x >= pFrame->width ||
189)       c < 0 || c >= pFrame->channels )
190)       return 0;
191) 

192)   return pFrame->ppData[y][x * pFrame->channels + c];

193) }
194) 
195) void BlinkenFrameSetPixel( stBlinkenFrame * pFrame, int y, int x, int c, unsigned char val )
196) {
197)   if( pFrame == NULL ||
198)       y < 0 || y >= pFrame->height ||
199)       x < 0 || x >= pFrame->width ||
200)       c < 0 || c >= pFrame->channels )
201)       return;
202) 
203)   if( val > pFrame->maxval )
204)     val = pFrame->maxval;

205)   pFrame->ppData[y][x * pFrame->channels + c] = val;

206) }
207) 
208) unsigned long BlinkenFrameGetColor( stBlinkenFrame * pFrame, int y, int x )
209) {
210)   if( pFrame == NULL ||
211)       y < 0 || y >= pFrame->height ||
212)       x < 0 || x >= pFrame->width )
213)       return 0;
214) 

215)   int i = x * pFrame->channels;
216) 

217)   if( pFrame->channels == 1 )

218)     return (((unsigned long)pFrame->ppData[y][i + 0] * 255 + pFrame->maxval / 2) / pFrame->maxval) << 16 |
219)            (((unsigned long)pFrame->ppData[y][i + 0] * 255 + pFrame->maxval / 2) / pFrame->maxval) << 8 |
220)            (((unsigned long)pFrame->ppData[y][i + 0] * 255 + pFrame->maxval / 2) / pFrame->maxval);

221)   if( pFrame->channels == 2 )

222)     return (((unsigned long)pFrame->ppData[y][i + 0] * 255 + pFrame->maxval / 2) / pFrame->maxval) << 16 |
223)            (((unsigned long)pFrame->ppData[y][i + 1] * 255 + pFrame->maxval / 2) / pFrame->maxval) << 8;
224)   return (((unsigned long)pFrame->ppData[y][i + 0] * 255 + pFrame->maxval / 2) / pFrame->maxval) << 16 |
225)          (((unsigned long)pFrame->ppData[y][i + 1] * 255 + pFrame->maxval / 2) / pFrame->maxval) << 8 |
226)          (((unsigned long)pFrame->ppData[y][i + 2] * 255 + pFrame->maxval / 2) / pFrame->maxval);

227) }
228) 
229) void BlinkenFrameSetColor( stBlinkenFrame * pFrame, int y, int x, unsigned long color )
230) {
231)   int alpha, alpha_, c;
232) 
233)   if( pFrame == NULL ||
234)       y < 0 || y >= pFrame->height ||
235)       x < 0 || x >= pFrame->width )
236)       return;
237) 

238)   int i = x * pFrame->channels;
239) 

240)   alpha = (color >> 24) & 0xFF;
241)   alpha_ = 255 - alpha;
242)   if( pFrame->channels >= 1 )

243)     pFrame->ppData[y][i + 0] = (unsigned char)(( ((((color >> 16) & 0xFF) * pFrame->maxval + 127) / 255) * alpha
244)                                                + (unsigned long)pFrame->ppData[y][i + 0] * alpha_

245)                                                ) / 255);
246)   if( pFrame->channels >= 2 )

247)     pFrame->ppData[y][i + 1] = (unsigned char)(( ((((color >> 8) & 0xFF) * pFrame->maxval + 127) / 255) * alpha
248)                                                + (unsigned long)pFrame->ppData[y][i + 1] * alpha_

249)                                                ) / 255);
250)   if( pFrame->channels >= 3 )

251)     pFrame->ppData[y][i + 2] = (unsigned char)(( (((color & 0xFF) * pFrame->maxval + 127) / 255) * alpha
252)                                                + (unsigned long)pFrame->ppData[y][i + 2] * alpha_

253)                                                ) / 255);
254)   for( c = 3; c < pFrame->channels; c++ )

255)     pFrame->ppData[y][i + c] = (unsigned char)(( 0
256)                                                + (unsigned long)pFrame->ppData[y][i + c] * alpha_

257)                                                ) / 255);
258) }
259) 
260) void BlinkenFrameResize( stBlinkenFrame * pFrame, int height, int width, int channels, int maxval )
261) {

262)   unsigned char * * ppData;
263)   int y, x, c, i, j;

264)   int emptyY, emptyX, skipY, skipX, rangeY, rangeX;
265)   unsigned long val, div;
266) 
267)   if( pFrame == NULL )
268)     return;
269) 
270)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
271)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
272)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
273)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
274)   if( channels < BlinkenChannelsMin ) channels = BlinkenChannelsMin;
275)   if( channels > BlinkenChannelsMax ) channels = BlinkenMaxvalMax;
276)   if( maxval < BlinkenMaxvalMin ) maxval = BlinkenMaxvalMin;
277)   if( maxval > BlinkenMaxvalMax ) maxval = BlinkenMaxvalMax;
278) 
279)   if( height == pFrame->height &&
280)       width == pFrame->width &&
281)       channels == pFrame->channels &&
282)       maxval == pFrame->maxval )
283)     return;
284) 
285)   //allocate new data array

286)   ppData = (unsigned char * *)malloc2D( height, width * channels, sizeof( unsigned char ) );
287)   if( ppData == NULL )

288)     return;
289)   for( y = 0; y < height; y++ )

290)     for( x = 0, i = 0; x < width; x++ )
291)       for( c = 0; c < channels; c++, i++ )
292)         ppData[y][i] = 0;

293) 
294)   //get number of pixels to skip / to leave empty in X and Y direction
295)   if( height > pFrame->height )
296)   {
297)     emptyY = (height - pFrame->height) / 2; 
298)     skipY = 0;
299)     rangeY = pFrame->height;
300)   }
301)   else
302)   {
303)     emptyY = 0;
304)     skipY = (pFrame->height - height) / 2;
305)     rangeY = height;
306)   }
307)   if( width > pFrame->width )
308)   {
309)     emptyX = (width - pFrame->width) / 2; 
310)     skipX = 0;
311)     rangeX = pFrame->width;
312)   }
313)   else
314)   {
315)     emptyX = 0;
316)     skipX = (pFrame->width - width) / 2;
317)     rangeX = width;
318)   }
319) 
320)   //resize frame with help of calculated parameters
321)   for( y = 0; y < rangeY; y++ )
322)   {
323)     for( x = 0; x < rangeX; x++ )
324)     {

325)       i = (skipX + x) * pFrame->channels;
326)       j = (emptyX + x) * channels;

327)       if( channels >= pFrame->channels ) //add channels: copy last channel into new channels
328)       {

329)         for( c = 0; c < pFrame->channels; c++, i++, j++ )
330)           ppData[emptyY + y][j] = (unsigned char)(((unsigned long)pFrame->ppData[skipY + y][i] * maxval + pFrame->maxval / 2) / pFrame->maxval);
331)         for( ; c < channels; c++, j++ )
332)           ppData[emptyY + y][j] = ppData[emptyY + y][j - 1];

333)       }
334)       else //remove channels: merge leftover channels with last kept channel
335)       {
336)         val = 0;

337)         for( c = 0; c < channels - 1; c++, i++, j++ )
338)           ppData[emptyY + y][j] = (unsigned char)(((unsigned long)pFrame->ppData[skipY + y][i] * maxval + pFrame->maxval / 2) / pFrame->maxval);
339)         for( c = channels - 1; c < pFrame->channels; c++, i++ )
340)           val += (unsigned long)pFrame->ppData[skipY + y][i];

341)         div = pFrame->maxval * (pFrame->channels - channels + 1);

342)         ppData[emptyY + y][j++] = (unsigned char)((val * maxval + div / 2) / div);

343)       }
344)     }
345)   }
346) 
347)   pFrame->height = height;
348)   pFrame->width = width;
349)   pFrame->channels = channels;
350)   pFrame->maxval = maxval;

351)   free( pFrame->ppData );
352)   pFrame->ppData = ppData;

353) }
354) 
355) void BlinkenFrameScale( stBlinkenFrame * pFrame, int height, int width )
356) {

357)   unsigned char * * ppData;

358)   double scaleHor, scaleVer, ox, oy, ox1, oy1, val;

359)   int chans, c, nx, ny, x, y, oxi, oyi, ox1i, oy1i;

360) 
361)   if( pFrame == NULL )
362)     return;
363) 
364)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
365)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
366)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
367)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
368) 
369)   if( height == pFrame->height &&
370)       width == pFrame->width )
371)     return;
372) 
373)   scaleHor = (double)width / (double)pFrame->width;
374)   scaleVer = (double)height / (double)pFrame->height;
375) 
376)   //allocate new data array

377)   ppData = (unsigned char * *)malloc2D( height, width * pFrame->channels, sizeof( unsigned char ) );
378)   if( ppData == NULL )

379)     return;
380) 
381)   //scale every channel

382)   chans = pFrame->channels;
383)   for( c = 0; c < chans; c++ )

384)   {
385)     for( ny = 0; ny < height; ny++ )
386)     {
387)       for( nx = 0; nx < width; nx++ )
388)       {
389)         oy = (double)ny / scaleVer; //sub-pixel exact range in old picture
390)         ox = (double)nx / scaleHor;
391)         oy1 = (double)(ny + 1) / scaleVer - 0.000001;
392)         ox1 = (double)(nx + 1) / scaleHor - 0.000001;
393)         if( oy < 0 || ox < 0 || oy1 >= pFrame->height || ox1 >= pFrame->width) //out of old picture

394)           ppData[ny][nx * chans + c] = 0;

395)         else
396)         {
397)           oyi = (int)oy;
398)           oxi = (int)ox;
399)           oy1i = (int)oy1;
400)           ox1i = (int)ox1;
401)           if( oyi == oy1i )
402)           {
403)             if( oxi == ox1i) //one source pixel
404)             {

405)               val = (double)pFrame->ppData[oyi][oxi * chans + c];

406)             }
407)             else //one line of source pixels
408)             {

409)               val = (double)pFrame->ppData[oyi][oxi * chans + c] * (1 - ox + oxi)
410)                   + (double)pFrame->ppData[oyi][ox1i * chans + c] * (ox1 - ox1i);

411)               for( x = oxi + 1; x < ox1i; x++ )

412)                 val += (double)pFrame->ppData[oyi][x * chans + c];

413)               val /= ox1 - ox;
414)             }
415)           }
416)           else //one column of source pixels
417)           {
418)             if( oxi == ox1i )
419)             {

420)               val = (double)pFrame->ppData[oyi][oxi * chans + c] * (1 - oy + oyi)
421)                   + (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 - oy1i);

422)               for( y = oyi + 1; y < oy1i; y++ )

423)                 val += (double)pFrame->ppData[y][oxi * chans + c];

424)               val /= oy1 - oy;
425)             }
426)             else //rectangle of source pixels
427)             {

428)               val = (double)pFrame->ppData[oyi][oxi* chans + c] * (1 - oy + oyi) * (1 - ox + oxi)
429)                   + (double)pFrame->ppData[oyi][ox1i * chans + c] * (1 - oy + oyi) * (ox1 - ox1i)
430)                   + (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 - oy1i) * (1 - ox + oxi)
431)                   + (double)pFrame->ppData[oy1i][ox1i * chans + c] * (oy1 - oy1i) * (ox1 - ox1i);

432)               for( y = oyi + 1; y < oy1i; y++ )
433)               {

434)                 val += (double)pFrame->ppData[y][oxi * chans + c] * (1 - ox + oxi)
435)                      + (double)pFrame->ppData[y][ox1i * chans + c] * (ox1 - ox1i);

436)               }
437)               for( x = oxi + 1; x < ox1i; x++ )
438)               {

439)                 val += (double)pFrame->ppData[oyi][x * chans + c] * (1 - oy + oyi)
440)                      + (double)pFrame->ppData[oy1i][x * chans + c] * (oy1 - oy1i);

441)               }
442)               for( y = oyi + 1; y < oy1i; y++ )
443)                 for( x = oxi + 1; x < ox1i; x++ )

444)                   val += (double)pFrame->ppData[y][x * chans + c];

445)               val /= (oy1 - oy) * (ox1 - ox);
446)             }
447)           }

448)           ppData[ny][nx * chans + c] = (unsigned char)(val + 0.5);

449)         }
450)       } //for( nx ...
451)     } //for( ny ...
452)   } //for( c ...
453) 
454)   pFrame->height = height;
455)   pFrame->width = width;

456)   free( pFrame->ppData );
457)   pFrame->ppData = ppData;

458) }
459) 
460) char * BlinkenFrameToString( stBlinkenFrame * pFrame )
461) {

462)   int size, y, x, c, i;

463)   char * str, * ptr;
464)   unsigned long val;
465) 
466)   if( pFrame == NULL )
467)     return NULL;
468) 
469)   size = pFrame->height * (pFrame->width + 1) + 32;
470) 
471)   str = (char *)malloc( size );
472)   if( str == NULL )
473)     return NULL;
474) 
475)   ptr = str;
476)   
477)   for( y = 0; y < pFrame->height; y++ )
478)   {

479)     for( x = 0, i = 0; x < pFrame->width; x++ )

480)     {
481)       val = 0;

482)       for( val = 0, c = 0; c < pFrame->channels; c++, i++ )
483)         val += pFrame->ppData[y][i];

484)       val = val * 7 / pFrame->maxval / pFrame->channels;
485)       *ptr = " -+*%#&@"[val];
486)       ptr++;
487)     }
488)     *ptr = '\n';
489)     ptr++;
490)   }
491) 
492)   sprintf( ptr, "%u ms\n", pFrame->duration );
493) 
494)   return str;
495) }
496) 

497) int BlinkenFrameToNetwork( stBlinkenFrame * pFrame, etBlinkenProto proto, char * pData, int maxLength )
498) //returns length or -1 on error
499) {

500)   int y, x, c, i, j, val;

501) 
502)   if( pFrame == NULL )
503)     return -1;
504) 
505)   switch( proto )
506)   {
507) 
508)     case BlinkenProtoNone:
509)       return 0;
510) 
511)     case BlinkenProtoBlp:
512)       if( maxLength < (int)sizeof( stBlinkenProtoBlpHdr ) + pFrame->height * pFrame->width ) //buffer too short
513)         return -1;
514)       ((stBlinkenProtoBlpHdr *)pData)->magic = htonl( BlinkenProtoBlpMagic ); //build header
515)       ((stBlinkenProtoBlpHdr *)pData)->frameNo = htonl( 0 );
516)       ((stBlinkenProtoBlpHdr *)pData)->width = htons( pFrame->width );
517)       ((stBlinkenProtoBlpHdr *)pData)->height = htons( pFrame->height );
518)       i = sizeof( stBlinkenProtoBlpHdr ); //put data into packet
519)       for( y = 0; y < pFrame->height; y++ )
520)       {

521)         for( x = 0, j = 0; x < pFrame->width; x++, i++ )

522)         {
523)            val = 0;

524)            for( c = 0; c < pFrame->channels; c++, j++ )
525)              val += pFrame->ppData[y][j];

526)            pData[i] = (val >= pFrame->channels * pFrame->maxval / 2 ? 0x01 : 0x00);
527)         }
528)       }
529)       return i; //return length
530) 
531)     case BlinkenProtoEblp:
532)       if( maxLength < (int)sizeof( stBlinkenProtoEblpHdr ) + pFrame->height * pFrame->width ) //buffer too short
533)         return -1;
534)       ((stBlinkenProtoEblpHdr *)pData)->magic = htonl( BlinkenProtoEblpMagic ); //build header
535)       ((stBlinkenProtoEblpHdr *)pData)->frameNo = htonl( 0 );
536)       ((stBlinkenProtoEblpHdr *)pData)->width = htons( pFrame->width );
537)       ((stBlinkenProtoEblpHdr *)pData)->height = htons( pFrame->height );
538)       i = sizeof( stBlinkenProtoEblpHdr ); //put data into packet
539)       for( y = 0; y < pFrame->height; y++ )
540)       {

541)         for( x = 0, j = 0; x < pFrame->width; x++, i++ )

542)         {
543)            val = 0;

544)            for( c = 0; c < pFrame->channels; c++, j++ )
545)              val += pFrame->ppData[y][j];

546)            val /= pFrame->channels;
547)            pData[i] = (pFrame->maxval == 255 ? (unsigned char)val
548)                                              : (unsigned char)((val * 255 + pFrame->maxval / 2) / pFrame->maxval));
549)         }
550)       }
551)       return i; //return length
552) 
553)     case BlinkenProtoMcuf:
554)       if( maxLength < (int)sizeof( stBlinkenProtoMcufHdr ) + pFrame->height * pFrame->width * pFrame->channels ) //buffer too short
555)         return -1;
556)       ((stBlinkenProtoMcufHdr *)pData)->magic = htonl( BlinkenProtoMcufMagic ); //build header
557)       ((stBlinkenProtoMcufHdr *)pData)->height = htons( pFrame->height );
558)       ((stBlinkenProtoMcufHdr *)pData)->width = htons( pFrame->width );
559)       ((stBlinkenProtoMcufHdr *)pData)->channels = htons( pFrame->channels );
560)       ((stBlinkenProtoMcufHdr *)pData)->maxval = htons( pFrame->maxval );
561)       i = sizeof( stBlinkenProtoMcufHdr ); //put data into packet
562)       for( y = 0; y < pFrame->height; y++ )

563)         for( x = 0, j = 0; x < pFrame->width; x++ )
564)            for( c = 0; c < pFrame->channels; c++, i++, j++ )
565)              pData[i] = pFrame->ppData[y][j];

566)       return i; //return length
567) 
568)     default:
569)       return -1;
570) 
571)   }
572) }
573) 
574) stBlinkenFrame * BlinkenFrameFromNetwork( char * pData, int length, etBlinkenProto * pProto )
575) //returns protocol in *pProto if pProto not NULL
576) {
577)   stBlinkenFrame * pFrame;

578)   int height, width, channels, maxval, y, x, c, i, j;

579) 
580)   if( length >= (int)sizeof( stBlinkenProtoBlpHdr ) &&
581)       ((stBlinkenProtoBlpHdr *)pData)->magic == htonl( BlinkenProtoBlpMagic ) )
582)   {
583)     if( pProto != NULL ) //return protocol
584)       *pProto = BlinkenProtoBlp;
585)     height = ntohs( ((stBlinkenProtoBlpHdr *)pData)->height ); //get header data
586)     width = ntohs( ((stBlinkenProtoBlpHdr *)pData)->width );
587)     if( length < (int)sizeof( stBlinkenProtoBlpHdr ) + height * width ) //check length of packet
588)       return NULL;
589)     if( height < BlinkenHeightMin || height > BlinkenHeightMax || //check header data
590)         width < BlinkenWidthMin || width > BlinkenWidthMax )
591)       return NULL;
592)     pFrame = BlinkenFrameNew( height, width, 1, 1, 0 ); //create frame according to header data
593)     if( pFrame == NULL )
594)       return NULL;

595)     i = sizeof( stBlinkenProtoBlpHdr ); //put data into frame

596)     for( y = 0; y < pFrame->height; y++ )
597)       for( x = 0; x < pFrame->width; x++, i++ )

598)         pFrame->ppData[y][x * 1 + 0] = pData[i];

599)     return pFrame;
600)   }
601) 
602)   if( length >= (int)sizeof( stBlinkenProtoEblpHdr ) &&
603)       ((stBlinkenProtoEblpHdr *)pData)->magic == htonl( BlinkenProtoEblpMagic ) )
604)   {
605)     if( pProto != NULL ) //return protocol
606)       *pProto = BlinkenProtoEblp;
607)     height = ntohs( ((stBlinkenProtoEblpHdr *)pData)->height ); //get header data
608)     width = ntohs( ((stBlinkenProtoEblpHdr *)pData)->width );
609)     if( length < (int)sizeof( stBlinkenProtoEblpHdr ) + width * height ) //check length of packet
610)       return NULL;
611)     if( height < BlinkenHeightMin || height > BlinkenHeightMax || //check header data
612)         width < BlinkenWidthMin || width > BlinkenWidthMax )
613)       return NULL;
614)     pFrame = BlinkenFrameNew( height, width, 1, 255, 0 ); //create frame according to header data
615)     if( pFrame == NULL )
616)       return NULL;
617)     i = sizeof( stBlinkenProtoEblpHdr ); //put data into frame
618)     for( y = 0; y < pFrame->height; y++ )
619)       for( x = 0; x < pFrame->width; x++, i++ )

620)         pFrame->ppData[y][x * 1 + 0] = pData[i];

621)     return pFrame;
622)   }
623) 
624)   if( length >= (int)sizeof( stBlinkenProtoMcufHdr ) &&
625)       ((stBlinkenProtoMcufHdr *)pData)->magic == htonl( BlinkenProtoMcufMagic ) )
626)   {
627)     if( pProto != NULL ) //return protocol
628)       *pProto = BlinkenProtoMcuf;
629)     height = ntohs( ((stBlinkenProtoMcufHdr *)pData)->height ); //get header data
630)     width = ntohs( ((stBlinkenProtoMcufHdr *)pData)->width );
631)     channels = ntohs( ((stBlinkenProtoMcufHdr *)pData)->channels );
632)     maxval = ntohs( ((stBlinkenProtoMcufHdr *)pData)->maxval );
633)     if( length < (int)sizeof( stBlinkenProtoMcufHdr ) + height * width * channels ) //check length of packet
634)       return NULL;
635)     if( height < BlinkenHeightMin || height > BlinkenHeightMax || //check header data
636)         width < BlinkenWidthMin || width > BlinkenWidthMax ||
637)         channels < BlinkenChannelsMin || channels > BlinkenChannelsMax ||
638)         maxval < BlinkenMaxvalMin || maxval > BlinkenMaxvalMax )
639)       return NULL;
640)     pFrame = BlinkenFrameNew( height, width, channels, maxval, 0 ); //create frame according to header data
641)     if( pFrame == NULL )
642)       return NULL;
643)     i = sizeof( stBlinkenProtoMcufHdr ); //put data into frame
644)     for( y = 0; y < pFrame->height; y++ )

645)       for( x = 0, j = 0; x < pFrame->width; x++ )
646)         for( c = 0; c < pFrame->channels; c++, i++, j++ )
647)           pFrame->ppData[y][j] = pData[i];