BlinkenLib

1) /* BlinkenLib

2)  * version 0.4.1 date 2005-12-05

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)  * powered by eventphone.de
7)  */
8) 
9) #include <stdio.h>
10) #include <stdlib.h>
11) #include <string.h>

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

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

26)   unsigned char * * ppData;

27) };
28) 

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

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

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

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

93)   int y, x, c, i;

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

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

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

117)   free( pFrame->ppData );

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

123)   int y, x, c, i;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

358)   unsigned char * * ppData;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

481)     {
482)       val = 0;

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

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

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

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

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

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

523)         {
524)            val = 0;

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

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

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

543)         {
544)            val = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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