BlinkenLib

1) /* BlinkenLib

2)  * version 0.5.4 date 2008-01-10
3)  * Copyright 2004-2008 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) int BlinkenFrameCompare( stBlinkenFrame * pFrame1, stBlinkenFrame * pFrame2 )
271) //returns -1 for frame1 smaller, 0 for equal, 1 for frame2 smaller
272) {
273)   int y, cmp;
274) 
275)   if( pFrame1->height < pFrame2->height )
276)     return -1;
277)   if( pFrame1->height > pFrame2->height )
278)     return 1;
279)   if( pFrame1->width < pFrame2->width )
280)     return -1;
281)   if( pFrame1->width > pFrame2->width )
282)     return 1;
283)   if( pFrame1->channels < pFrame2->channels )
284)     return -1;
285)   if( pFrame1->channels > pFrame2->channels )
286)     return 1;
287)   if( pFrame1->maxval < pFrame2->maxval )
288)     return -1;
289)   if( pFrame1->maxval > pFrame2->maxval )
290)     return 1;
291) 
292)   for( y = 0; y < pFrame1->height; y++ ) {
293)     cmp = memcmp( pFrame1->ppData[y], pFrame2->ppData[y], pFrame1->width * pFrame2->channels );
294)     if( cmp != 0 )
295)       return cmp;
296)   }
297) 
298)   return 0;
299) }
300) 

301) void BlinkenFrameResize( stBlinkenFrame * pFrame, int height, int width, int channels, int maxval )
302) {

303)   unsigned char * * ppData;
304)   int y, x, c, i, j;

305)   int emptyY, emptyX, skipY, skipX, rangeY, rangeX;
306)   unsigned long val, div;
307) 
308)   if( pFrame == NULL )
309)     return;
310) 
311)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
312)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
313)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
314)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
315)   if( channels < BlinkenChannelsMin ) channels = BlinkenChannelsMin;
316)   if( channels > BlinkenChannelsMax ) channels = BlinkenMaxvalMax;
317)   if( maxval < BlinkenMaxvalMin ) maxval = BlinkenMaxvalMin;
318)   if( maxval > BlinkenMaxvalMax ) maxval = BlinkenMaxvalMax;
319) 
320)   if( height == pFrame->height &&
321)       width == pFrame->width &&
322)       channels == pFrame->channels &&
323)       maxval == pFrame->maxval )
324)     return;
325) 
326)   //allocate new data array

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

329)     return;
330)   for( y = 0; y < height; y++ )

331)     for( x = 0, i = 0; x < width; x++ )
332)       for( c = 0; c < channels; c++, i++ )
333)         ppData[y][i] = 0;

334) 
335)   //get number of pixels to skip / to leave empty in X and Y direction
336)   if( height > pFrame->height )
337)   {
338)     emptyY = (height - pFrame->height) / 2; 
339)     skipY = 0;
340)     rangeY = pFrame->height;
341)   }
342)   else
343)   {
344)     emptyY = 0;
345)     skipY = (pFrame->height - height) / 2;
346)     rangeY = height;
347)   }
348)   if( width > pFrame->width )
349)   {
350)     emptyX = (width - pFrame->width) / 2; 
351)     skipX = 0;
352)     rangeX = pFrame->width;
353)   }
354)   else
355)   {
356)     emptyX = 0;
357)     skipX = (pFrame->width - width) / 2;
358)     rangeX = width;
359)   }
360) 
361)   //resize frame with help of calculated parameters
362)   for( y = 0; y < rangeY; y++ )
363)   {
364)     for( x = 0; x < rangeX; x++ )
365)     {

366)       i = (skipX + x) * pFrame->channels;
367)       j = (emptyX + x) * channels;

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

370)         for( c = 0; c < pFrame->channels; c++, i++, j++ )
371)           ppData[emptyY + y][j] = (unsigned char)(((unsigned long)pFrame->ppData[skipY + y][i] * maxval + pFrame->maxval / 2) / pFrame->maxval);
372)         for( ; c < channels; c++, j++ )
373)           ppData[emptyY + y][j] = ppData[emptyY + y][j - 1];

374)       }
375)       else //remove channels: merge leftover channels with last kept channel
376)       {
377)         val = 0;

378)         for( c = 0; c < channels - 1; c++, i++, j++ )
379)           ppData[emptyY + y][j] = (unsigned char)(((unsigned long)pFrame->ppData[skipY + y][i] * maxval + pFrame->maxval / 2) / pFrame->maxval);
380)         for( c = channels - 1; c < pFrame->channels; c++, i++ )
381)           val += (unsigned long)pFrame->ppData[skipY + y][i];

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

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

384)       }
385)     }
386)   }
387) 
388)   pFrame->height = height;
389)   pFrame->width = width;
390)   pFrame->channels = channels;
391)   pFrame->maxval = maxval;

392)   free( pFrame->ppData );
393)   pFrame->ppData = ppData;

394) }
395) 
396) void BlinkenFrameScale( stBlinkenFrame * pFrame, int height, int width )
397) {

398)   unsigned char * * ppData;

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

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

401) 
402)   if( pFrame == NULL )
403)     return;
404) 
405)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
406)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
407)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
408)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
409) 
410)   if( height == pFrame->height &&
411)       width == pFrame->width )
412)     return;
413) 
414)   scaleHor = (double)width / (double)pFrame->width;
415)   scaleVer = (double)height / (double)pFrame->height;
416) 
417)   //allocate new data array

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

420)     return;
421) 
422)   //scale every channel

423)   chans = pFrame->channels;
424)   for( c = 0; c < chans; c++ )

425)   {
426)     for( ny = 0; ny < height; ny++ )
427)     {
428)       for( nx = 0; nx < width; nx++ )
429)       {
430)         oy = (double)ny / scaleVer; //sub-pixel exact range in old picture
431)         ox = (double)nx / scaleHor;
432)         oy1 = (double)(ny + 1) / scaleVer - 0.000001;
433)         ox1 = (double)(nx + 1) / scaleHor - 0.000001;
434)         if( oy < 0 || ox < 0 || oy1 >= pFrame->height || ox1 >= pFrame->width) //out of old picture

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

436)         else
437)         {
438)           oyi = (int)oy;
439)           oxi = (int)ox;
440)           oy1i = (int)oy1;
441)           ox1i = (int)ox1;
442)           if( oyi == oy1i )
443)           {
444)             if( oxi == ox1i) //one source pixel
445)             {

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

447)             }
448)             else //one line of source pixels
449)             {

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

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

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

454)               val /= ox1 - ox;
455)             }
456)           }
457)           else //one column of source pixels
458)           {
459)             if( oxi == ox1i )
460)             {

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

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

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

465)               val /= oy1 - oy;
466)             }
467)             else //rectangle of source pixels
468)             {

469)               val = (double)pFrame->ppData[oyi][oxi* chans + c] * (1 - oy + oyi) * (1 - ox + oxi)
470)                   + (double)pFrame->ppData[oyi][ox1i * chans + c] * (1 - oy + oyi) * (ox1 - ox1i)
471)                   + (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 - oy1i) * (1 - ox + oxi)
472)                   + (double)pFrame->ppData[oy1i][ox1i * chans + c] * (oy1 - oy1i) * (ox1 - ox1i);

473)               for( y = oyi + 1; y < oy1i; y++ )
474)               {

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

477)               }
478)               for( x = oxi + 1; x < ox1i; x++ )
479)               {

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

482)               }
483)               for( y = oyi + 1; y < oy1i; y++ )
484)                 for( x = oxi + 1; x < ox1i; x++ )

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

486)               val /= (oy1 - oy) * (ox1 - ox);
487)             }
488)           }

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

490)         }
491)       } //for( nx ...
492)     } //for( ny ...
493)   } //for( c ...
494) 
495)   pFrame->height = height;
496)   pFrame->width = width;

497)   free( pFrame->ppData );
498)   pFrame->ppData = ppData;

499) }
500) 

501) void BlinkenFrameColorize( stBlinkenFrame * pFrame, int channels, int mode, int step )
502) {
503)   unsigned char * * ppData;
504)   int y, x, c, i, j;
505)   unsigned int val;
506) 
507)   if( pFrame == NULL )
508)     return;
509) 
510)   if( channels < BlinkenChannelsMin ) channels = BlinkenChannelsMin;
511)   if( channels > BlinkenChannelsMax ) channels = BlinkenMaxvalMax;
512) 
513)   //allocate new data array
514)   ppData = (unsigned char * *)malloc2D( pFrame->height, pFrame->width * channels, sizeof( unsigned char ) );
515)   if( ppData == NULL )
516)     return;
517)   for( y = 0; y < pFrame->height; y++ )
518)     for( x = 0, i = 0; x < pFrame->width; x++ )
519)       for( c = 0; c < channels; c++, i++ )
520)         ppData[y][i] = 0;
521) 
522)   //colorize frame
523)   for( y = 0; y < pFrame->height; y++ )
524)   {
525)     for( x = 0; x < pFrame->width; x++ )
526)     {
527)       i = x * pFrame->channels;
528)       //merge channels
529)       val = 0;
530)       for( c = 0; c < pFrame->channels; c++, i++ )
531)         val += pFrame->ppData[y][i];
532)       val = (val + pFrame->channels / 2) / pFrame->channels;
533)       val = (val * BlinkenMaxvalMax + pFrame->maxval / 2) / pFrame->maxval;
534)       //colorize
535)       j = x * channels;
536)       for( c = 0; c < channels; c++, j++ ) {
537)         int color = BlinkenColorizerGetColor( channels, mode, step, y, x, c );
538)         ppData[y][j] = (unsigned char)((val * color + 127) / 255);
539)       }
540)     }
541)   }
542) 
543)   pFrame->channels = channels;
544)   pFrame->maxval = BlinkenMaxvalMax;
545)   free( pFrame->ppData );
546)   pFrame->ppData = ppData;
547) }
548) 

549) char * BlinkenFrameToString( stBlinkenFrame * pFrame )
550) {

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

552)   char * str, * ptr;
553)   unsigned long val;
554) 
555)   if( pFrame == NULL )
556)     return NULL;
557) 
558)   size = pFrame->height * (pFrame->width + 1) + 32;
559) 
560)   str = (char *)malloc( size );
561)   if( str == NULL )
562)     return NULL;
563) 
564)   ptr = str;
565)   
566)   for( y = 0; y < pFrame->height; y++ )
567)   {

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

569)     {
570)       val = 0;

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

573)       val = val * 7 / pFrame->maxval / pFrame->channels;
574)       *ptr = " -+*%#&@"[val];
575)       ptr++;
576)     }
577)     *ptr = '\n';
578)     ptr++;
579)   }
580) 
581)   sprintf( ptr, "%u ms\n", pFrame->duration );
582) 
583)   return str;
584) }
585) 

586) int BlinkenFrameToNetwork( stBlinkenFrame * pFrame, etBlinkenProto proto, char * pData, int maxLength )
587) //returns length or -1 on error
588) {

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

590) 
591)   if( pFrame == NULL )
592)     return -1;
593) 
594)   switch( proto )
595)   {
596) 
597)     case BlinkenProtoNone:
598)       return 0;
599) 
600)     case BlinkenProtoBlp:
601)       if( maxLength < (int)sizeof( stBlinkenProtoBlpHdr ) + pFrame->height * pFrame->width ) //buffer too short
602)         return -1;
603)       ((stBlinkenProtoBlpHdr *)pData)->magic = htonl( BlinkenProtoBlpMagic ); //build header
604)       ((stBlinkenProtoBlpHdr *)pData)->frameNo = htonl( 0 );

605)       ((stBlinkenProtoBlpHdr *)pData)->width = htons( (uint16_t)pFrame->width );
606)       ((stBlinkenProtoBlpHdr *)pData)->height = htons( (uint16_t)pFrame->height );

607)       i = sizeof( stBlinkenProtoBlpHdr ); //put data into packet
608)       for( y = 0; y < pFrame->height; y++ )
609)       {

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

611)         {
612)            val = 0;

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

615)            pData[i] = (val >= pFrame->channels * pFrame->maxval / 2 ? 0x01 : 0x00);
616)         }
617)       }
618)       return i; //return length
619) 
620)     case BlinkenProtoEblp:
621)       if( maxLength < (int)sizeof( stBlinkenProtoEblpHdr ) + pFrame->height * pFrame->width ) //buffer too short
622)         return -1;
623)       ((stBlinkenProtoEblpHdr *)pData)->magic = htonl( BlinkenProtoEblpMagic ); //build header
624)       ((stBlinkenProtoEblpHdr *)pData)->frameNo = htonl( 0 );

625)       ((stBlinkenProtoEblpHdr *)pData)->width = htons( (uint16_t)pFrame->width );
626)       ((stBlinkenProtoEblpHdr *)pData)->height = htons( (uint16_t)pFrame->height );

627)       i = sizeof( stBlinkenProtoEblpHdr ); //put data into packet
628)       for( y = 0; y < pFrame->height; y++ )
629)       {

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

631)         {
632)            val = 0;

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

635)            val /= pFrame->channels;
636)            pData[i] = (pFrame->maxval == 255 ? (unsigned char)val
637)                                              : (unsigned char)((val * 255 + pFrame->maxval / 2) / pFrame->maxval));
638)         }
639)       }
640)       return i; //return length
641) 
642)     case BlinkenProtoMcuf:
643)       if( maxLength < (int)sizeof( stBlinkenProtoMcufHdr ) + pFrame->height * pFrame->width * pFrame->channels ) //buffer too short
644)         return -1;
645)       ((stBlinkenProtoMcufHdr *)pData)->magic = htonl( BlinkenProtoMcufMagic ); //build header

646)       ((stBlinkenProtoMcufHdr *)pData)->height = htons( (uint16_t)pFrame->height );
647)       ((stBlinkenProtoMcufHdr *)pData)->width = htons( (uint16_t)pFrame->width );
648)       ((stBlinkenProtoMcufHdr *)pData)->channels = htons( (uint16_t)pFrame->channels );
649)       ((stBlinkenProtoMcufHdr *)pData)->maxval = htons( (uint16_t)pFrame->maxval );

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

652)         for( x = 0, j = 0; x < pFrame->width; x++ )
653)            for( c = 0; c < pFrame->channels; c++, i++, j++ )
654)              pData[i] = pFrame->ppData[y][j];

655)       return i; //return length
656) 
657)     default:
658)       return -1;
659) 
660)   }
661) }
662) 
663) stBlinkenFrame * BlinkenFrameFromNetwork( char * pData, int length, etBlinkenProto * pProto )
664) //returns protocol in *pProto if pProto not NULL
665) {
666)   stBlinkenFrame * pFrame;

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

668) 
669)   if( length >= (int)sizeof( stBlinkenProtoBlpHdr ) &&
670)       ((stBlinkenProtoBlpHdr *)pData)->magic == htonl( BlinkenProtoBlpMagic ) )
671)   {
672)     if( pProto != NULL ) //return protocol
673)       *pProto = BlinkenProtoBlp;
674)     height = ntohs( ((stBlinkenProtoBlpHdr *)pData)->height ); //get header data
675)     width = ntohs( ((stBlinkenProtoBlpHdr *)pData)->width );
676)     if( length < (int)sizeof( stBlinkenProtoBlpHdr ) + height * width ) //check length of packet
677)       return NULL;
678)     if( height < BlinkenHeightMin || height > BlinkenHeightMax || //check header data
679)         width < BlinkenWidthMin || width > BlinkenWidthMax )
680)       return NULL;
681)     pFrame = BlinkenFrameNew( height, width, 1, 1, 0 ); //create frame according to header data
682)     if( pFrame == NULL )
683)       return NULL;

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

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

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

688)     return pFrame;
689)   }
690) 
691)   if( length >= (int)sizeof( stBlinkenProtoEblpHdr ) &&
692)       ((stBlinkenProtoEblpHdr *)pData)->magic == htonl( BlinkenProtoEblpMagic ) )
693)   {
694)     if( pProto != NULL ) //return protocol
695)       *pProto = BlinkenProtoEblp;
696)     height = ntohs( ((stBlinkenProtoEblpHdr *)pData)->height ); //get header data
697)     width = ntohs( ((stBlinkenProtoEblpHdr *)pData)->width );
698)     if( length < (int)sizeof( stBlinkenProtoEblpHdr ) + width * height ) //check length of packet
699)       return NULL;
700)     if( height < BlinkenHeightMin || height > BlinkenHeightMax || //check header data
701)         width < BlinkenWidthMin || width > BlinkenWidthMax )
702)       return NULL;
703)     pFrame = BlinkenFrameNew( height, width, 1, 255, 0 ); //create frame according to header data
704)     if( pFrame == NULL )
705)       return NULL;
706)     i = sizeof( stBlinkenProtoEblpHdr ); //put data into frame
707)     for( y = 0; y < pFrame->height; y++ )
708)       for( x = 0; x < pFrame->width; x++, i++ )

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

710)     return pFrame;
711)   }
712) 
713)   if( length >= (int)sizeof( stBlinkenProtoMcufHdr ) &&
714)       ((stBlinkenProtoMcufHdr *)pData)->magic == htonl( BlinkenProtoMcufMagic ) )
715)   {
716)     if( pProto != NULL ) //return protocol
717)       *pProto = BlinkenProtoMcuf;
718)     height = ntohs( ((stBlinkenProtoMcufHdr *)pData)->height ); //get header data
719)     width = ntohs( ((stBlinkenProtoMcufHdr *)pData)->width );
720)     channels = ntohs( ((stBlinkenProtoMcufHdr *)pData)->channels );
721)     maxval = ntohs( ((stBlinkenProtoMcufHdr *)pData)->maxval );
722)     if( length < (int)sizeof( stBlinkenProtoMcufHdr ) + height * width * channels ) //check length of packet
723)       return NULL;
724)     if( height < BlinkenHeightMin || height > BlinkenHeightMax || //check header data
725)         width < BlinkenWidthMin || width > BlinkenWidthMax ||
726)         channels < BlinkenChannelsMin || channels > BlinkenChannelsMax ||
727)         maxval < BlinkenMaxvalMin || maxval > BlinkenMaxvalMax )
728)       return NULL;
729)     pFrame = BlinkenFrameNew( height, width, channels, maxval, 0 ); //create frame according to header data
730)     if( pFrame == NULL )
731)       return NULL;
732)     i = sizeof( stBlinkenProtoMcufHdr ); //put data into frame
733)     for( y = 0; y < pFrame->height; y++ )

734)       for( x = 0, j = 0; x < pFrame->width; x++ )
735)         for( c = 0; c < pFrame->channels; c++, i++, j++ )
736)           pFrame->ppData[y][j] = pData[i];