BlinkenLib

1) /* BlinkenLib

2)  * version 0.5 date 2005-12-06

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

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

11) #include <unistd.h>
12) #include <sys/time.h>
13) #include <sys/types.h>
14) #include <sys/socket.h>
15) #include <sys/select.h>

16) 
17) #include "BlinkenConstants.h"
18) #include "BlinkenFrame.h"
19) #include "BlinkenMovie.h"
20) #include "Tools.h"
21) 
22) struct sBlinkenMovie
23) {
24)   int height;
25)   int width;
26)   int channels;
27)   int maxval;
28)   int infoCnt;
29)   char * * * pppInfos;
30)   int frameCnt;
31)   stBlinkenFrame * * ppFrames;
32) };
33) 
34) stBlinkenMovie * BlinkenMovieNew( int height, int width, int channels, int maxval )
35) {
36)   stBlinkenMovie * pMovie;
37) 
38)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
39)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
40)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
41)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
42)   if( channels < BlinkenChannelsMin ) channels = BlinkenChannelsMin;
43)   if( channels > BlinkenChannelsMax ) channels = BlinkenMaxvalMax;
44)   if( maxval < BlinkenMaxvalMin ) maxval = BlinkenMaxvalMin;
45)   if( maxval > BlinkenMaxvalMax ) maxval = BlinkenMaxvalMax;
46) 
47)   pMovie = (stBlinkenMovie *)malloc( sizeof( stBlinkenMovie ) );
48)   if( pMovie == NULL )
49)     return NULL;
50) 
51)   pMovie->height = height;
52)   pMovie->width = width;
53)   pMovie->channels = channels;
54)   pMovie->maxval = maxval;
55)   pMovie->infoCnt = 0;
56)   pMovie->pppInfos = (char * * *)malloc2D( 0, 2, sizeof( char * ) );
57)   if( pMovie->pppInfos == NULL )
58)   {
59)     free( pMovie );
60)     return NULL;
61)   }
62)   pMovie->frameCnt = 0;
63)   pMovie->ppFrames = (stBlinkenFrame * *)malloc1D( 0, sizeof( stBlinkenFrame * ) );
64)   if( pMovie->ppFrames == NULL )
65)   {
66)     free( pMovie->pppInfos );
67)     free( pMovie );
68)     return NULL;
69)   }
70) 
71)   return pMovie;
72) }
73) 
74) stBlinkenMovie * BlinkenMovieClone( stBlinkenMovie * pSrcMovie )
75) {
76)   stBlinkenMovie * pMovie;

77)   stBlinkenFrame * pFrame;

78)   int i;
79) 
80)   pMovie = BlinkenMovieNew( pSrcMovie->height, pSrcMovie->width, pSrcMovie->channels, pSrcMovie->maxval );
81)   if( pMovie == NULL )
82)     return NULL;
83) 
84)   for( i = 0; i < pSrcMovie->infoCnt; i++ )
85)     BlinkenMovieAppendInfo( pMovie, pSrcMovie->pppInfos[i][0], pSrcMovie->pppInfos[i][1] );
86) 
87)   for( i = 0; i < pSrcMovie->frameCnt; i++ )

88)   {
89)     pFrame = BlinkenFrameClone( pSrcMovie->ppFrames[i] );
90)     if( BlinkenMovieAppendFrame( pMovie, pFrame ) != 0 )
91)       BlinkenFrameFree( pFrame );
92)   }

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

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

351) {
352)   stBlinkenFrame * * ppNewFrames;
353)   int i;
354) 
355)   if( pMovie == NULL || frameNo < 0 || frameNo > pMovie->frameCnt )

356)     return -1;

357) 
358)   ppNewFrames = (stBlinkenFrame * *)malloc1D( pMovie->frameCnt + 1, sizeof( stBlinkenFrame * ) );
359)   if( ppNewFrames == NULL )

360)     return -1;

361) 
362)   for( i = 0; i < frameNo; i++ )
363)     ppNewFrames[i] = pMovie->ppFrames[i];
364) 
365)   BlinkenFrameResize( pFrame, pMovie->height, pMovie->width, pMovie->channels, pMovie->maxval );
366)   ppNewFrames[frameNo] = pFrame;
367) 
368)   for( i = frameNo; i < pMovie->frameCnt; i++ )
369)     ppNewFrames[i+1] = pMovie->ppFrames[i];
370) 
371)   free( pMovie->ppFrames );
372)   pMovie->ppFrames = ppNewFrames;
373)   pMovie->frameCnt++;

374)   return 0;

375) }
376) 

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

378) {
379)   if( pMovie == NULL )

380)     return -1;

381) 

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

383) }
384) 
385) void BlinkenMovieDeleteFrame( stBlinkenMovie * pMovie, int frameNo )
386) {
387)   stBlinkenFrame * * ppNewFrames;
388)   int i;
389) 
390)   if( pMovie == NULL || frameNo < 0 || frameNo >= pMovie->frameCnt )
391)     return;
392) 
393)   ppNewFrames = (stBlinkenFrame * *)malloc1D( pMovie->frameCnt - 1, sizeof( stBlinkenFrame * ) );
394)   if( ppNewFrames == NULL )
395)     return;
396) 
397)   for( i = 0; i < frameNo; i++ )
398)     ppNewFrames[i] = pMovie->ppFrames[i];
399) 
400)   BlinkenFrameFree( pMovie->ppFrames[frameNo] );
401) 
402)   for( i = frameNo; i < pMovie->frameCnt - 1; i++ )
403)     ppNewFrames[i] = pMovie->ppFrames[i+1];
404) 
405)   free( pMovie->ppFrames );
406)   pMovie->ppFrames = ppNewFrames;
407)   pMovie->frameCnt--;
408) }
409) 
410) void BlinkenMovieDeleteFrames( stBlinkenMovie * pMovie )
411) {
412)   stBlinkenFrame * * ppNewFrames;
413)   int i;
414) 
415)   if( pMovie == NULL )
416)     return;
417) 
418)   ppNewFrames = (stBlinkenFrame * *)malloc1D( 0, sizeof( stBlinkenFrame * ) );
419)   if( ppNewFrames == NULL )
420)     return;
421) 
422)   for( i = 0; i < pMovie->frameCnt; i++ )
423)     BlinkenFrameFree( pMovie->ppFrames[i] );
424) 
425)   free( pMovie->ppFrames );
426)   pMovie->ppFrames = ppNewFrames;
427)   pMovie->frameCnt = 0;
428) }
429) 
430) void BlinkenMovieResize( stBlinkenMovie * pMovie, int height, int width, int channels, int maxval )
431) {
432)   int i;
433) 
434)   if( pMovie == NULL )
435)     return;
436) 
437)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
438)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
439)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
440)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
441)   if( channels < BlinkenChannelsMin ) channels = BlinkenChannelsMin;
442)   if( channels > BlinkenChannelsMax ) channels = BlinkenMaxvalMax;
443)   if( maxval < BlinkenMaxvalMin ) maxval = BlinkenMaxvalMin;
444)   if( maxval > BlinkenMaxvalMax ) maxval = BlinkenMaxvalMax;
445) 
446)   pMovie->height = height;
447)   pMovie->width = width;
448)   pMovie->channels = channels;
449)   pMovie->maxval = maxval;
450) 
451)   for( i = 0; i < pMovie->frameCnt; i++ )
452)     BlinkenFrameResize( pMovie->ppFrames[i], height, width, channels, maxval );
453) }
454) 
455) void BlinkenMovieScale( stBlinkenMovie * pMovie, int height, int width )
456) {
457)   int i;
458) 
459)   if( pMovie == NULL )
460)     return;
461) 
462)   if( height < BlinkenHeightMin ) height = BlinkenHeightMin;
463)   if( height > BlinkenHeightMax ) height = BlinkenHeightMax;
464)   if( width < BlinkenWidthMin ) width = BlinkenWidthMin;
465)   if( width > BlinkenWidthMax ) width = BlinkenWidthMax;
466) 
467)   pMovie->height = height;
468)   pMovie->width = width;
469) 
470)   for( i = 0; i < pMovie->frameCnt; i++ )
471)     BlinkenFrameScale( pMovie->ppFrames[i], height, width );
472) }
473) 
474) char * BlinkenMovieToString( stBlinkenMovie * pMovie )
475) {
476)   char * * strs, * str, * ptr;
477)   int i, size;
478) 
479)   if( pMovie == NULL )
480)     return NULL;
481) 
482)   strs = (char * *)malloc1D( pMovie->frameCnt, sizeof( char * ) );
483)   if( strs == NULL )
484)     return NULL;
485) 
486)   for( i = 0; i < pMovie->frameCnt; i++ )
487)   {
488)     strs[i] = BlinkenFrameToString( pMovie->ppFrames[i] );
489)     if( strs[i] == NULL )
490)     {
491)       for( i--; i >= 0; i-- )
492)         free( strs[i] );
493)       free( strs );
494)       return NULL;
495)     }
496)   }
497) 
498)   size = 128;
499)   for( i = 0; i < pMovie->infoCnt; i++ )
500)     size += strlen( pMovie->pppInfos[i][0] ) + strlen( pMovie->pppInfos[i][1] ) + 8;
501)   for( i = 0; i < pMovie->frameCnt; i++ )
502)     size += strlen( strs[i] ) + 32;
503) 
504)   str = (char *)malloc( size );
505)   if( str == NULL )
506)   {
507)     for( i = 0; i < pMovie->frameCnt; i++ )
508)       free( strs[i] );
509)     free( strs );
510)     return NULL;
511)   }
512) 
513)   ptr = str;
514) 
515)   sprintf( ptr, "BlinkenMovie %ux%u-%u/%u\n", pMovie->width, pMovie->height, pMovie->channels, pMovie->maxval );
516)   ptr += strlen( ptr );
517) 
518)   for( i = 0; i < pMovie->infoCnt; i++ )
519)   {
520)     sprintf( ptr, "%s = %s\n", pMovie->pppInfos[i][0], pMovie->pppInfos[i][1] );
521)     ptr += strlen( ptr );
522)   }
523) 
524)   for( i = 0; i < pMovie->frameCnt; i++ )
525)   {
526)     sprintf( ptr, "frame %u\n%s", i, strs[i] );
527)     ptr += strlen( ptr );
528)     free( strs[i] );
529)   }
530)   free( strs );
531) 
532)   return str;  
533) }
534) 
535) stBlinkenMovie * BlinkenMovieLoadBlm( char * pFilename )
536) {
537)   FILE * pFile;
538)   stBlinkenMovie * pMovie;
539)   stBlinkenFrame * pFrame;
540)   int width, height, y, x, chr, duration;
541)   char infoType[256], infoData[1024], pixel[2];
542) 
543)   if( pFilename == NULL )
544)     return NULL;
545) 
546)   //open file
547)   pFile = fopen( pFilename, "rt" );

548)   if( pFile == NULL )
549)     return NULL;

550) 
551)   //read magic and size
552)   if( fscanf( pFile, " # BlinkenLights Movie %ux%u", &width, &height ) != 2 )
553)   {
554)     fclose( pFile );
555)     return NULL;
556)   }
557) 
558)   //allocate a new movie
559)   pMovie = BlinkenMovieNew( height, width, 1, 1 );
560)   if( pMovie == NULL )
561)   {
562)     fclose( pFile );
563)     return NULL;
564)   }
565) 
566)   //no frame yet
567)   pFrame = NULL;
568)   y = 0;
569) 
570)   //read frames
571)   while( ! feof( pFile ) )
572)   {
573)     //skip rest of previous line (including newline)
574)     while( (chr = fgetc( pFile )) != '\n' && chr != EOF );
575) 
576)     //info line
577)     if( fscanf( pFile, " # %255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType, infoData ) == 2 )
578)     {
579)       BlinkenMovieAppendInfo( pMovie, infoType, infoData );
580)     }
581) 
582)     //start of frame
583)     else if( fscanf( pFile, " @ %u", &duration ) == 1 )
584)     {
585)       //create new frame and append it to movie
586)       pFrame = BlinkenFrameNew( height, width, 1, 1, duration );
587)       if( pFrame != NULL )
588)       {
589)         BlinkenFrameClear( pFrame );

590)         if( BlinkenMovieAppendFrame( pMovie, pFrame ) != 0 )
591)         {
592)           BlinkenFrameFree( pFrame );
593)           pFrame = NULL;
594)         }

595)         y = 0;
596)       }
597)     }
598) 
599)     //data line
600)     else if( fscanf( pFile, "%1[01]", pixel ) == 1 )
601)     {
602)       if( pFrame != NULL )
603)       {
604)         for( x = 0; ; x++ )
605)         {
606)           BlinkenFrameSetPixel( pFrame, y, x, 0, pixel[0] == '1' ? 1 : 0 ); //set pixel
607)           if( fscanf( pFile, "%1[01]", pixel ) != 1 ) //read next pixel
608)             break;
609)         }  
610)         y++; //next row
611)       }
612)     }
613) 
614)   } //while( ! feof( pFile ) )
615) 
616)   //close file
617)   fclose( pFile );
618) 
619)   return pMovie;
620) }
621) 
622) stBlinkenMovie * BlinkenMovieLoadBmm( char * pFilename )
623) {
624)   FILE * pFile;
625)   stBlinkenMovie * pMovie;
626)   stBlinkenFrame * pFrame;
627)   int width, height, y, x, chr, duration, val;
628)   char infoType[256], infoData[1024], pixel[8];
629) 
630)   if( pFilename == NULL )
631)     return NULL;
632) 
633)   //open file
634)   pFile = fopen( pFilename, "rt" );

635)   if( pFile == NULL )
636)     return NULL;

637) 
638)   //read magic and size
639)   if( fscanf( pFile, " # BlinkenMini Movie %ux%u", &width, &height ) != 2 )
640)   {
641)     fclose( pFile );
642)     return NULL;
643)   }
644) 
645)   //allocate a new movie
646)   pMovie = BlinkenMovieNew( height, width, 1, 255 );
647)   if( pMovie == NULL )
648)   {
649)     fclose( pFile );
650)     return NULL;
651)   }
652) 
653)   //no frame yet
654)   pFrame = NULL;
655)   y = 0;
656) 
657)   //read frames
658)   while( ! feof( pFile ) )
659)   {
660)     //skip rest of previous line (including newline)
661)     while( (chr = fgetc( pFile )) != '\n' && chr != EOF );
662) 
663)     //info line
664)     if( fscanf( pFile, " # %255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType, infoData ) == 2 )
665)     {
666)       BlinkenMovieAppendInfo( pMovie, infoType, infoData );
667)     }
668) 
669)     //start of frame
670)     else if( fscanf( pFile, " @ %u", &duration ) == 1 )
671)     {
672)       //create new frame and append it to movie
673)       pFrame = BlinkenFrameNew( height, width, 1, 255, duration );
674)       if( pFrame != NULL )
675)       {
676)         BlinkenFrameClear( pFrame );

677)         if( BlinkenMovieAppendFrame( pMovie, pFrame ) != 0 )
678)         {
679)           BlinkenFrameFree( pFrame );
680)           pFrame = NULL;
681)         }

682)         y = 0;
683)       }
684)     }
685) 
686)     //data line
687)     else if( fscanf( pFile, "%7[0-9A-FXa-fx]", pixel ) == 1 )
688)     {
689)       if( pFrame != NULL )
690)       {
691)         for( x = 0; ; x++ )
692)         {
693)           if( sscanf( pixel, "%i", &val ) != 1 ) //convert pixel to number
694)             break;
695)           BlinkenFrameSetPixel( pFrame, y, x, 0, (unsigned char)val ); //set pixel
696)           fscanf( pFile, "%*[ \t]" ); //kill space
697)           if( fscanf( pFile, "%7[0-9A-FXa-fx]", pixel ) != 1 ) //read next pixel
698)             break;
699)         }  
700)         y++; //next row
701)       }
702)     }
703) 
704)   } //while( ! feof( pFile ) )
705) 
706)   //close file
707)   fclose( pFile );
708) 
709)   return pMovie;
710) }
711) 
712) stBlinkenMovie * BlinkenMovieLoadBml( char * pFilename )
713) {
714)   FILE * pFile;
715)   stBlinkenMovie * pMovie;
716)   stBlinkenFrame * pFrame;
717)   int width, height, channels, bits, maxval, chrs, y, x, c, duration, val;
718)   char buffer[2048], infoType[256], infoData[1024], pixelFormat[16], pixel[8], * ptr, chr;
719) 
720)   if( pFilename == NULL )
721)     return NULL;
722) 
723)   //open file
724)   pFile = fopen( pFilename, "rt" );

725)   if( pFile == NULL )
726)     return NULL;

727) 
728)   //no movie yet - blm tag not yet found
729)   pMovie = NULL;
730) 
731)   //no frame yet
732)   pFrame = NULL;
733)   y = 0;
734) 
735)   //read tags
736)   maxval = 0;
737)   while( ! feof( pFile ) )
738)   {
739) 
740)     //skip to just before beginning of next tag
741)     fscanf( pFile, "%*[^<]" );
742)     //skip beginning character of next tag
743)     if( fgetc( pFile ) != '<' )
744)       //end loop (no more tags)
745)       break;
746) 
747)     //no blm tag yet
748)     if( pMovie == NULL )
749)     {
750) 
751)       //blm tag
752)       if( fscanf( pFile, "blm%2047[^>]", buffer ) == 1 )
753)       {
754)         //get attributes
755)         width = 0;
756)         height = 0;

757)         channels = 1;
758)         bits = 4;
759)         maxval = 15;

760)         if( (ptr = strstr( buffer, "height=\"" )) != NULL ) //height
761)           sscanf( ptr+8, "%u", &height );
762)         if( (ptr = strstr( buffer, "width=\"" )) != NULL ) //width
763)           sscanf( ptr+7, "%u", &width );
764)         if( (ptr = strstr( buffer, "channels=\"" )) != NULL ) //channels
765)           sscanf( ptr+10, "%u", &channels );
766)         if( (ptr = strstr( buffer, "bits=\"" )) != NULL ) //bits
767)           sscanf( ptr+6, "%u", &bits );
768)         maxval = (1 << bits) - 1; //maxval
769) 
770)         //allocate a new movie
771)         pMovie = BlinkenMovieNew( height, width, channels, maxval );
772)         if( pMovie == NULL )
773)         {
774)           fclose( pFile );
775)           return NULL;
776)         }
777) 
778)         //get number of characters per channel
779)         chrs = (bits + 3) >> 2;
780)         //get fscanf formart string for reading a pixel
781)         sprintf( pixelFormat, "%%%d[0-9A-Fa-f]", chrs > 4 ? 5 : chrs ); //read max 5 chars (2 already in use by prefix)
782)         //initialize pixel buffer with hex prefix
783)         strcpy( pixel, "0x" );
784)       }
785) 
786)     } //if( pMovie == NULL )
787) 
788)     //blm tag was already found
789)     else //if( pMovie == NULL )
790)     {
791) 
792)       //title tag
793)       if( fscanf( pFile, "title>%2047[^<]", buffer ) == 1 )
794)       {
795)         //add info to movie
796)         BlinkenMovieAppendInfo( pMovie, "title", buffer );
797)       }
798) 
799)       //description tag
800)       else if( fscanf( pFile, "description>%2047[^<]", buffer ) == 1 )
801)       {
802)         //check if generic info
803)         if( sscanf( buffer, "%255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType, infoData ) == 2 )
804)           //add info to movie
805)           BlinkenMovieAppendInfo( pMovie, infoType, infoData );
806)         else
807)           //add info to movie
808)           BlinkenMovieAppendInfo( pMovie, "description", buffer );
809)       }
810) 
811)       //creator tag
812)       else if( fscanf( pFile, "creator>%2047[^<]", buffer ) == 1 )
813)       {
814)         //add info to movie
815)         BlinkenMovieAppendInfo( pMovie, "creator", buffer );
816)       }
817) 
818)       //author tag
819)       else if( fscanf( pFile, "author>%2047[^<]", buffer ) == 1 )
820)       {
821)         //add info to movie
822)         BlinkenMovieAppendInfo( pMovie, "author", buffer );
823)       }
824) 
825)       //email tag
826)       else if( fscanf( pFile, "email>%2047[^<]", buffer ) == 1 )
827)       {
828)         //add info to movie
829)         BlinkenMovieAppendInfo( pMovie, "email", buffer );
830)       }
831) 
832)       //url tag
833)       else if( fscanf( pFile, "url>%2047[^<]", buffer ) == 1 )
834)       {
835)         //add info to movie
836)         BlinkenMovieAppendInfo( pMovie, "url", buffer );
837)       }
838) 
839)       //frame tag
840)       else if( fscanf( pFile, "frame%2047[^>]", buffer ) == 1 )
841)       {
842)         //get attributes
843)         duration = 0;
844)         if( (ptr = strstr( buffer, "duration=\"" )) != NULL ) //duration
845)           sscanf( ptr+10, "%u", &duration );
846)         //create new frame and append it to movie
847)         pFrame = BlinkenFrameNew( height, width, channels, maxval, duration );
848)         if( pFrame != NULL )
849)         {
850)           BlinkenFrameClear( pFrame );

851)           if( BlinkenMovieAppendFrame( pMovie, pFrame ) != 0 )
852)           {
853)             BlinkenFrameFree( pFrame );
854)             pFrame = NULL;
855)           }

856)           y = 0;
857)         }
858)       }
859) 
860)       //row tag
861)       else if( fscanf( pFile, "row%c", &chr ) == 1 && chr == '>' )
862)       {
863)         if( pFrame != NULL )
864)         {
865)           //parse row
866)           for( x = 0; x < width; x++ )
867)           {
868)             for( c = 0; c < channels; c++ )
869)             {
870)               //read next pixel (one channel of pixel)
871)               if( fscanf( pFile, pixelFormat, pixel+2 ) != 1 )
872)               {
873)                 x = width; //also terminate x loop
874)                 break;
875)               }
876)               //convert pixel (one channel of pixel) to number
877)               if( sscanf( pixel, "%i", &val ) != 1 )
878)               {
879)                 x = width; //also terminate x loop
880)                 break;
881)               }
882)               //set pixel (one channel of pixel)
883)               BlinkenFrameSetPixel( pFrame, y, x, c, (unsigned char)val );
884)             }
885)           }
886)           y++; //next row
887)         }
888)       }
889) 
890)     } //if( pMovie == NULL ) ... else
891) 
892)   } //while( ! feof( pFile ) )
893) 
894)   //close file
895)   fclose( pFile );
896) 
897)   return pMovie;
898) }
899) 
900) stBlinkenMovie * BlinkenMovieLoadBbm( char * pFilename )
901) {
902)   FILE * pFile;
903)   stBlinkenMovie * pMovie;
904)   stBlinkenFrame * pFrame;
905)   unsigned char header[24], subHeader[6], frameStartMarker[4];
906)   unsigned long headerMagic, headerFrameCnt, headerDuration, headerFramePtr;
907)   unsigned short headerHeight, headerWidth, headerChannels, headerMaxval;
908)   unsigned long subHeaderMagic, frameStartMarkerMagic;
909)   unsigned short subHeaderSize;
910)   unsigned char * pInfoHeader, * pInfoHeaderX, * pFrameData;
911)   int len, duration, y, x, c, i;
912) 
913)   if( pFilename == NULL )
914)     return NULL;
915) 
916)   //open file
917)   pFile = fopen( pFilename, "rb" );

918)   if( pFile == NULL )
919)     return NULL;

920) 
921)   //read header
922)   if( fread( header, 1, 24, pFile ) != 24 )
923)   {
924)     fclose( pFile );
925)     return NULL;
926)   }
927)   headerMagic = (unsigned long)header[0] << 24 | (unsigned long)header[1] << 16 | (unsigned long)header[2] << 8 | (unsigned long)header[3];
928)   headerHeight = (unsigned short)header[4] << 8 | (unsigned short)header[5];
929)   headerWidth = (unsigned short)header[6] << 8 | (unsigned short)header[7];
930)   headerChannels = (unsigned short)header[8] << 8 | (unsigned short)header[9];
931)   headerMaxval = (unsigned short)header[10] << 8 | (unsigned short)header[11];
932)   headerFrameCnt = (unsigned long)header[12] << 24 | (unsigned long)header[13] << 16 | (unsigned long)header[14] << 8 | (unsigned long)header[15];
933)   headerDuration = (unsigned long)header[16] << 24 | (unsigned long)header[17] << 16 | (unsigned long)header[18] << 8 | (unsigned long)header[19];
934)   headerFramePtr = (unsigned long)header[20] << 24 | (unsigned long)header[21] << 16 | (unsigned long)header[22] << 8 | (unsigned long)header[23];
935)   //check magic
936)   if( headerMagic != 0x23542666 )
937)   {
938)     fclose( pFile );
939)     return NULL;
940)   }
941) 
942)   //allocate a new movie
943)   pMovie = BlinkenMovieNew( headerHeight, headerWidth, headerChannels, headerMaxval );
944)   if( pMovie == NULL )
945)   {
946)     fclose( pFile );
947)     return NULL;
948)   }
949) 
950)   //read subheaders
951)   while( ftell( pFile ) + 6 <= (long)headerFramePtr )
952)   {
953)     if( fread( subHeader, 1, 6, pFile ) != 6 )
954)     {
955)       BlinkenMovieFree( pMovie );
956)       fclose( pFile );
957)       return NULL;
958)     }
959)     subHeaderMagic = (unsigned long)subHeader[0] << 24 | (unsigned long)subHeader[1] << 16 | (unsigned long)subHeader[2] << 8 | (unsigned long)subHeader[3];
960)     subHeaderSize = (unsigned short)subHeader[4] << 8 | (unsigned short)subHeader[5];
961) 
962)     //header fits into gap to frame start
963)     if( subHeaderSize >= 6 && ftell( pFile ) + subHeaderSize - 6 <= (long)headerFramePtr )
964)     {
965)       //info header
966)       if( subHeaderMagic == 0x696E666F ) //'i' 'n' 'f' 'o'
967)       {
968)         //read rest of info header
969)         pInfoHeader = (unsigned char *)malloc( subHeaderSize - 6 );
970)         if( pInfoHeader == NULL )
971)         {
972)           BlinkenMovieFree( pMovie );
973)           fclose( pFile );
974)           return NULL;
975)         }
976)         if( fread( pInfoHeader, 1, subHeaderSize - 6, pFile ) != (unsigned short)(subHeaderSize - 6) )
977)         {
978)           free( pInfoHeader );
979)           BlinkenMovieFree( pMovie );
980)           fclose( pFile );
981)           return NULL;
982)         }
983)         //parse information
984)         if( (pInfoHeaderX = memchr( pInfoHeader, 0, subHeaderSize - 6 )) != NULL )
985)         {
986)           pInfoHeaderX++;
987)           len = pInfoHeaderX - pInfoHeader;
988)           if( memchr( pInfoHeaderX, 0, subHeaderSize - 6 - len ) != NULL )
989)             BlinkenMovieAppendInfo( pMovie, pInfoHeader, pInfoHeaderX );
990)         }
991)         free( pInfoHeader );
992)       }
993) 
994)       //unknown subHeader
995)       else
996)         //skip
997)         fseek( pFile, subHeaderSize - 6, SEEK_CUR );
998) 
999)     } //if( ftell( pFile ) ...
1000)   } //while( ftell( pFile ) ...
1001) 
1002)   //seek to start of frames
1003)   fseek( pFile, headerFramePtr, SEEK_SET );
1004) 
1005)   //read frame start marker
1006)   if( fread( frameStartMarker, 1, 4, pFile ) != 4 )
1007)   {
1008)     BlinkenMovieFree( pMovie );
1009)     fclose( pFile );
1010)     return NULL;
1011)   }
1012)   frameStartMarkerMagic = (unsigned long)frameStartMarker[0] << 24 | (unsigned long)frameStartMarker[1] << 16 | (unsigned long)frameStartMarker[2] << 8 | (unsigned long)frameStartMarker[3];
1013)   if( frameStartMarkerMagic != 0x66726D73 ) //'f' 'r' 'm' 's'
1014)   {
1015)     BlinkenMovieFree( pMovie );
1016)     fclose( pFile );
1017)     return NULL;
1018)   }
1019) 
1020)   //allocate buffer for frame data
1021)   len = 2 + headerHeight * headerWidth * headerChannels;
1022)   pFrameData = (unsigned char *)malloc( len );
1023)   if( pFrameData == NULL )
1024)   {
1025)     BlinkenMovieFree( pMovie );
1026)     fclose( pFile );
1027)     return NULL;
1028)   }
1029) 
1030)   //read frames
1031)   for( ; ; )
1032)   {
1033)     //read frame
1034)     if( fread( pFrameData, 1, len, pFile ) != (unsigned int)len )
1035)       break;
1036)     duration = (unsigned short)pFrameData[0] << 8 | (unsigned short)pFrameData[1];
1037)     //build frame and append it to movie
1038)     pFrame = BlinkenFrameNew( headerHeight, headerWidth, headerChannels, headerMaxval, duration );
1039)     if( pFrame == NULL )
1040)       break;
1041)     i = 2;
1042)     for( y = 0; y < headerHeight; y++ )
1043)       for( x = 0; x < headerWidth; x++ )
1044)         for( c = 0; c < headerChannels; c++, i++ )
1045)           BlinkenFrameSetPixel( pFrame, y, x, c, pFrameData[i] );

1046)     if( BlinkenMovieAppendFrame( pMovie, pFrame ) != 0 )
1047)     {
1048)       BlinkenFrameFree( pFrame );
1049)       pFrame = NULL;
1050)     }

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

1410) void BlinkenMovieSend( stBlinkenMovie * pMovie, int udpSocket, etBlinkenProto proto )
1411) //udp socket must be "connected"
1412) {
1413)   int i, len;
1414)   char buffer[65536]; //64kB is more tham maximum UDP size
1415) 
1416)   for( i = 0; i < pMovie->frameCnt; i++ )
1417)   {
1418)     len = BlinkenFrameToNetwork( pMovie->ppFrames[i], proto, buffer, sizeof( buffer ) );
1419)     if( len > 0 )
1420)       send( udpSocket, buffer, len, 0 );
1421)     usleep( BlinkenFrameGetDuration( pMovie->ppFrames[i] ) * 1000 );
1422)   }
1423) }
1424) 
1425) stBlinkenMovie * BlinkenMovieReceive( int udpSocket, int timeout, etBlinkenProto * pProto )
1426) //udp socket must be "bound" and should be "connected"
1427) //after timeout ms of no reception, the movie is considered to be complete
1428) //returns protocol in *pProto if pProto not NULL
1429) {
1430)   stBlinkenMovie * pMovie;
1431)   stBlinkenFrame * pLastFrame, * pFrame;
1432)   etBlinkenProto proto, p;
1433)   fd_set readFds;
1434)   struct timeval timeo, lastTime, curTime;

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