BlinkenLib

1) /* BlinkenLib

2)  * version 0.5.3 date 2007-12-28
3)  * Copyright 2004-2007 Stefan Schuermans <stefan@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) #ifdef WIN32
12) #include <winsock2.h>
13) #include <windows.h>
14) typedef WORD uint16_t;
15) typedef DWORD uint32_t;
16) #else

17) #include <stdint.h>
18) #include <netinet/in.h>

19) #endif

20) 
21) #include "BlinkenConstants.h"

22) #include "BlinkenColorizer.h"

23) #include "BlinkenFrame.h"
24) #include "Tools.h"
25) 
26) struct sBlinkenFrame
27) {
28)   int height;
29)   int width;
30)   int channels;
31)   int maxval;
32)   int duration;

33)   unsigned char * * ppData;

34) };
35) 

36) //blinken protocol headers
37) typedef struct sBlinkenProtoBlpHdr
38) {
39)   uint32_t magic;
40)   uint32_t frameNo;
41)   uint16_t width;
42)   uint16_t height;
43) } stBlinkenProtoBlpHdr;
44) #define BlinkenProtoBlpMagic 0xDEADBEEF
45) typedef struct sBlinkenProtoEblpHdr
46) {
47)   uint32_t magic;
48)   uint32_t frameNo;
49)   uint16_t width;
50)   uint16_t height;
51) } stBlinkenProtoEblpHdr;
52) #define BlinkenProtoEblpMagic 0xFEEDBEEF
53) typedef struct sBlinkenProtoMcufHdr
54) {
55)   uint32_t magic;
56)   uint16_t height;
57)   uint16_t width;
58)   uint16_t channels;
59)   uint16_t maxval;
60) } stBlinkenProtoMcufHdr;
61) #define BlinkenProtoMcufMagic 0x23542666
62) 

63) stBlinkenFrame * BlinkenFrameNew( int height, int width, int channels, int maxval, int duration )
64) {
65)   stBlinkenFrame * pFrame;
66) 
67)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
68)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
69)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
70)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
71)   if( channels < BlinkenChannelsMin ) channels = BlinkenChannelsMin;
72)   if( channels > BlinkenChannelsMax ) channels = BlinkenMaxvalMax;
73)   if( maxval < BlinkenMaxvalMin ) maxval = BlinkenMaxvalMin;
74)   if( maxval > BlinkenMaxvalMax ) maxval = BlinkenMaxvalMax;
75)   if( duration < BlinkenDurationMin ) duration = BlinkenDurationMin;
76)   if( duration > BlinkenDurationMax ) duration = BlinkenDurationMax;
77) 
78)   pFrame = (stBlinkenFrame *)malloc( sizeof( stBlinkenFrame ) );
79)   if( pFrame == NULL )
80)     return NULL;
81) 
82)   pFrame->height = height;
83)   pFrame->width = width;
84)   pFrame->channels = channels;
85)   pFrame->maxval = maxval;
86)   pFrame->duration = duration;
87) 

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

90)   {
91)     free( pFrame );
92)     return NULL;
93)   }
94) 
95)   return pFrame;
96) }
97) 
98) stBlinkenFrame * BlinkenFrameClone( stBlinkenFrame * pSrcFrame )
99) {

100)   int y, x, c, i;

101)   stBlinkenFrame * pFrame;
102) 
103)   if( pSrcFrame == NULL )
104)     return NULL;
105) 
106)   pFrame = BlinkenFrameNew( pSrcFrame->height, pSrcFrame->width,
107)                             pSrcFrame->channels, pSrcFrame->maxval, pSrcFrame->duration );
108)   if( pFrame == NULL )
109)     return NULL;
110) 
111)   for( y = 0; y < pFrame->height; y++ )

112)     for( x = 0, i = 0; x < pFrame->width; x++ )
113)       for( c = 0; c < pFrame->channels; c++, i++ )
114)         pFrame->ppData[y][i] = pSrcFrame->ppData[y][i];

115) 
116)   return pFrame;
117) }
118) 
119) void BlinkenFrameFree( stBlinkenFrame * pFrame )
120) {
121)   if( pFrame == NULL )
122)     return;
123) 

124)   free( pFrame->ppData );

125)   free( pFrame );
126) }
127) 
128) void BlinkenFrameClear( stBlinkenFrame * pFrame )
129) {

130)   int y, x, c, i;

131) 
132)   if( pFrame == NULL )
133)     return;
134) 
135)   for( y = 0; y < pFrame->height; y++ )

136)     for( x = 0, i = 0; x < pFrame->width; x++ )
137)       for( c = 0; c < pFrame->channels; c++, i++ )
138)         pFrame->ppData[y][i] = 0;

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

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

201) }
202) 
203) void BlinkenFrameSetPixel( stBlinkenFrame * pFrame, int y, int x, int c, unsigned char val )
204) {
205)   if( pFrame == NULL ||
206)       y < 0 || y >= pFrame->height ||
207)       x < 0 || x >= pFrame->width ||
208)       c < 0 || c >= pFrame->channels )
209)       return;
210) 
211)   if( val > pFrame->maxval )
212)     val = pFrame->maxval;

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

214) }
215) 
216) unsigned long BlinkenFrameGetColor( stBlinkenFrame * pFrame, int y, int x )
217) {

218)   int i;
219) 

220)   if( pFrame == NULL ||
221)       y < 0 || y >= pFrame->height ||
222)       x < 0 || x >= pFrame->width )
223)       return 0;
224) 

225)   i = x * pFrame->channels;

226) 

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

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

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

232)     return (((unsigned long)pFrame->ppData[y][i + 0] * 255 + pFrame->maxval / 2) / pFrame->maxval) << 16 |
233)            (((unsigned long)pFrame->ppData[y][i + 1] * 255 + pFrame->maxval / 2) / pFrame->maxval) << 8;
234)   return (((unsigned long)pFrame->ppData[y][i + 0] * 255 + pFrame->maxval / 2) / pFrame->maxval) << 16 |
235)          (((unsigned long)pFrame->ppData[y][i + 1] * 255 + pFrame->maxval / 2) / pFrame->maxval) << 8 |
236)          (((unsigned long)pFrame->ppData[y][i + 2] * 255 + pFrame->maxval / 2) / pFrame->maxval);

237) }
238) 
239) void BlinkenFrameSetColor( stBlinkenFrame * pFrame, int y, int x, unsigned long color )
240) {

241)   int i, alpha, alpha_, c;

242) 
243)   if( pFrame == NULL ||
244)       y < 0 || y >= pFrame->height ||
245)       x < 0 || x >= pFrame->width )
246)       return;
247) 

248)   i = x * pFrame->channels;

249) 

250)   alpha = (color >> 24) & 0xFF;
251)   alpha_ = 255 - alpha;
252)   if( pFrame->channels >= 1 )

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

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

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

259)                                                ) / 255);
260)   if( pFrame->channels >= 3 )

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

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

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

267)                                                ) / 255);
268) }
269) 
270) void BlinkenFrameResize( stBlinkenFrame * pFrame, int height, int width, int channels, int maxval )
271) {

272)   unsigned char * * ppData;
273)   int y, x, c, i, j;

274)   int emptyY, emptyX, skipY, skipX, rangeY, rangeX;
275)   unsigned long val, div;
276) 
277)   if( pFrame == NULL )
278)     return;
279) 
280)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
281)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
282)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
283)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
284)   if( channels < BlinkenChannelsMin ) channels = BlinkenChannelsMin;
285)   if( channels > BlinkenChannelsMax ) channels = BlinkenMaxvalMax;
286)   if( maxval < BlinkenMaxvalMin ) maxval = BlinkenMaxvalMin;
287)   if( maxval > BlinkenMaxvalMax ) maxval = BlinkenMaxvalMax;
288) 
289)   if( height == pFrame->height &&
290)       width == pFrame->width &&
291)       channels == pFrame->channels &&
292)       maxval == pFrame->maxval )
293)     return;
294) 
295)   //allocate new data array

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

298)     return;
299)   for( y = 0; y < height; y++ )

300)     for( x = 0, i = 0; x < width; x++ )
301)       for( c = 0; c < channels; c++, i++ )
302)         ppData[y][i] = 0;

303) 
304)   //get number of pixels to skip / to leave empty in X and Y direction
305)   if( height > pFrame->height )
306)   {
307)     emptyY = (height - pFrame->height) / 2; 
308)     skipY = 0;
309)     rangeY = pFrame->height;
310)   }
311)   else
312)   {
313)     emptyY = 0;
314)     skipY = (pFrame->height - height) / 2;
315)     rangeY = height;
316)   }
317)   if( width > pFrame->width )
318)   {
319)     emptyX = (width - pFrame->width) / 2; 
320)     skipX = 0;
321)     rangeX = pFrame->width;
322)   }
323)   else
324)   {
325)     emptyX = 0;
326)     skipX = (pFrame->width - width) / 2;
327)     rangeX = width;
328)   }
329) 
330)   //resize frame with help of calculated parameters
331)   for( y = 0; y < rangeY; y++ )
332)   {
333)     for( x = 0; x < rangeX; x++ )
334)     {

335)       i = (skipX + x) * pFrame->channels;
336)       j = (emptyX + x) * channels;

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

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

343)       }
344)       else //remove channels: merge leftover channels with last kept channel
345)       {
346)         val = 0;

347)         for( c = 0; c < channels - 1; c++, i++, j++ )
348)           ppData[emptyY + y][j] = (unsigned char)(((unsigned long)pFrame->ppData[skipY + y][i] * maxval + pFrame->maxval / 2) / pFrame->maxval);
349)         for( c = channels - 1; c < pFrame->channels; c++, i++ )
350)           val += (unsigned long)pFrame->ppData[skipY + y][i];

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

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

353)       }
354)     }
355)   }
356) 
357)   pFrame->height = height;
358)   pFrame->width = width;
359)   pFrame->channels = channels;
360)   pFrame->maxval = maxval;

361)   free( pFrame->ppData );
362)   pFrame->ppData = ppData;

363) }
364) 
365) void BlinkenFrameScale( stBlinkenFrame * pFrame, int height, int width )
366) {

367)   unsigned char * * ppData;

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

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

370) 
371)   if( pFrame == NULL )
372)     return;
373) 
374)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
375)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
376)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
377)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
378) 
379)   if( height == pFrame->height &&
380)       width == pFrame->width )
381)     return;
382) 
383)   scaleHor = (double)width / (double)pFrame->width;
384)   scaleVer = (double)height / (double)pFrame->height;
385) 
386)   //allocate new data array

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

389)     return;
390) 
391)   //scale every channel

392)   chans = pFrame->channels;
393)   for( c = 0; c < chans; c++ )

394)   {
395)     for( ny = 0; ny < height; ny++ )
396)     {
397)       for( nx = 0; nx < width; nx++ )
398)       {
399)         oy = (double)ny / scaleVer; //sub-pixel exact range in old picture
400)         ox = (double)nx / scaleHor;
401)         oy1 = (double)(ny + 1) / scaleVer - 0.000001;
402)         ox1 = (double)(nx + 1) / scaleHor - 0.000001;
403)         if( oy < 0 || ox < 0 || oy1 >= pFrame->height || ox1 >= pFrame->width) //out of old picture

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

405)         else
406)         {
407)           oyi = (int)oy;
408)           oxi = (int)ox;
409)           oy1i = (int)oy1;
410)           ox1i = (int)ox1;
411)           if( oyi == oy1i )
412)           {
413)             if( oxi == ox1i) //one source pixel
414)             {

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

416)             }
417)             else //one line of source pixels
418)             {

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

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

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

423)               val /= ox1 - ox;
424)             }
425)           }
426)           else //one column of source pixels
427)           {
428)             if( oxi == ox1i )
429)             {

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

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

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

434)               val /= oy1 - oy;
435)             }
436)             else //rectangle of source pixels
437)             {

438)               val = (double)pFrame->ppData[oyi][oxi* chans + c] * (1 - oy + oyi) * (1 - ox + oxi)
439)                   + (double)pFrame->ppData[oyi][ox1i * chans + c] * (1 - oy + oyi) * (ox1 - ox1i)
440)                   + (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 - oy1i) * (1 - ox + oxi)
441)                   + (double)pFrame->ppData[oy1i][ox1i * chans + c] * (oy1 - oy1i) * (ox1 - ox1i);

442)               for( y = oyi + 1; y < oy1i; y++ )
443)               {

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

446)               }
447)               for( x = oxi + 1; x < ox1i; x++ )
448)               {

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

451)               }
452)               for( y = oyi + 1; y < oy1i; y++ )
453)                 for( x = oxi + 1; x < ox1i; x++ )

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

455)               val /= (oy1 - oy) * (ox1 - ox);
456)             }
457)           }

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

459)         }
460)       } //for( nx ...
461)     } //for( ny ...
462)   } //for( c ...
463) 
464)   pFrame->height = height;
465)   pFrame->width = width;

466)   free( pFrame->ppData );
467)   pFrame->ppData = ppData;

468) }
469) 

470) void BlinkenFrameColorize( stBlinkenFrame * pFrame, int channels, int mode, int step )
471) {
472)   unsigned char * * ppData;
473)   int y, x, c, i, j;
474)   unsigned int val;
475) 
476)   if( pFrame == NULL )
477)     return;
478) 
479)   if( channels < BlinkenChannelsMin ) channels = BlinkenChannelsMin;
480)   if( channels > BlinkenChannelsMax ) channels = BlinkenMaxvalMax;
481) 
482)   //allocate new data array
483)   ppData = (unsigned char * *)malloc2D( pFrame->height, pFrame->width * channels, sizeof( unsigned char ) );
484)   if( ppData == NULL )
485)     return;
486)   for( y = 0; y < pFrame->height; y++ )
487)     for( x = 0, i = 0; x < pFrame->width; x++ )
488)       for( c = 0; c < channels; c++, i++ )
489)         ppData[y][i] = 0;
490) 
491)   //colorize frame
492)   for( y = 0; y < pFrame->height; y++ )
493)   {
494)     for( x = 0; x < pFrame->width; x++ )
495)     {
496)       i = x * pFrame->channels;
497)       //merge channels
498)       val = 0;
499)       for( c = 0; c < pFrame->channels; c++, i++ )
500)         val += pFrame->ppData[y][i];
501)       val = (val + pFrame->channels / 2) / pFrame->channels;
502)       val = (val * BlinkenMaxvalMax + pFrame->maxval / 2) / pFrame->maxval;
503)       //colorize
504)       j = x * channels;
505)       for( c = 0; c < channels; c++, j++ ) {
506)         int color = BlinkenColorizerGetColor( channels, mode, step, y, x, c );
507)         ppData[y][j] = (unsigned char)((val * color + 127) / 255);
508)       }
509)     }
510)   }
511) 
512)   pFrame->channels = channels;
513)   pFrame->maxval = BlinkenMaxvalMax;
514)   free( pFrame->ppData );
515)   pFrame->ppData = ppData;
516) }
517) 

518) char * BlinkenFrameToString( stBlinkenFrame * pFrame )
519) {

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

521)   char * str, * ptr;
522)   unsigned long val;
523) 
524)   if( pFrame == NULL )
525)     return NULL;
526) 
527)   size = pFrame->height * (pFrame->width + 1) + 32;
528) 
529)   str = (char *)malloc( size );
530)   if( str == NULL )
531)     return NULL;
532) 
533)   ptr = str;
534)   
535)   for( y = 0; y < pFrame->height; y++ )
536)   {

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

538)     {
539)       val = 0;

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

542)       val = val * 7 / pFrame->maxval / pFrame->channels;
543)       *ptr = " -+*%#&@"[val];
544)       ptr++;
545)     }
546)     *ptr = '\n';
547)     ptr++;
548)   }
549) 
550)   sprintf( ptr, "%u ms\n", pFrame->duration );
551) 
552)   return str;
553) }
554) 

555) int BlinkenFrameToNetwork( stBlinkenFrame * pFrame, etBlinkenProto proto, char * pData, int maxLength )
556) //returns length or -1 on error
557) {

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

559) 
560)   if( pFrame == NULL )
561)     return -1;
562) 
563)   switch( proto )
564)   {
565) 
566)     case BlinkenProtoNone:
567)       return 0;
568) 
569)     case BlinkenProtoBlp:
570)       if( maxLength < (int)sizeof( stBlinkenProtoBlpHdr ) + pFrame->height * pFrame->width ) //buffer too short
571)         return -1;
572)       ((stBlinkenProtoBlpHdr *)pData)->magic = htonl( BlinkenProtoBlpMagic ); //build header
573)       ((stBlinkenProtoBlpHdr *)pData)->frameNo = htonl( 0 );

574)       ((stBlinkenProtoBlpHdr *)pData)->width = htons( (uint16_t)pFrame->width );
575)       ((stBlinkenProtoBlpHdr *)pData)->height = htons( (uint16_t)pFrame->height );

576)       i = sizeof( stBlinkenProtoBlpHdr ); //put data into packet
577)       for( y = 0; y < pFrame->height; y++ )
578)       {

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

580)         {
581)            val = 0;

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

584)            pData[i] = (val >= pFrame->channels * pFrame->maxval / 2 ? 0x01 : 0x00);
585)         }
586)       }
587)       return i; //return length
588) 
589)     case BlinkenProtoEblp:
590)       if( maxLength < (int)sizeof( stBlinkenProtoEblpHdr ) + pFrame->height * pFrame->width ) //buffer too short
591)         return -1;
592)       ((stBlinkenProtoEblpHdr *)pData)->magic = htonl( BlinkenProtoEblpMagic ); //build header
593)       ((stBlinkenProtoEblpHdr *)pData)->frameNo = htonl( 0 );

594)       ((stBlinkenProtoEblpHdr *)pData)->width = htons( (uint16_t)pFrame->width );
595)       ((stBlinkenProtoEblpHdr *)pData)->height = htons( (uint16_t)pFrame->height );

596)       i = sizeof( stBlinkenProtoEblpHdr ); //put data into packet
597)       for( y = 0; y < pFrame->height; y++ )
598)       {

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

600)         {
601)            val = 0;

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

604)            val /= pFrame->channels;
605)            pData[i] = (pFrame->maxval == 255 ? (unsigned char)val
606)                                              : (unsigned char)((val * 255 + pFrame->maxval / 2) / pFrame->maxval));
607)         }
608)       }
609)       return i; //return length
610) 
611)     case BlinkenProtoMcuf:
612)       if( maxLength < (int)sizeof( stBlinkenProtoMcufHdr ) + pFrame->height * pFrame->width * pFrame->channels ) //buffer too short
613)         return -1;
614)       ((stBlinkenProtoMcufHdr *)pData)->magic = htonl( BlinkenProtoMcufMagic ); //build header

615)       ((stBlinkenProtoMcufHdr *)pData)->height = htons( (uint16_t)pFrame->height );
616)       ((stBlinkenProtoMcufHdr *)pData)->width = htons( (uint16_t)pFrame->width );
617)       ((stBlinkenProtoMcufHdr *)pData)->channels = htons( (uint16_t)pFrame->channels );
618)       ((stBlinkenProtoMcufHdr *)pData)->maxval = htons( (uint16_t)pFrame->maxval );

619)       i = sizeof( stBlinkenProtoMcufHdr ); //put data into packet
620)       for( y = 0; y < pFrame->height; y++ )

621)         for( x = 0, j = 0; x < pFrame->width; x++ )
622)            for( c = 0; c < pFrame->channels; c++, i++, j++ )
623)              pData[i] = pFrame->ppData[y][j];

624)       return i; //return length
625) 
626)     default:
627)       return -1;
628) 
629)   }
630) }
631) 
632) stBlinkenFrame * BlinkenFrameFromNetwork( char * pData, int length, etBlinkenProto * pProto )
633) //returns protocol in *pProto if pProto not NULL
634) {
635)   stBlinkenFrame * pFrame;

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

637) 
638)   if( length >= (int)sizeof( stBlinkenProtoBlpHdr ) &&
639)       ((stBlinkenProtoBlpHdr *)pData)->magic == htonl( BlinkenProtoBlpMagic ) )
640)   {
641)     if( pProto != NULL ) //return protocol
642)       *pProto = BlinkenProtoBlp;
643)     height = ntohs( ((stBlinkenProtoBlpHdr *)pData)->height ); //get header data
644)     width = ntohs( ((stBlinkenProtoBlpHdr *)pData)->width );
645)     if( length < (int)sizeof( stBlinkenProtoBlpHdr ) + height * width ) //check length of packet
646)       return NULL;
647)     if( height < BlinkenHeightMin || height > BlinkenHeightMax || //check header data
648)         width < BlinkenWidthMin || width > BlinkenWidthMax )
649)       return NULL;
650)     pFrame = BlinkenFrameNew( height, width, 1, 1, 0 ); //create frame according to header data
651)     if( pFrame == NULL )
652)       return NULL;

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

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

656)         pFrame->ppData[y][x] = pData[i] ? 0x01 : 0x00;

657)     return pFrame;
658)   }
659) 
660)   if( length >= (int)sizeof( stBlinkenProtoEblpHdr ) &&
661)       ((stBlinkenProtoEblpHdr *)pData)->magic == htonl( BlinkenProtoEblpMagic ) )
662)   {
663)     if( pProto != NULL ) //return protocol
664)       *pProto = BlinkenProtoEblp;
665)     height = ntohs( ((stBlinkenProtoEblpHdr *)pData)->height ); //get header data
666)     width = ntohs( ((stBlinkenProtoEblpHdr *)pData)->width );
667)     if( length < (int)sizeof( stBlinkenProtoEblpHdr ) + width * height ) //check length of packet
668)       return NULL;
669)     if( height < BlinkenHeightMin || height > BlinkenHeightMax || //check header data
670)         width < BlinkenWidthMin || width > BlinkenWidthMax )
671)       return NULL;
672)     pFrame = BlinkenFrameNew( height, width, 1, 255, 0 ); //create frame according to header data
673)     if( pFrame == NULL )
674)       return NULL;
675)     i = sizeof( stBlinkenProtoEblpHdr ); //put data into frame
676)     for( y = 0; y < pFrame->height; y++ )
677)       for( x = 0; x < pFrame->width; x++, i++ )

678)         pFrame->ppData[y][x] = pData[i];

679)     return pFrame;
680)   }
681) 
682)   if( length >= (int)sizeof( stBlinkenProtoMcufHdr ) &&
683)       ((stBlinkenProtoMcufHdr *)pData)->magic == htonl( BlinkenProtoMcufMagic ) )
684)   {
685)     if( pProto != NULL ) //return protocol
686)       *pProto = BlinkenProtoMcuf;
687)     height = ntohs( ((stBlinkenProtoMcufHdr *)pData)->height ); //get header data
688)     width = ntohs( ((stBlinkenProtoMcufHdr *)pData)->width );
689)     channels = ntohs( ((stBlinkenProtoMcufHdr *)pData)->channels );
690)     maxval = ntohs( ((stBlinkenProtoMcufHdr *)pData)->maxval );
691)     if( length < (int)sizeof( stBlinkenProtoMcufHdr ) + height * width * channels ) //check length of packet
692)       return NULL;
693)     if( height < BlinkenHeightMin || height > BlinkenHeightMax || //check header data
694)         width < BlinkenWidthMin || width > BlinkenWidthMax ||
695)         channels < BlinkenChannelsMin || channels > BlinkenChannelsMax ||
696)         maxval < BlinkenMaxvalMin || maxval > BlinkenMaxvalMax )
697)       return NULL;
698)     pFrame = BlinkenFrameNew( height, width, channels, maxval, 0 ); //create frame according to header data
699)     if( pFrame == NULL )
700)       return NULL;
701)     i = sizeof( stBlinkenProtoMcufHdr ); //put data into frame
702)     for( y = 0; y < pFrame->height; y++ )

703)       for( x = 0, j = 0; x < pFrame->width; x++ )
704)         for( c = 0; c < pFrame->channels; c++, i++, j++ )
705)           pFrame->ppData[y][j] = pData[i];