BlinkenLib

1) /* BlinkenLib

2)  * version 0.5.2 date 2006-05-10
3)  * Copyright 2004-2006 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) #ifdef WIN32
12) #include <winsock2.h>
13) #include <windows.h>
14) #else

15) #include <unistd.h>
16) #include <sys/time.h>
17) #include <sys/types.h>
18) #include <sys/socket.h>
19) #include <sys/select.h>

20) #endif

21) 
22) #include "BlinkenConstants.h"
23) #include "BlinkenFrame.h"
24) #include "BlinkenMovie.h"
25) #include "Tools.h"
26) 
27) struct sBlinkenMovie
28) {
29)   int height;
30)   int width;
31)   int channels;
32)   int maxval;
33)   int infoCnt;
34)   char * * * pppInfos;
35)   int frameCnt;
36)   stBlinkenFrame * * ppFrames;
37) };
38) 

39) #ifdef WIN32
40) 
41) static void msleep( unsigned int ms )
42) {
43)   Sleep( ms );
44) }
45) 
46) static unsigned int get_ms( )
47) {
48)   return GetTickCount( );
49) }
50) 
51) #else
52) 
53) static void msleep( unsigned int ms )
54) {
55)   usleep( ms * 1000 );
56) }
57) 
58) static unsigned int get_ms( )
59) {
60)   struct timeval tv;
61)   gettimeofday( &tv, NULL );
62)   return (unsigned int)(tv.tv_usec / 1000 + tv.tv_sec * 1000);
63) }
64) 
65) #endif
66) 

67) stBlinkenMovie * BlinkenMovieNew( int height, int width, int channels, int maxval )
68) {
69)   stBlinkenMovie * pMovie;
70) 
71)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
72)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
73)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
74)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
75)   if( channels < BlinkenChannelsMin ) channels = BlinkenChannelsMin;
76)   if( channels > BlinkenChannelsMax ) channels = BlinkenMaxvalMax;
77)   if( maxval < BlinkenMaxvalMin ) maxval = BlinkenMaxvalMin;
78)   if( maxval > BlinkenMaxvalMax ) maxval = BlinkenMaxvalMax;
79) 
80)   pMovie = (stBlinkenMovie *)malloc( sizeof( stBlinkenMovie ) );
81)   if( pMovie == NULL )
82)     return NULL;
83) 
84)   pMovie->height = height;
85)   pMovie->width = width;
86)   pMovie->channels = channels;
87)   pMovie->maxval = maxval;
88)   pMovie->infoCnt = 0;
89)   pMovie->pppInfos = (char * * *)malloc2D( 0, 2, sizeof( char * ) );
90)   if( pMovie->pppInfos == NULL )
91)   {
92)     free( pMovie );
93)     return NULL;
94)   }
95)   pMovie->frameCnt = 0;
96)   pMovie->ppFrames = (stBlinkenFrame * *)malloc1D( 0, sizeof( stBlinkenFrame * ) );
97)   if( pMovie->ppFrames == NULL )
98)   {
99)     free( pMovie->pppInfos );
100)     free( pMovie );
101)     return NULL;
102)   }
103) 
104)   return pMovie;
105) }
106) 
107) stBlinkenMovie * BlinkenMovieClone( stBlinkenMovie * pSrcMovie )
108) {
109)   stBlinkenMovie * pMovie;

110)   stBlinkenFrame * pFrame;

111)   int i;
112) 
113)   pMovie = BlinkenMovieNew( pSrcMovie->height, pSrcMovie->width, pSrcMovie->channels, pSrcMovie->maxval );
114)   if( pMovie == NULL )
115)     return NULL;
116) 
117)   for( i = 0; i < pSrcMovie->infoCnt; i++ )
118)     BlinkenMovieAppendInfo( pMovie, pSrcMovie->pppInfos[i][0], pSrcMovie->pppInfos[i][1] );
119) 
120)   for( i = 0; i < pSrcMovie->frameCnt; i++ )

121)   {
122)     pFrame = BlinkenFrameClone( pSrcMovie->ppFrames[i] );
123)     if( BlinkenMovieAppendFrame( pMovie, pFrame ) != 0 )
124)       BlinkenFrameFree( pFrame );
125)   }

126) 
127)   return pMovie;
128) }
129) 
130) void BlinkenMovieFree( stBlinkenMovie * pMovie )
131) {
132)   int i;
133) 
134)   if( pMovie == NULL )
135)     return;
136) 
137)   for( i = 0; i < pMovie->infoCnt; i++ )
138)   {
139)     free( pMovie->pppInfos[i][0] );
140)     free( pMovie->pppInfos[i][1] );
141)   }
142)   free( pMovie->pppInfos );
143) 
144)   for( i = 0; i < pMovie->frameCnt; i++ )
145)     BlinkenFrameFree( pMovie->ppFrames[i] );
146)   free( pMovie->ppFrames );
147) 
148)   free( pMovie );
149) }
150) 
151) int BlinkenMovieGetHeight( stBlinkenMovie * pMovie )
152) {
153)   if( pMovie == NULL )
154)     return 0;
155) 
156)   return pMovie->height;
157) }
158) 
159) int BlinkenMovieGetWidth( stBlinkenMovie * pMovie )
160) {
161)   if( pMovie == NULL )
162)     return 0;
163) 
164)   return pMovie->width;
165) }
166) 
167) int BlinkenMovieGetChannels( stBlinkenMovie * pMovie )
168) {
169)   if( pMovie == NULL )
170)     return 0;
171) 
172)   return pMovie->channels;
173) }
174) 
175) int BlinkenMovieGetMaxval( stBlinkenMovie * pMovie )
176) {
177)   if( pMovie == NULL )
178)     return 0;
179) 
180)   return pMovie->maxval;
181) }
182) 
183) int BlinkenMovieGetDuration( stBlinkenMovie * pMovie )
184) {
185)   int i, duration;
186) 
187)   if( pMovie == NULL )
188)     return 0;
189) 
190)   duration = 0;
191)   for( i = 0; i < pMovie->frameCnt; i++ )
192)     duration += BlinkenFrameGetDuration( pMovie->ppFrames[i] );
193)   return duration;
194) }
195) 
196) int BlinkenMovieGetInfoCnt( stBlinkenMovie * pMovie )
197) {
198)   if( pMovie == NULL )
199)     return 0;
200) 
201)   return pMovie->infoCnt;
202) }
203) 
204) char * BlinkenMovieGetInfoType( stBlinkenMovie * pMovie, int infoNo )
205) {
206)   if( pMovie == NULL || pMovie->infoCnt < 1 )
207)     return "";
208) 
209)   if( infoNo < 0 ) infoNo = 0;
210)   if( infoNo >= pMovie->infoCnt ) infoNo = pMovie->infoCnt - 1;
211)   return pMovie->pppInfos[infoNo][0];
212) }
213) 
214) char * BlinkenMovieGetInfoData( stBlinkenMovie * pMovie, int infoNo )
215) {
216)   if( pMovie == NULL || pMovie->infoCnt < 1 )
217)     return "";
218) 
219)   if( infoNo < 0 ) infoNo = 0;
220)   if( infoNo >= pMovie->infoCnt ) infoNo = pMovie->infoCnt - 1;
221)   return pMovie->pppInfos[infoNo][1];
222) }
223) 
224) void BlinkenMovieSetInfo( stBlinkenMovie * pMovie, int infoNo, char * pInfoType, char * pInfoData )
225) {
226)   char * pType, * pData;
227) 
228)   if( pMovie == NULL || infoNo < 0 || infoNo >= pMovie->infoCnt )
229)     return;
230) 
231)   pType = strdup( pInfoType );
232)   if( pType == NULL )
233)     return;
234)   pData = strdup( pInfoData );
235)   if( pData == NULL )
236)   {
237)     free( pType );
238)     return;
239)   }
240) 
241)   free( pMovie->pppInfos[infoNo][0] );
242)   pMovie->pppInfos[infoNo][0] = pType;
243)   free( pMovie->pppInfos[infoNo][1] );
244)   pMovie->pppInfos[infoNo][1] = pData;
245) }
246) 
247) void BlinkenMovieInsertInfo( stBlinkenMovie * pMovie, int infoNo, char * pInfoType, char * pInfoData )
248) {
249)   char * * * pppNewInfos, * pType, * pData;
250)   int i;
251) 
252)   if( pMovie == NULL || infoNo < 0 || infoNo > pMovie->infoCnt )
253)     return;
254) 
255)   pppNewInfos = (char * * *)malloc2D( pMovie->infoCnt + 1, 2, sizeof( char * ) );
256)   if( pppNewInfos == NULL )
257)     return;
258) 
259)   pType = strdup( pInfoType );
260)   if( pType == NULL )
261)   {
262)     free( pppNewInfos );
263)     return;
264)   }
265)   pData = strdup( pInfoData );
266)   if( pData == NULL )
267)   {
268)     free( pppNewInfos );
269)     free( pType );
270)     return;
271)   }
272) 
273)   for( i = 0; i < infoNo; i++ )
274)   {
275)     pppNewInfos[i][0] = pMovie->pppInfos[i][0];
276)     pppNewInfos[i][1] = pMovie->pppInfos[i][1];
277)   }
278) 
279)   pppNewInfos[infoNo][0] = pType;
280)   pppNewInfos[infoNo][1] = pData;
281) 
282)   for( i = infoNo; i < pMovie->infoCnt; i++ )
283)   {
284)     pppNewInfos[i+1][0] = pMovie->pppInfos[i][0];
285)     pppNewInfos[i+1][1] = pMovie->pppInfos[i][1];
286)   }
287) 
288)   free( pMovie->pppInfos );
289)   pMovie->pppInfos = pppNewInfos;
290)   pMovie->infoCnt++;
291) }
292) 
293) void BlinkenMovieAppendInfo( stBlinkenMovie * pMovie, char * pInfoType, char * pInfoData )
294) {
295)   if( pMovie == NULL )
296)     return;
297) 
298)   BlinkenMovieInsertInfo( pMovie, pMovie->infoCnt, pInfoType, pInfoData );
299) }
300) 
301) void BlinkenMovieDeleteInfo( stBlinkenMovie * pMovie, int infoNo )
302) {
303)   char * * * pppNewInfos;
304)   int i;
305) 
306)   if( pMovie == NULL || infoNo < 0 || infoNo >= pMovie->infoCnt )
307)     return;
308) 
309)   pppNewInfos = (char * * *)malloc2D( pMovie->infoCnt - 1, 2, sizeof( char * ) );
310)   if( pppNewInfos == NULL )
311)     return;
312) 
313)   for( i = 0; i < infoNo; i++ )
314)   {
315)     pppNewInfos[i][0] = pMovie->pppInfos[i][0];
316)     pppNewInfos[i][1] = pMovie->pppInfos[i][1];
317)   }
318) 
319)   free( pMovie->pppInfos[infoNo][0] );
320)   free( pMovie->pppInfos[infoNo][1] );
321) 
322)   for( i = infoNo; i < pMovie->infoCnt - 1; i++ )
323)   {
324)     pppNewInfos[i][0] = pMovie->pppInfos[i+1][0];
325)     pppNewInfos[i][1] = pMovie->pppInfos[i+1][1];
326)   }
327) 
328)   free( pMovie->pppInfos );
329)   pMovie->pppInfos = pppNewInfos;
330)   pMovie->infoCnt--;
331) }
332) 
333) void BlinkenMovieDeleteInfos( stBlinkenMovie * pMovie )
334) {
335)   char * * * pppNewInfos;
336)   int i;
337) 
338)   if( pMovie == NULL )
339)     return;
340) 
341)   pppNewInfos = (char * * *)malloc2D( 0, 2, sizeof( char * ) );
342)   if( pppNewInfos == NULL )
343)     return;
344) 
345)   for( i = 0; i < pMovie->infoCnt; i++ )
346)   {
347)     free( pMovie->pppInfos[i][0] );
348)     free( pMovie->pppInfos[i][1] );
349)   }
350) 
351)   free( pMovie->pppInfos );
352)   pMovie->pppInfos = pppNewInfos;
353)   pMovie->infoCnt = 0;
354) }
355) 
356) int BlinkenMovieGetFrameCnt( stBlinkenMovie * pMovie )
357) {
358)   if( pMovie == NULL )
359)     return 0;
360) 
361)   return pMovie->frameCnt;
362) }
363) 
364) stBlinkenFrame * BlinkenMovieGetFrame( stBlinkenMovie * pMovie, int frameNo )
365) {
366)   if( pMovie == NULL || pMovie->frameCnt < 1 )
367)     return NULL;
368) 
369)   if( frameNo < 0 ) frameNo = 0;
370)   if( frameNo >= pMovie->frameCnt ) frameNo = pMovie->frameCnt - 1;
371)   return pMovie->ppFrames[frameNo];
372) }
373) 
374) void BlinkenMovieSetFrame( stBlinkenMovie * pMovie, int frameNo, stBlinkenFrame * pFrame )
375) {
376)   if( pMovie == NULL || frameNo < 0 || frameNo >= pMovie->frameCnt )
377)     return;
378) 
379)   BlinkenFrameResize( pFrame, pMovie->height, pMovie->width, pMovie->channels, pMovie->maxval );
380)   pMovie->ppFrames[frameNo] = pFrame;
381) }
382) 

383) int BlinkenMovieInsertFrame( stBlinkenMovie * pMovie, int frameNo, stBlinkenFrame * pFrame )

384) {
385)   stBlinkenFrame * * ppNewFrames;
386)   int i;
387) 
388)   if( pMovie == NULL || frameNo < 0 || frameNo > pMovie->frameCnt )

389)     return -1;

390) 
391)   ppNewFrames = (stBlinkenFrame * *)malloc1D( pMovie->frameCnt + 1, sizeof( stBlinkenFrame * ) );
392)   if( ppNewFrames == NULL )

393)     return -1;

394) 
395)   for( i = 0; i < frameNo; i++ )
396)     ppNewFrames[i] = pMovie->ppFrames[i];
397) 
398)   BlinkenFrameResize( pFrame, pMovie->height, pMovie->width, pMovie->channels, pMovie->maxval );
399)   ppNewFrames[frameNo] = pFrame;
400) 
401)   for( i = frameNo; i < pMovie->frameCnt; i++ )
402)     ppNewFrames[i+1] = pMovie->ppFrames[i];
403) 
404)   free( pMovie->ppFrames );
405)   pMovie->ppFrames = ppNewFrames;
406)   pMovie->frameCnt++;

407)   return 0;

408) }
409) 

410) int BlinkenMovieAppendFrame( stBlinkenMovie * pMovie, stBlinkenFrame * pFrame )

411) {
412)   if( pMovie == NULL )

413)     return -1;

414) 

415)   return BlinkenMovieInsertFrame( pMovie, pMovie->frameCnt, pFrame );

416) }
417) 
418) void BlinkenMovieDeleteFrame( stBlinkenMovie * pMovie, int frameNo )
419) {
420)   stBlinkenFrame * * ppNewFrames;
421)   int i;
422) 
423)   if( pMovie == NULL || frameNo < 0 || frameNo >= pMovie->frameCnt )
424)     return;
425) 
426)   ppNewFrames = (stBlinkenFrame * *)malloc1D( pMovie->frameCnt - 1, sizeof( stBlinkenFrame * ) );
427)   if( ppNewFrames == NULL )
428)     return;
429) 
430)   for( i = 0; i < frameNo; i++ )
431)     ppNewFrames[i] = pMovie->ppFrames[i];
432) 
433)   BlinkenFrameFree( pMovie->ppFrames[frameNo] );
434) 
435)   for( i = frameNo; i < pMovie->frameCnt - 1; i++ )
436)     ppNewFrames[i] = pMovie->ppFrames[i+1];
437) 
438)   free( pMovie->ppFrames );
439)   pMovie->ppFrames = ppNewFrames;
440)   pMovie->frameCnt--;
441) }
442) 
443) void BlinkenMovieDeleteFrames( stBlinkenMovie * pMovie )
444) {
445)   stBlinkenFrame * * ppNewFrames;
446)   int i;
447) 
448)   if( pMovie == NULL )
449)     return;
450) 
451)   ppNewFrames = (stBlinkenFrame * *)malloc1D( 0, sizeof( stBlinkenFrame * ) );
452)   if( ppNewFrames == NULL )
453)     return;
454) 
455)   for( i = 0; i < pMovie->frameCnt; i++ )
456)     BlinkenFrameFree( pMovie->ppFrames[i] );
457) 
458)   free( pMovie->ppFrames );
459)   pMovie->ppFrames = ppNewFrames;
460)   pMovie->frameCnt = 0;
461) }
462) 
463) void BlinkenMovieResize( stBlinkenMovie * pMovie, int height, int width, int channels, int maxval )
464) {
465)   int i;
466) 
467)   if( pMovie == NULL )
468)     return;
469) 
470)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
471)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
472)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
473)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
474)   if( channels < BlinkenChannelsMin ) channels = BlinkenChannelsMin;
475)   if( channels > BlinkenChannelsMax ) channels = BlinkenMaxvalMax;
476)   if( maxval < BlinkenMaxvalMin ) maxval = BlinkenMaxvalMin;
477)   if( maxval > BlinkenMaxvalMax ) maxval = BlinkenMaxvalMax;
478) 
479)   pMovie->height = height;
480)   pMovie->width = width;
481)   pMovie->channels = channels;
482)   pMovie->maxval = maxval;
483) 
484)   for( i = 0; i < pMovie->frameCnt; i++ )
485)     BlinkenFrameResize( pMovie->ppFrames[i], height, width, channels, maxval );
486) }
487) 
488) void BlinkenMovieScale( stBlinkenMovie * pMovie, int height, int width )
489) {
490)   int i;
491) 
492)   if( pMovie == NULL )
493)     return;
494) 
495)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
496)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
497)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
498)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
499) 
500)   pMovie->height = height;
501)   pMovie->width = width;
502) 
503)   for( i = 0; i < pMovie->frameCnt; i++ )
504)     BlinkenFrameScale( pMovie->ppFrames[i], height, width );
505) }
506) 
507) char * BlinkenMovieToString( stBlinkenMovie * pMovie )
508) {
509)   char * * strs, * str, * ptr;
510)   int i, size;
511) 
512)   if( pMovie == NULL )
513)     return NULL;
514) 
515)   strs = (char * *)malloc1D( pMovie->frameCnt, sizeof( char * ) );
516)   if( strs == NULL )
517)     return NULL;
518) 
519)   for( i = 0; i < pMovie->frameCnt; i++ )
520)   {
521)     strs[i] = BlinkenFrameToString( pMovie->ppFrames[i] );
522)     if( strs[i] == NULL )
523)     {
524)       for( i--; i >= 0; i-- )
525)         free( strs[i] );
526)       free( strs );
527)       return NULL;
528)     }
529)   }
530) 
531)   size = 128;
532)   for( i = 0; i < pMovie->infoCnt; i++ )
533)     size += strlen( pMovie->pppInfos[i][0] ) + strlen( pMovie->pppInfos[i][1] ) + 8;
534)   for( i = 0; i < pMovie->frameCnt; i++ )
535)     size += strlen( strs[i] ) + 32;
536) 
537)   str = (char *)malloc( size );
538)   if( str == NULL )
539)   {
540)     for( i = 0; i < pMovie->frameCnt; i++ )
541)       free( strs[i] );
542)     free( strs );
543)     return NULL;
544)   }
545) 
546)   ptr = str;
547) 
548)   sprintf( ptr, "BlinkenMovie %ux%u-%u/%u\n", pMovie->width, pMovie->height, pMovie->channels, pMovie->maxval );
549)   ptr += strlen( ptr );
550) 
551)   for( i = 0; i < pMovie->infoCnt; i++ )
552)   {
553)     sprintf( ptr, "%s = %s\n", pMovie->pppInfos[i][0], pMovie->pppInfos[i][1] );
554)     ptr += strlen( ptr );
555)   }
556) 
557)   for( i = 0; i < pMovie->frameCnt; i++ )
558)   {
559)     sprintf( ptr, "frame %u\n%s", i, strs[i] );
560)     ptr += strlen( ptr );
561)     free( strs[i] );
562)   }
563)   free( strs );
564) 
565)   return str;  
566) }
567) 
568) stBlinkenMovie * BlinkenMovieLoadBlm( char * pFilename )
569) {
570)   FILE * pFile;
571)   stBlinkenMovie * pMovie;
572)   stBlinkenFrame * pFrame;
573)   int width, height, y, x, chr, duration;
574)   char infoType[256], infoData[1024], pixel[2];
575) 
576)   if( pFilename == NULL )
577)     return NULL;
578) 
579)   //open file
580)   pFile = fopen( pFilename, "rt" );

581)   if( pFile == NULL )
582)     return NULL;

583) 
584)   //read magic and size
585)   if( fscanf( pFile, " # BlinkenLights Movie %ux%u", &width, &height ) != 2 )
586)   {
587)     fclose( pFile );
588)     return NULL;
589)   }
590) 
591)   //allocate a new movie
592)   pMovie = BlinkenMovieNew( height, width, 1, 1 );
593)   if( pMovie == NULL )
594)   {
595)     fclose( pFile );
596)     return NULL;
597)   }
598) 
599)   //no frame yet
600)   pFrame = NULL;
601)   y = 0;
602) 
603)   //read frames
604)   while( ! feof( pFile ) )
605)   {
606)     //skip rest of previous line (including newline)
607)     while( (chr = fgetc( pFile )) != '\n' && chr != EOF );
608) 
609)     //info line
610)     if( fscanf( pFile, " # %255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType, infoData ) == 2 )
611)     {
612)       BlinkenMovieAppendInfo( pMovie, infoType, infoData );
613)     }
614) 
615)     //start of frame
616)     else if( fscanf( pFile, " @ %u", &duration ) == 1 )
617)     {
618)       //create new frame and append it to movie
619)       pFrame = BlinkenFrameNew( height, width, 1, 1, duration );
620)       if( pFrame != NULL )
621)       {
622)         BlinkenFrameClear( pFrame );

623)         if( BlinkenMovieAppendFrame( pMovie, pFrame ) != 0 )
624)         {
625)           BlinkenFrameFree( pFrame );
626)           pFrame = NULL;
627)         }

628)         y = 0;
629)       }
630)     }
631) 
632)     //data line
633)     else if( fscanf( pFile, "%1[01]", pixel ) == 1 )
634)     {
635)       if( pFrame != NULL )
636)       {
637)         for( x = 0; ; x++ )
638)         {

639)           BlinkenFrameSetPixel( pFrame, y, x, 0, (unsigned char)(pixel[0] == '1' ? 1 : 0) ); //set pixel

640)           if( fscanf( pFile, "%1[01]", pixel ) != 1 ) //read next pixel
641)             break;
642)         }  
643)         y++; //next row
644)       }
645)     }
646) 
647)   } //while( ! feof( pFile ) )
648) 
649)   //close file
650)   fclose( pFile );
651) 
652)   return pMovie;
653) }
654) 
655) stBlinkenMovie * BlinkenMovieLoadBmm( char * pFilename )
656) {
657)   FILE * pFile;
658)   stBlinkenMovie * pMovie;
659)   stBlinkenFrame * pFrame;
660)   int width, height, y, x, chr, duration, val;
661)   char infoType[256], infoData[1024], pixel[8];
662) 
663)   if( pFilename == NULL )
664)     return NULL;
665) 
666)   //open file
667)   pFile = fopen( pFilename, "rt" );

668)   if( pFile == NULL )
669)     return NULL;

670) 
671)   //read magic and size
672)   if( fscanf( pFile, " # BlinkenMini Movie %ux%u", &width, &height ) != 2 )
673)   {
674)     fclose( pFile );
675)     return NULL;
676)   }
677) 
678)   //allocate a new movie
679)   pMovie = BlinkenMovieNew( height, width, 1, 255 );
680)   if( pMovie == NULL )
681)   {
682)     fclose( pFile );
683)     return NULL;
684)   }
685) 
686)   //no frame yet
687)   pFrame = NULL;
688)   y = 0;
689) 
690)   //read frames
691)   while( ! feof( pFile ) )
692)   {
693)     //skip rest of previous line (including newline)
694)     while( (chr = fgetc( pFile )) != '\n' && chr != EOF );
695) 
696)     //info line
697)     if( fscanf( pFile, " # %255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType, infoData ) == 2 )
698)     {
699)       BlinkenMovieAppendInfo( pMovie, infoType, infoData );
700)     }
701) 
702)     //start of frame
703)     else if( fscanf( pFile, " @ %u", &duration ) == 1 )
704)     {
705)       //create new frame and append it to movie
706)       pFrame = BlinkenFrameNew( height, width, 1, 255, duration );
707)       if( pFrame != NULL )
708)       {
709)         BlinkenFrameClear( pFrame );

710)         if( BlinkenMovieAppendFrame( pMovie, pFrame ) != 0 )
711)         {
712)           BlinkenFrameFree( pFrame );
713)           pFrame = NULL;
714)         }

715)         y = 0;
716)       }
717)     }
718) 
719)     //data line
720)     else if( fscanf( pFile, "%7[0-9A-FXa-fx]", pixel ) == 1 )
721)     {
722)       if( pFrame != NULL )
723)       {
724)         for( x = 0; ; x++ )
725)         {
726)           if( sscanf( pixel, "%i", &val ) != 1 ) //convert pixel to number
727)             break;
728)           BlinkenFrameSetPixel( pFrame, y, x, 0, (unsigned char)val ); //set pixel
729)           fscanf( pFile, "%*[ \t]" ); //kill space
730)           if( fscanf( pFile, "%7[0-9A-FXa-fx]", pixel ) != 1 ) //read next pixel
731)             break;
732)         }  
733)         y++; //next row
734)       }
735)     }
736) 
737)   } //while( ! feof( pFile ) )
738) 
739)   //close file
740)   fclose( pFile );
741) 
742)   return pMovie;
743) }
744) 
745) stBlinkenMovie * BlinkenMovieLoadBml( char * pFilename )
746) {
747)   FILE * pFile;
748)   stBlinkenMovie * pMovie;
749)   stBlinkenFrame * pFrame;
750)   int width, height, channels, bits, maxval, chrs, y, x, c, duration, val;
751)   char buffer[2048], infoType[256], infoData[1024], pixelFormat[16], pixel[8], * ptr, chr;
752) 
753)   if( pFilename == NULL )
754)     return NULL;
755) 
756)   //open file
757)   pFile = fopen( pFilename, "rt" );

758)   if( pFile == NULL )
759)     return NULL;

760) 
761)   //no movie yet - blm tag not yet found
762)   pMovie = NULL;
763) 
764)   //no frame yet
765)   pFrame = NULL;
766)   y = 0;
767) 
768)   //read tags
769)   maxval = 0;
770)   while( ! feof( pFile ) )
771)   {
772) 
773)     //skip to just before beginning of next tag
774)     fscanf( pFile, "%*[^<]" );
775)     //skip beginning character of next tag
776)     if( fgetc( pFile ) != '<' )
777)       //end loop (no more tags)
778)       break;
779) 
780)     //no blm tag yet
781)     if( pMovie == NULL )
782)     {
783) 
784)       //blm tag
785)       if( fscanf( pFile, "blm%2047[^>]", buffer ) == 1 )
786)       {
787)         //get attributes
788)         width = 0;
789)         height = 0;

790)         channels = 1;
791)         bits = 4;
792)         maxval = 15;

793)         if( (ptr = strstr( buffer, "height=\"" )) != NULL ) //height
794)           sscanf( ptr+8, "%u", &height );
795)         if( (ptr = strstr( buffer, "width=\"" )) != NULL ) //width
796)           sscanf( ptr+7, "%u", &width );
797)         if( (ptr = strstr( buffer, "channels=\"" )) != NULL ) //channels
798)           sscanf( ptr+10, "%u", &channels );
799)         if( (ptr = strstr( buffer, "bits=\"" )) != NULL ) //bits
800)           sscanf( ptr+6, "%u", &bits );
801)         maxval = (1 << bits) - 1; //maxval
802) 
803)         //allocate a new movie
804)         pMovie = BlinkenMovieNew( height, width, channels, maxval );
805)         if( pMovie == NULL )
806)         {
807)           fclose( pFile );
808)           return NULL;
809)         }
810) 
811)         //get number of characters per channel
812)         chrs = (bits + 3) >> 2;
813)         //get fscanf formart string for reading a pixel
814)         sprintf( pixelFormat, "%%%d[0-9A-Fa-f]", chrs > 4 ? 5 : chrs ); //read max 5 chars (2 already in use by prefix)
815)         //initialize pixel buffer with hex prefix
816)         strcpy( pixel, "0x" );
817)       }
818) 
819)     } //if( pMovie == NULL )
820) 
821)     //blm tag was already found
822)     else //if( pMovie == NULL )
823)     {
824) 
825)       //title tag
826)       if( fscanf( pFile, "title>%2047[^<]", buffer ) == 1 )
827)       {
828)         //add info to movie
829)         BlinkenMovieAppendInfo( pMovie, "title", buffer );
830)       }
831) 
832)       //description tag
833)       else if( fscanf( pFile, "description>%2047[^<]", buffer ) == 1 )
834)       {
835)         //check if generic info
836)         if( sscanf( buffer, "%255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType, infoData ) == 2 )
837)           //add info to movie
838)           BlinkenMovieAppendInfo( pMovie, infoType, infoData );
839)         else
840)           //add info to movie
841)           BlinkenMovieAppendInfo( pMovie, "description", buffer );
842)       }
843) 
844)       //creator tag
845)       else if( fscanf( pFile, "creator>%2047[^<]", buffer ) == 1 )
846)       {
847)         //add info to movie
848)         BlinkenMovieAppendInfo( pMovie, "creator", buffer );
849)       }
850) 
851)       //author tag
852)       else if( fscanf( pFile, "author>%2047[^<]", buffer ) == 1 )
853)       {
854)         //add info to movie
855)         BlinkenMovieAppendInfo( pMovie, "author", buffer );
856)       }
857) 
858)       //email tag
859)       else if( fscanf( pFile, "email>%2047[^<]", buffer ) == 1 )
860)       {
861)         //add info to movie
862)         BlinkenMovieAppendInfo( pMovie, "email", buffer );
863)       }
864) 
865)       //url tag
866)       else if( fscanf( pFile, "url>%2047[^<]", buffer ) == 1 )
867)       {
868)         //add info to movie
869)         BlinkenMovieAppendInfo( pMovie, "url", buffer );
870)       }
871) 
872)       //frame tag
873)       else if( fscanf( pFile, "frame%2047[^>]", buffer ) == 1 )
874)       {
875)         //get attributes
876)         duration = 0;
877)         if( (ptr = strstr( buffer, "duration=\"" )) != NULL ) //duration
878)           sscanf( ptr+10, "%u", &duration );
879)         //create new frame and append it to movie
880)         pFrame = BlinkenFrameNew( height, width, channels, maxval, duration );
881)         if( pFrame != NULL )
882)         {
883)           BlinkenFrameClear( pFrame );

884)           if( BlinkenMovieAppendFrame( pMovie, pFrame ) != 0 )
885)           {
886)             BlinkenFrameFree( pFrame );
887)             pFrame = NULL;
888)           }

889)           y = 0;
890)         }
891)       }
892) 
893)       //row tag
894)       else if( fscanf( pFile, "row%c", &chr ) == 1 && chr == '>' )
895)       {
896)         if( pFrame != NULL )
897)         {
898)           //parse row
899)           for( x = 0; x < width; x++ )
900)           {
901)             for( c = 0; c < channels; c++ )
902)             {
903)               //read next pixel (one channel of pixel)
904)               if( fscanf( pFile, pixelFormat, pixel+2 ) != 1 )
905)               {
906)                 x = width; //also terminate x loop
907)                 break;
908)               }
909)               //convert pixel (one channel of pixel) to number
910)               if( sscanf( pixel, "%i", &val ) != 1 )
911)               {
912)                 x = width; //also terminate x loop
913)                 break;
914)               }
915)               //set pixel (one channel of pixel)
916)               BlinkenFrameSetPixel( pFrame, y, x, c, (unsigned char)val );
917)             }
918)           }
919)           y++; //next row
920)         }
921)       }
922) 
923)     } //if( pMovie == NULL ) ... else
924) 
925)   } //while( ! feof( pFile ) )
926) 
927)   //close file
928)   fclose( pFile );
929) 
930)   return pMovie;
931) }
932) 
933) stBlinkenMovie * BlinkenMovieLoadBbm( char * pFilename )
934) {
935)   FILE * pFile;
936)   stBlinkenMovie * pMovie;
937)   stBlinkenFrame * pFrame;
938)   unsigned char header[24], subHeader[6], frameStartMarker[4];
939)   unsigned long headerMagic, headerFrameCnt, headerDuration, headerFramePtr;
940)   unsigned short headerHeight, headerWidth, headerChannels, headerMaxval;
941)   unsigned long subHeaderMagic, frameStartMarkerMagic;
942)   unsigned short subHeaderSize;
943)   unsigned char * pInfoHeader, * pInfoHeaderX, * pFrameData;
944)   int len, duration, y, x, c, i;
945) 
946)   if( pFilename == NULL )
947)     return NULL;
948) 
949)   //open file
950)   pFile = fopen( pFilename, "rb" );

951)   if( pFile == NULL )
952)     return NULL;

953) 
954)   //read header
955)   if( fread( header, 1, 24, pFile ) != 24 )
956)   {
957)     fclose( pFile );
958)     return NULL;
959)   }
960)   headerMagic = (unsigned long)header[0] << 24 | (unsigned long)header[1] << 16 | (unsigned long)header[2] << 8 | (unsigned long)header[3];
961)   headerHeight = (unsigned short)header[4] << 8 | (unsigned short)header[5];
962)   headerWidth = (unsigned short)header[6] << 8 | (unsigned short)header[7];
963)   headerChannels = (unsigned short)header[8] << 8 | (unsigned short)header[9];
964)   headerMaxval = (unsigned short)header[10] << 8 | (unsigned short)header[11];
965)   headerFrameCnt = (unsigned long)header[12] << 24 | (unsigned long)header[13] << 16 | (unsigned long)header[14] << 8 | (unsigned long)header[15];
966)   headerDuration = (unsigned long)header[16] << 24 | (unsigned long)header[17] << 16 | (unsigned long)header[18] << 8 | (unsigned long)header[19];
967)   headerFramePtr = (unsigned long)header[20] << 24 | (unsigned long)header[21] << 16 | (unsigned long)header[22] << 8 | (unsigned long)header[23];
968)   //check magic
969)   if( headerMagic != 0x23542666 )
970)   {
971)     fclose( pFile );
972)     return NULL;
973)   }
974) 
975)   //allocate a new movie
976)   pMovie = BlinkenMovieNew( headerHeight, headerWidth, headerChannels, headerMaxval );
977)   if( pMovie == NULL )
978)   {
979)     fclose( pFile );
980)     return NULL;
981)   }
982) 
983)   //read subheaders
984)   while( ftell( pFile ) + 6 <= (long)headerFramePtr )
985)   {
986)     if( fread( subHeader, 1, 6, pFile ) != 6 )
987)     {
988)       BlinkenMovieFree( pMovie );
989)       fclose( pFile );
990)       return NULL;
991)     }
992)     subHeaderMagic = (unsigned long)subHeader[0] << 24 | (unsigned long)subHeader[1] << 16 | (unsigned long)subHeader[2] << 8 | (unsigned long)subHeader[3];
993)     subHeaderSize = (unsigned short)subHeader[4] << 8 | (unsigned short)subHeader[5];
994) 
995)     //header fits into gap to frame start
996)     if( subHeaderSize >= 6 && ftell( pFile ) + subHeaderSize - 6 <= (long)headerFramePtr )
997)     {
998)       //info header
999)       if( subHeaderMagic == 0x696E666F ) //'i' 'n' 'f' 'o'
1000)       {
1001)         //read rest of info header
1002)         pInfoHeader = (unsigned char *)malloc( subHeaderSize - 6 );
1003)         if( pInfoHeader == NULL )
1004)         {
1005)           BlinkenMovieFree( pMovie );
1006)           fclose( pFile );
1007)           return NULL;
1008)         }
1009)         if( fread( pInfoHeader, 1, subHeaderSize - 6, pFile ) != (unsigned short)(subHeaderSize - 6) )
1010)         {
1011)           free( pInfoHeader );
1012)           BlinkenMovieFree( pMovie );
1013)           fclose( pFile );
1014)           return NULL;
1015)         }
1016)         //parse information
1017)         if( (pInfoHeaderX = memchr( pInfoHeader, 0, subHeaderSize - 6 )) != NULL )
1018)         {
1019)           pInfoHeaderX++;
1020)           len = pInfoHeaderX - pInfoHeader;
1021)           if( memchr( pInfoHeaderX, 0, subHeaderSize - 6 - len ) != NULL )
1022)             BlinkenMovieAppendInfo( pMovie, pInfoHeader, pInfoHeaderX );
1023)         }
1024)         free( pInfoHeader );
1025)       }
1026) 
1027)       //unknown subHeader
1028)       else
1029)         //skip
1030)         fseek( pFile, subHeaderSize - 6, SEEK_CUR );
1031) 
1032)     } //if( ftell( pFile ) ...
1033)   } //while( ftell( pFile ) ...
1034) 
1035)   //seek to start of frames
1036)   fseek( pFile, headerFramePtr, SEEK_SET );
1037) 
1038)   //read frame start marker
1039)   if( fread( frameStartMarker, 1, 4, pFile ) != 4 )
1040)   {
1041)     BlinkenMovieFree( pMovie );
1042)     fclose( pFile );
1043)     return NULL;
1044)   }
1045)   frameStartMarkerMagic = (unsigned long)frameStartMarker[0] << 24 | (unsigned long)frameStartMarker[1] << 16 | (unsigned long)frameStartMarker[2] << 8 | (unsigned long)frameStartMarker[3];
1046)   if( frameStartMarkerMagic != 0x66726D73 ) //'f' 'r' 'm' 's'
1047)   {
1048)     BlinkenMovieFree( pMovie );
1049)     fclose( pFile );
1050)     return NULL;
1051)   }
1052) 
1053)   //allocate buffer for frame data
1054)   len = 2 + headerHeight * headerWidth * headerChannels;
1055)   pFrameData = (unsigned char *)malloc( len );
1056)   if( pFrameData == NULL )
1057)   {
1058)     BlinkenMovieFree( pMovie );
1059)     fclose( pFile );
1060)     return NULL;
1061)   }
1062) 
1063)   //read frames
1064)   for( ; ; )
1065)   {
1066)     //read frame
1067)     if( fread( pFrameData, 1, len, pFile ) != (unsigned int)len )
1068)       break;
1069)     duration = (unsigned short)pFrameData[0] << 8 | (unsigned short)pFrameData[1];
1070)     //build frame and append it to movie
1071)     pFrame = BlinkenFrameNew( headerHeight, headerWidth, headerChannels, headerMaxval, duration );
1072)     if( pFrame == NULL )
1073)       break;
1074)     i = 2;
1075)     for( y = 0; y < headerHeight; y++ )
1076)       for( x = 0; x < headerWidth; x++ )
1077)         for( c = 0; c < headerChannels; c++, i++ )
1078)           BlinkenFrameSetPixel( pFrame, y, x, c, pFrameData[i] );

1079)     if( BlinkenMovieAppendFrame( pMovie, pFrame ) != 0 )
1080)     {
1081)       BlinkenFrameFree( pFrame );
1082)       pFrame = NULL;
1083)     }

1084) 
1085)   } //for( ; ; )
1086) 
1087)   //free buffer for frame data
1088)   free( pFrameData );
1089) 
1090)   //close file
1091)   fclose( pFile );
1092) 
1093)   return pMovie;
1094) }
1095) 
1096) stBlinkenMovie * BlinkenMovieLoad( char * pFilename )
1097) {
1098)   int len;
1099) 
1100)   if( pFilename == NULL )
1101)     return NULL;
1102) 
1103)   len = strlen( pFilename );
1104)   if( len > 4 && strcmp( pFilename + len - 4, ".blm" ) == 0 )
1105)     return BlinkenMovieLoadBlm( pFilename );
1106)   if( len > 4 && strcmp( pFilename + len - 4, ".bmm" ) == 0 )
1107)     return BlinkenMovieLoadBmm( pFilename );
1108)   if( len > 4 && strcmp( pFilename + len - 4, ".bml" ) == 0 )
1109)     return BlinkenMovieLoadBml( pFilename );
1110)   if( len > 4 && strcmp( pFilename + len - 4, ".bbm" ) == 0 )
1111)     return BlinkenMovieLoadBbm( pFilename );
1112)   return NULL;
1113) }
1114) 
1115) int BlinkenMovieSaveBlm( stBlinkenMovie * pMovie, char * pFilename )
1116) {
1117)   stBlinkenMovie * pOutMovie;
1118)   FILE * pFile;
1119)   int i, y, x;
1120) 
1121)   if( pMovie == NULL || pFilename == NULL )
1122)     return -1;
1123) 
1124)   //convert movie to suitable format
1125)   pOutMovie = BlinkenMovieClone( pMovie );
1126)   if( pOutMovie == NULL )
1127)     return -1;
1128)   BlinkenMovieResize( pOutMovie, pOutMovie->height, pOutMovie->width, 1, 1 );
1129) 
1130)   //open file
1131)   pFile = fopen( pFilename, "wt" );
1132)   if( pFile == NULL )
1133)   {
1134)     BlinkenMovieFree( pOutMovie );
1135)     return -1;
1136)   }
1137) 
1138)   //write header line
1139)   fprintf( pFile, "# BlinkenLights Movie %ux%u\n", pOutMovie->width, pOutMovie->height );
1140) 
1141)   //write information lines
1142)   for( i = 0; i < pOutMovie->infoCnt; i++ )
1143)     fprintf( pFile, "# %s = %s\n", pOutMovie->pppInfos[i][0], pOutMovie->pppInfos[i][1] );
1144) 
1145)   //write frames
1146)   for( i = 0; i < pOutMovie->frameCnt; i++ )
1147)   {
1148)     fprintf( pFile, "\n@%u\n", BlinkenFrameGetDuration( pOutMovie->ppFrames[i] ) );
1149)     for( y = 0; y < pOutMovie->height; y++ )
1150)     {
1151)       for( x = 0; x < pOutMovie->width; x++ )
1152)       {
1153)         if( BlinkenFrameGetPixel( pOutMovie->ppFrames[i], y, x, 0 ) != 0 )
1154)           fprintf( pFile, "1" );
1155)         else
1156)           fprintf( pFile, "0" );
1157)       }
1158)       fprintf( pFile, "\n" );
1159)     }
1160)   }
1161) 
1162)   //close file
1163)   fclose( pFile );
1164) 
1165)   //free copied movie
1166)   BlinkenMovieFree( pOutMovie );
1167) 
1168)   //success
1169)   return 0;
1170) }
1171) 
1172) int BlinkenMovieSaveBmm( stBlinkenMovie * pMovie, char * pFilename )
1173) {
1174)   stBlinkenMovie * pOutMovie;
1175)   FILE * pFile;
1176)   int i, y, x;
1177) 
1178)   if( pMovie == NULL || pFilename == NULL )
1179)     return -1;
1180) 
1181)   //convert movie to suitable format
1182)   pOutMovie = BlinkenMovieClone( pMovie );
1183)   if( pOutMovie == NULL )
1184)     return -1;
1185)   BlinkenMovieResize( pOutMovie, pOutMovie->height, pOutMovie->width, 1, 255 );
1186) 
1187)   //open file
1188)   pFile = fopen( pFilename, "wt" );
1189)   if( pFile == NULL )
1190)   {
1191)     BlinkenMovieFree( pOutMovie );
1192)     return -1;
1193)   }
1194) 
1195)   //write header line
1196)   fprintf( pFile, "# BlinkenMini Movie %ux%u\n", pOutMovie->width, pOutMovie->height );
1197) 
1198)   //write information lines
1199)   for( i = 0; i < pOutMovie->infoCnt; i++ )
1200)     fprintf( pFile, "# %s = %s\n", pOutMovie->pppInfos[i][0], pOutMovie->pppInfos[i][1] );
1201) 
1202)   //write frames
1203)   for( i = 0; i < pOutMovie->frameCnt; i++ )
1204)   {
1205)     fprintf( pFile, "\n@%u\n", BlinkenFrameGetDuration( pOutMovie->ppFrames[i] ) );
1206)     for( y = 0; y < pOutMovie->height; y++ )
1207)     {
1208)       fprintf( pFile, "0x%02X", BlinkenFrameGetPixel( pOutMovie->ppFrames[i], y, 0, 0 ) );
1209)       for( x = 1; x < pOutMovie->width; x++ )
1210)         fprintf( pFile, " 0x%02X", BlinkenFrameGetPixel( pOutMovie->ppFrames[i], y, x, 0 ) );
1211)       fprintf( pFile, "\n" );
1212)     }
1213)   }
1214) 
1215)   //close file
1216)   fclose( pFile );
1217) 
1218)   //free copied movie
1219)   BlinkenMovieFree( pOutMovie );
1220) 
1221)   //success
1222)   return 0;
1223) }
1224) 
1225) int BlinkenMovieSaveBml( stBlinkenMovie * pMovie, char * pFilename )
1226) {
1227)   stBlinkenMovie * pOutMovie;
1228)   FILE * pFile;
1229)   int bits, val, i, y, x, c;
1230) 
1231)   if( pMovie == NULL || pFilename == NULL )
1232)     return -1;
1233) 
1234)   //convert movie to suitable format
1235)   pOutMovie = BlinkenMovieClone( pMovie );
1236)   if( pOutMovie == NULL )
1237)     return -1;
1238)   val = pOutMovie->maxval; //get number of bits
1239)   for( bits = 0; val != 0; val >>= 1, bits++ );
1240)   BlinkenMovieResize( pOutMovie, pOutMovie->height, pOutMovie->width, pOutMovie->channels, (1 << bits) - 1 );
1241) 
1242)   //open file
1243)   pFile = fopen( pFilename, "wt" );
1244)   if( pFile == NULL )
1245)   {
1246)     BlinkenMovieFree( pOutMovie );
1247)     return -1;
1248)   }
1249) 
1250)   //write header line
1251)   fprintf( pFile, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" );
1252) 
1253)   //write blm start tag
1254)   fprintf( pFile, "<blm width=\"%u\" height=\"%u\" bits=\"%u\" channels=\"%u\">\n",
1255)            pOutMovie->width, pOutMovie->height, bits, pOutMovie->channels );
1256) 
1257)   //write information lines
1258)   fprintf( pFile, "\t<header>\n" );
1259)   for( i = 0; i < pOutMovie->infoCnt; i++ )
1260)   {
1261)     if( strcmp( pOutMovie->pppInfos[i][0], "title" ) == 0 )
1262)       fprintf( pFile, "\t\t<title>%s</title>\n", pOutMovie->pppInfos[i][1] );
1263)     else if( strcmp( pOutMovie->pppInfos[i][0], "description" ) == 0 )
1264)       fprintf( pFile, "\t\t<description>%s</description>\n", pOutMovie->pppInfos[i][1] );
1265)     else if( strcmp( pOutMovie->pppInfos[i][0], "creator" ) == 0 )
1266)       fprintf( pFile, "\t\t<creator>%s</creator>\n", pOutMovie->pppInfos[i][1] );
1267)     else if( strcmp( pOutMovie->pppInfos[i][0], "author" ) == 0)
1268)       fprintf( pFile, "\t\t<author>%s</author>\n", pOutMovie->pppInfos[i][1] );
1269)     else if( strcmp( pOutMovie->pppInfos[i][0], "email" ) == 0)
1270)       fprintf( pFile, "\t\t<email>%s</email>\n", pOutMovie->pppInfos[i][1] );
1271)     else if( strcmp( pOutMovie->pppInfos[i][0], "url" ) == 0)
1272)       fprintf( pFile, "\t\t<url>%s</url>\n", pOutMovie->pppInfos[i][1] );
1273)     else
1274)       fprintf( pFile, "\t\t<description>%s: %s</description>\n", pOutMovie->pppInfos[i][0], pOutMovie->pppInfos[i][1] );
1275)   }
1276)   fprintf( pFile, "\t</header>\n" );
1277) 
1278)   //write frames
1279)   for( i = 0; i < pOutMovie->frameCnt; i++ )
1280)   {
1281)     fprintf( pFile, "\n\t<frame duration=\"%u\">\n", BlinkenFrameGetDuration( pOutMovie->ppFrames[i] ) );
1282)     for( y = 0; y < pOutMovie->height; y++ )
1283)     {
1284)       fprintf( pFile, "\t\t<row>" );
1285)       for( x = 0; x < pOutMovie->width; x++ )
1286)         for( c = 0; c < pOutMovie->channels; c++ )
1287)           fprintf( pFile, bits > 4 ? "%02X" : "%01X",
1288)             BlinkenFrameGetPixel( pOutMovie->ppFrames[i], y, x, c ) );
1289)       fprintf( pFile, "</row>\n" );
1290)     }
1291)     fprintf( pFile, "\t</frame>\n" );
1292)   }
1293) 
1294)   //write blm end tag
1295)   fprintf( pFile, "</blm>\n" );
1296) 
1297)   //close file
1298)   fclose( pFile );
1299) 
1300)   //free copied movie
1301)   BlinkenMovieFree( pOutMovie );
1302) 
1303)   //success
1304)   return 0;
1305) }
1306) 
1307) int BlinkenMovieSaveBbm( stBlinkenMovie * pMovie, char * pFilename )
1308) {
1309)   unsigned char * pFrameData;
1310)   FILE * pFile;
1311)   unsigned char header[24], infoHeader[6], framePointer[4], frameStartMarker[4];
1312)   int duration, len, len0, len1, i, j, y, x, c, val;
1313)   long pos;
1314) 
1315)   if( pMovie == NULL || pFilename == NULL )
1316)     return -1;
1317) 
1318)   //allocate frame data buffer
1319)   pFrameData = (unsigned char *)malloc( 2 + pMovie->height * pMovie->width * pMovie->channels );
1320)   if( pFrameData == NULL )
1321)     return -1;
1322) 
1323)   //open file
1324)   pFile = fopen( pFilename, "wb" );
1325)   if( pFile == NULL )
1326)   {
1327)     free( pFrameData );
1328)     return -1;
1329)   }
1330) 
1331)   //write header
1332)   header[0] = 0x23; //magic
1333)   header[1] = 0x54;
1334)   header[2] = 0x26;
1335)   header[3] = 0x66;
1336)   header[4] = (unsigned char)(pMovie->height >> 8);
1337)   header[5] = (unsigned char)pMovie->height;
1338)   header[6] = (unsigned char)(pMovie->width >> 8);
1339)   header[7] = (unsigned char)pMovie->width;
1340)   header[8] = (unsigned char)(pMovie->channels >> 8);
1341)   header[9] = (unsigned char)pMovie->channels;
1342)   header[10] = (unsigned char)(pMovie->maxval >> 8);
1343)   header[11] = (unsigned char)pMovie->maxval;
1344)   header[12] = (unsigned char)(pMovie->frameCnt >> 24);
1345)   header[13] = (unsigned char)(pMovie->frameCnt >> 16);
1346)   header[14] = (unsigned char)(pMovie->frameCnt >> 8);
1347)   header[15] = (unsigned char)pMovie->frameCnt;
1348)   duration = 0;
1349)   for( i = 0; i < pMovie->frameCnt; i++ )
1350)     duration += BlinkenFrameGetDuration( pMovie->ppFrames[i] ); 
1351)   header[16] = (unsigned char)(duration >> 24);
1352)   header[17] = (unsigned char)(duration >> 16);
1353)   header[18] = (unsigned char)(duration >> 8);
1354)   header[19] = (unsigned char)duration;
1355)   header[20] = 0; //frame pointer is written later
1356)   header[21] = 0;
1357)   header[22] = 0;
1358)   header[23] = 0;
1359)   fwrite( header, 1, 24, pFile );
1360) 
1361)   //write information
1362)   for( i = 0; i < pMovie->infoCnt; i++ )
1363)   {
1364)     len0 = strlen( pMovie->pppInfos[i][0] );
1365)     if( len0 > 32760 )
1366)       len0 = 32760;
1367)     len1 = strlen( pMovie->pppInfos[i][1] );
1368)     if( len1 > 32760 )
1369)       len1 = 32760;
1370)     len = 8 + len0 + len1;
1371)     infoHeader[0] = 0x69; //'i'
1372)     infoHeader[1] = 0x6E; //'n'
1373)     infoHeader[2] = 0x66; //'f'
1374)     infoHeader[3] = 0x6F; //'o'
1375)     infoHeader[4] = (unsigned char)(len >> 8);
1376)     infoHeader[5] = (unsigned char)len;
1377)     fwrite( infoHeader, 1, 6, pFile );
1378)     fwrite( pMovie->pppInfos[i][0], 1, len0, pFile );
1379)     fwrite( "\0", 1, 1, pFile );
1380)     fwrite( pMovie->pppInfos[i][1], 1, len1, pFile );
1381)     fwrite( "\0", 1, 1, pFile );
1382)   }
1383) 
1384)   //write frame pointer
1385)   pos = ftell( pFile );
1386)   framePointer[0] = (unsigned char)(pos >> 24);
1387)   framePointer[1] = (unsigned char)(pos >> 16);
1388)   framePointer[2] = (unsigned char)(pos >> 8);
1389)   framePointer[3] = (unsigned char)pos;
1390)   fseek( pFile, 20, SEEK_SET );
1391)   fwrite( framePointer, 1, 4, pFile );
1392)   fseek( pFile, pos, SEEK_SET );
1393) 
1394)   //write frame start marker
1395)   frameStartMarker[0] = 0x66; //'f'
1396)   frameStartMarker[1] = 0x72; //'r'
1397)   frameStartMarker[2] = 0x6D; //'m'
1398)   frameStartMarker[3] = 0x73; //'s'
1399)   fwrite( frameStartMarker, 1, 4, pFile );
1400) 
1401)   //write frames
1402)   for( i = 0; i < pMovie->frameCnt; i++ )
1403)   {
1404)     val = BlinkenFrameGetDuration( pMovie->ppFrames[i] );
1405)     pFrameData[0] = (unsigned char)(val >> 8);
1406)     pFrameData[1] = (unsigned char)val;
1407)     for( j = 2, y = 0; y < pMovie->height; y++ )
1408)       for( x = 0; x < pMovie->width; x++ )
1409)         for( c = 0; c < pMovie->channels; c++, j++ )
1410)           pFrameData[j] = BlinkenFrameGetPixel( pMovie->ppFrames[i], y, x, c );
1411)     fwrite( pFrameData, 1, j, pFile );
1412)   }
1413) 
1414)   //free frame data buffer
1415)   free( pFrameData );
1416) 
1417)   //close file
1418)   fclose( pFile );
1419) 
1420)   //success
1421)   return 0;
1422) }
1423) 
1424) int BlinkenMovieSave( stBlinkenMovie * pMovie, char * pFilename )
1425) {
1426)   int len;
1427) 
1428)   if( pMovie == NULL || pFilename == NULL )
1429)     return -1;
1430) 
1431)   len = strlen( pFilename );
1432)   if( len > 4 && strcmp( pFilename + len - 4, ".blm" ) == 0 )
1433)     return BlinkenMovieSaveBlm( pMovie, pFilename );
1434)   if( len > 4 && strcmp( pFilename + len - 4, ".bmm" ) == 0 )
1435)     return BlinkenMovieSaveBmm( pMovie, pFilename );
1436)   if( len > 4 && strcmp( pFilename + len - 4, ".bml" ) == 0 )
1437)     return BlinkenMovieSaveBml( pMovie, pFilename );
1438)   if( len > 4 && strcmp( pFilename + len - 4, ".bbm" ) == 0 )
1439)     return BlinkenMovieSaveBbm( pMovie, pFilename );
1440)   return -1;
1441) }
1442) 

1443) void BlinkenMovieSend( stBlinkenMovie * pMovie, SOCKET udpSocket, etBlinkenProto proto )

1444) //udp socket must be "connected"
1445) {
1446)   int i, len;
1447)   char buffer[65536]; //64kB is more tham maximum UDP size
1448) 
1449)   for( i = 0; i < pMovie->frameCnt; i++ )
1450)   {
1451)     len = BlinkenFrameToNetwork( pMovie->ppFrames[i], proto, buffer, sizeof( buffer ) );
1452)     if( len > 0 )
1453)       send( udpSocket, buffer, len, 0 );

1454)     msleep( BlinkenFrameGetDuration( pMovie->ppFrames[i] ) );

1455)   }
1456) }
1457) 

1458) stBlinkenMovie * BlinkenMovieReceive( SOCKET udpSocket, int timeout, etBlinkenProto * pProto )

1459) //udp socket must be "bound" and should be "connected"
1460) //after timeout ms of no reception, the movie is considered to be complete
1461) //returns protocol in *pProto if pProto not NULL
1462) {
1463)   stBlinkenMovie * pMovie;
1464)   stBlinkenFrame * pLastFrame, * pFrame;
1465)   etBlinkenProto proto, p;
1466)   fd_set readFds;

1467)   struct timeval timeo;
1468)   unsigned int lastTime, curTime;

1469)   char buffer[65536]; //64kB is more than maximum UDP size

1470)   int len;
1471) 
1472)   //correct timeout
1473)   if( timeout < 0 )
1474)     timeout = 0;
1475) 
1476)   //wait for frames
1477)   pMovie = NULL;
1478)   proto = BlinkenProtoNone;
1479)   pLastFrame = NULL;

1480)   lastTime = get_ms( );

1481)   for( ; ; )
1482)   {
1483)     //wait for next frame
1484)     FD_ZERO( &readFds );
1485)     FD_SET( udpSocket, &readFds );
1486)     timeo.tv_sec = timeout / 1000;
1487)     timeo.tv_usec = (timeout % 1000) * 1000;
1488)     if( select( udpSocket + 1, &readFds, NULL, NULL, &timeo ) <= 0 ) //timeout or error
1489)       break;
1490) 
1491)     //fetch data
1492)     len = recv( udpSocket, buffer, sizeof( buffer ), 0 );
1493)     if( len <= 0 )
1494)       break;
1495) 
1496)     //get frame from data
1497)     pFrame = BlinkenFrameFromNetwork( buffer, len, &p );
1498)     if( pFrame != NULL )
1499)     {
1500)       //valid protocol
1501)       if( p != BlinkenProtoNone )
1502)       {
1503)         //first frame
1504)         if( proto == BlinkenProtoNone )
1505)           proto = p; //use this protocol
1506)         //protocol matches
1507)         if( p == proto )
1508)         {
1509)           //no movie yet
1510)           if( pMovie == NULL )
1511)           {
1512)             //allocate a new movie
1513)             pMovie = BlinkenMovieNew( BlinkenFrameGetHeight( pFrame ),
1514)                                       BlinkenFrameGetWidth( pFrame ),
1515)                                       BlinkenFrameGetChannels( pFrame ),
1516)                                       BlinkenFrameGetMaxval( pFrame ) );
1517)             if( pMovie == NULL )
1518)             {
1519)               BlinkenFrameFree( pFrame );
1520)               break;
1521)             }
1522)           }
1523) 
1524)           //append frame to movie
1525)           if( BlinkenMovieAppendFrame( pMovie, pFrame ) == 0 )
1526)           {
1527)             //get current time

1528)             curTime = get_ms( );

1529)             //set duration of last frame
1530)             if( pLastFrame != NULL )

1531)               BlinkenFrameSetDuration( pLastFrame, curTime - lastTime );

1532)             //remember this frame as last frame appended to movie
1533)             pLastFrame = pFrame;
1534)             pFrame = NULL; //do not free this frame (it was appended)
1535)             lastTime = curTime; //remember time of this frame
1536)           }
1537)         } //if( p == proto )
1538)       } //if( p != BlinkenProtoNone )
1539)       //free frame if it was not appended
1540)       if( pFrame != NULL )
1541)         BlinkenFrameFree( pFrame );
1542)     } //if( pFrame != NULL )
1543)   } //for( ; ; )
1544) 
1545)   //get current time

1546)   curTime = get_ms( );

1547)   //set duration of last frame
1548)   if( pLastFrame != NULL )

1549)     BlinkenFrameSetDuration( pLastFrame, curTime - lastTime );