BlinkenLib

BlinkenLib/BlinkenMng.c   1) /* BlinkenLib

BlinkenLib/BlinkenMng.c   2)    Copyright 2004-2014 Stefan Schuermans <stefan@schuermans.info>

BlinkenLib/BlinkenMng.c   3)    Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html
BlinkenLib/BlinkenMng.c   4)    a blinkenarea.org project */

BlinkenLib/BlinkenMng.c   5) 
BlinkenLib/BlinkenMng.c   6) #include <stdio.h>
BlinkenLib/BlinkenMng.c   7) #include <stdlib.h>
BlinkenLib/BlinkenMng.c   8) #include <strings.h>
BlinkenLib/BlinkenMng.c   9) 
BlinkenLib/BlinkenMng.c  10) #include <zlib.h>
BlinkenLib/BlinkenMng.c  11) 
BlinkenLib/BlinkenMng.c  12) #define MNG_INCLUDE_WRITE_PROCS
BlinkenLib/BlinkenMng.c  13) #define MNG_ACCESS_CHUNKS
BlinkenLib/BlinkenMng.c  14) #define MNG_SUPPORT_READ
BlinkenLib/BlinkenMng.c  15) #define MNG_SUPPORT_DISPLAY
BlinkenLib/BlinkenMng.c  16) #define MNG_SUPPORT_WRITE
BlinkenLib/BlinkenMng.c  17) #include <libmng.h>
BlinkenLib/BlinkenMng.c  18) 
BlinkenLib/BlinkenMng.c  19) #include <BlinkenLib/config.h>
BlinkenLib/BlinkenMng.c  20) #include <BlinkenLib/BlinkenFrame.h>
BlinkenLib/BlinkenMng.c  21) #include <BlinkenLib/BlinkenMovie.h>

src/BlinkenMng.c         22) 
src/BlinkenMng.c         23) #include "BlinkenConstants.h"
src/BlinkenMng.c         24) #include "BlinkenMng.h"

BlinkenLib/BlinkenMng.c  25) 
BlinkenLib/BlinkenMng.c  26) // type for state of the MNG read/write process
BlinkenLib/BlinkenMng.c  27) typedef struct _BlMng_userdata {

BlinkenLib/BlinkenMng.c  28)   FILE *hFile;  // handle of open file
BlinkenLib/BlinkenMng.c  29)   unsigned int width;   // size of canvas

BlinkenLib/BlinkenMng.c  30)   unsigned int height;

BlinkenLib/BlinkenMng.c  31)   unsigned char *canvas;        // canvas (i.e. pixel data, size is height *
BlinkenLib/BlinkenMng.c  32)   // width * 3)
BlinkenLib/BlinkenMng.c  33)   unsigned int counter_msec;    // current number of milliseconds
BlinkenLib/BlinkenMng.c  34)   unsigned int timer_msec;      // the MNG library will be called after this
BlinkenLib/BlinkenMng.c  35)   // number of milliseconds
BlinkenLib/BlinkenMng.c  36)   stBlinkenMovie *movie;        // movie being created

BlinkenLib/BlinkenMng.c  37) } BlMng_userdata;
BlinkenLib/BlinkenMng.c  38) 

BlinkenLib/BlinkenMng.c  39) mng_ptr BlMng_alloc(mng_size_t iSize)

BlinkenLib/BlinkenMng.c  40) {

BlinkenLib/BlinkenMng.c  41)   void *ptr = malloc(iSize);
BlinkenLib/BlinkenMng.c  42)   if (ptr != NULL)
BlinkenLib/BlinkenMng.c  43)     memset(ptr, 0, iSize);
BlinkenLib/BlinkenMng.c  44)   return (mng_ptr) ptr;

BlinkenLib/BlinkenMng.c  45) }
BlinkenLib/BlinkenMng.c  46) 

BlinkenLib/BlinkenMng.c  47) void BlMng_free(mng_ptr pPtr, mng_size_t __attribute__ ((unused)) iSize)

BlinkenLib/BlinkenMng.c  48) {

BlinkenLib/BlinkenMng.c  49)   free(pPtr);

BlinkenLib/BlinkenMng.c  50) }
BlinkenLib/BlinkenMng.c  51) 

BlinkenLib/BlinkenMng.c  52) mng_bool BlMng_openstream(mng_handle __attribute__ ((unused)) hMNG)

BlinkenLib/BlinkenMng.c  53) {
BlinkenLib/BlinkenMng.c  54)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c  55) }
BlinkenLib/BlinkenMng.c  56) 

BlinkenLib/BlinkenMng.c  57) mng_bool BlMng_closestream(mng_handle __attribute__ ((unused)) hMNG)

BlinkenLib/BlinkenMng.c  58) {
BlinkenLib/BlinkenMng.c  59)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c  60) }
BlinkenLib/BlinkenMng.c  61) 
BlinkenLib/BlinkenMng.c  62) // read data from the open file

BlinkenLib/BlinkenMng.c  63) mng_bool BlMng_readdata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,
BlinkenLib/BlinkenMng.c  64)                         mng_uint32 * iRead)

BlinkenLib/BlinkenMng.c  65) {

BlinkenLib/BlinkenMng.c  66)   BlMng_userdata *data = (BlMng_userdata *) mng_get_userdata(hMNG);
BlinkenLib/BlinkenMng.c  67)   *iRead = fread(pBuf, 1, iSize, data->hFile);

BlinkenLib/BlinkenMng.c  68)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c  69) }
BlinkenLib/BlinkenMng.c  70) 
BlinkenLib/BlinkenMng.c  71) // write data to the open file

BlinkenLib/BlinkenMng.c  72) mng_bool BlMng_writedata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,
BlinkenLib/BlinkenMng.c  73)                          mng_uint32 * iWritten)

BlinkenLib/BlinkenMng.c  74) {

BlinkenLib/BlinkenMng.c  75)   BlMng_userdata *data = (BlMng_userdata *) mng_get_userdata(hMNG);
BlinkenLib/BlinkenMng.c  76)   *iWritten = fwrite(pBuf, 1, iSize, data->hFile);

BlinkenLib/BlinkenMng.c  77)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c  78) }
BlinkenLib/BlinkenMng.c  79) 
BlinkenLib/BlinkenMng.c  80) // MNG library has processed the header information

BlinkenLib/BlinkenMng.c  81) mng_bool BlMng_processheader(mng_handle hMNG, mng_uint32 iWidth,
BlinkenLib/BlinkenMng.c  82)                              mng_uint32 iHeight)

BlinkenLib/BlinkenMng.c  83) {

BlinkenLib/BlinkenMng.c  84)   BlMng_userdata *data = (BlMng_userdata *) mng_get_userdata(hMNG);

BlinkenLib/BlinkenMng.c  85) 
BlinkenLib/BlinkenMng.c  86)   // free old canvas (in case there is already one)

BlinkenLib/BlinkenMng.c  87)   if (data->canvas != NULL) {
BlinkenLib/BlinkenMng.c  88)     free(data->canvas);

BlinkenLib/BlinkenMng.c  89)     data->canvas = NULL;

BlinkenLib/BlinkenMng.c  90)     printf("</blm>\n");

BlinkenLib/BlinkenMng.c  91)   }
BlinkenLib/BlinkenMng.c  92)   // free old movie

BlinkenLib/BlinkenMng.c  93)   if (data->movie) {
BlinkenLib/BlinkenMng.c  94)     BlinkenMovieFree(data->movie);

BlinkenLib/BlinkenMng.c  95)     data->movie = NULL;
BlinkenLib/BlinkenMng.c  96)   }
BlinkenLib/BlinkenMng.c  97)   // remember dimensions and allocate new canvas
BlinkenLib/BlinkenMng.c  98)   data->width = iWidth;
BlinkenLib/BlinkenMng.c  99)   data->height = iHeight;

BlinkenLib/BlinkenMng.c 100)   data->canvas = (unsigned char *)malloc(iHeight * iWidth * 3);
BlinkenLib/BlinkenMng.c 101)   if (data->canvas == NULL)

BlinkenLib/BlinkenMng.c 102)     return MNG_FALSE;
BlinkenLib/BlinkenMng.c 103)   data->counter_msec = 0;
BlinkenLib/BlinkenMng.c 104)   data->timer_msec = 0;
BlinkenLib/BlinkenMng.c 105) 
BlinkenLib/BlinkenMng.c 106)   // create new empty movie

BlinkenLib/BlinkenMng.c 107)   data->movie = BlinkenMovieNew(iHeight, iWidth, 3, 255);       // always 24
BlinkenLib/BlinkenMng.c 108)   // bit RGB
BlinkenLib/BlinkenMng.c 109)   if (data->movie == NULL)

BlinkenLib/BlinkenMng.c 110)     return MNG_FALSE;
BlinkenLib/BlinkenMng.c 111) 

BlinkenLib/BlinkenMng.c 112)   return MNG_TRUE;

BlinkenLib/BlinkenMng.c 113) }
BlinkenLib/BlinkenMng.c 114) 
BlinkenLib/BlinkenMng.c 115) // get access to a line of the canvas

BlinkenLib/BlinkenMng.c 116) mng_ptr BlMng_getcanvasline(mng_handle hMNG, mng_uint32 iLinenr)

BlinkenLib/BlinkenMng.c 117) {

BlinkenLib/BlinkenMng.c 118)   BlMng_userdata *data = (BlMng_userdata *) mng_get_userdata(hMNG);

BlinkenLib/BlinkenMng.c 119) 
BlinkenLib/BlinkenMng.c 120)   // return pointer to line

BlinkenLib/BlinkenMng.c 121)   if (iLinenr < data->height)
BlinkenLib/BlinkenMng.c 122)     return (mng_ptr) (data->canvas + iLinenr * data->width * 3);

BlinkenLib/BlinkenMng.c 123)   else

BlinkenLib/BlinkenMng.c 124)     return (mng_ptr) NULL;

BlinkenLib/BlinkenMng.c 125) }
BlinkenLib/BlinkenMng.c 126) 
BlinkenLib/BlinkenMng.c 127) // the MNG library thinks that (a part of) the canvas should be shown

BlinkenLib/BlinkenMng.c 128) mng_bool BlMng_refresh(mng_handle __attribute__ ((unused)) hMNG, mng_uint32
BlinkenLib/BlinkenMng.c 129)                        __attribute__ ((unused)) iX, mng_uint32
BlinkenLib/BlinkenMng.c 130)                        __attribute__ ((unused)) iY, mng_uint32
BlinkenLib/BlinkenMng.c 131)                        __attribute__ ((unused)) iWidth, mng_uint32
BlinkenLib/BlinkenMng.c 132)                        __attribute__ ((unused)) iHeight)

BlinkenLib/BlinkenMng.c 133) {

BlinkenLib/BlinkenMng.c 134)   // nothing to do here for BlinkenLib as we are only converting and not
BlinkenLib/BlinkenMng.c 135)   // displaying

BlinkenLib/BlinkenMng.c 136)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c 137) }
BlinkenLib/BlinkenMng.c 138) 
BlinkenLib/BlinkenMng.c 139) // the MNG library want to know how many milliseconds have passed

BlinkenLib/BlinkenMng.c 140) mng_uint32 BlMng_gettickcount(mng_handle hMNG)

BlinkenLib/BlinkenMng.c 141) {

BlinkenLib/BlinkenMng.c 142)   BlMng_userdata *data = (BlMng_userdata *) mng_get_userdata(hMNG);

BlinkenLib/BlinkenMng.c 143) 

BlinkenLib/BlinkenMng.c 144)   // just return the current number of milliseconds (only converting, do not
BlinkenLib/BlinkenMng.c 145)   // use real time for this)

BlinkenLib/BlinkenMng.c 146)   return data->counter_msec;
BlinkenLib/BlinkenMng.c 147) }
BlinkenLib/BlinkenMng.c 148) 
BlinkenLib/BlinkenMng.c 149) // the MNG library wants to be be called again after some milliseconds

BlinkenLib/BlinkenMng.c 150) mng_bool BlMng_settimer(mng_handle hMNG, mng_uint32 iMsecs)

BlinkenLib/BlinkenMng.c 151) {

BlinkenLib/BlinkenMng.c 152)   BlMng_userdata *data = (BlMng_userdata *) mng_get_userdata(hMNG);

BlinkenLib/BlinkenMng.c 153) 
BlinkenLib/BlinkenMng.c 154)   // just remember the number of milliseconds
BlinkenLib/BlinkenMng.c 155)   data->timer_msec = iMsecs;
BlinkenLib/BlinkenMng.c 156) 
BlinkenLib/BlinkenMng.c 157)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c 158) }
BlinkenLib/BlinkenMng.c 159) 
BlinkenLib/BlinkenMng.c 160) // save as new frame to current movie

BlinkenLib/BlinkenMng.c 161) void BlMng_save_frame(stBlinkenMovie *movie, unsigned int msec,

BlinkenLib/BlinkenMng.c 162)                       unsigned int width, unsigned int height,
BlinkenLib/BlinkenMng.c 163)                       unsigned char *data)

BlinkenLib/BlinkenMng.c 164) {

BlinkenLib/BlinkenMng.c 165)   stBlinkenFrame *frame;

BlinkenLib/BlinkenMng.c 166)   unsigned int c, x, y;
BlinkenLib/BlinkenMng.c 167) 
BlinkenLib/BlinkenMng.c 168)   // check that a movie is present

BlinkenLib/BlinkenMng.c 169)   if (movie == NULL)

BlinkenLib/BlinkenMng.c 170)     return;
BlinkenLib/BlinkenMng.c 171) 
BlinkenLib/BlinkenMng.c 172)   // create new frame (24 bit RGB)

BlinkenLib/BlinkenMng.c 173)   frame = BlinkenFrameNew(height, width, 3, 255, msec);
BlinkenLib/BlinkenMng.c 174)   if (frame == NULL)

BlinkenLib/BlinkenMng.c 175)     return;
BlinkenLib/BlinkenMng.c 176) 
BlinkenLib/BlinkenMng.c 177)   // set pixels of frame

BlinkenLib/BlinkenMng.c 178)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenMng.c 179)     for (x = 0; x < width; x++) {
BlinkenLib/BlinkenMng.c 180)       for (c = 0; c < 3; c++) {
BlinkenLib/BlinkenMng.c 181)         BlinkenFrameSetPixel(frame, y, x, c, *data);

BlinkenLib/BlinkenMng.c 182)         data++;
BlinkenLib/BlinkenMng.c 183)       }
BlinkenLib/BlinkenMng.c 184)     }
BlinkenLib/BlinkenMng.c 185)   }
BlinkenLib/BlinkenMng.c 186) 
BlinkenLib/BlinkenMng.c 187)   // append frame to movie

BlinkenLib/BlinkenMng.c 188)   if (BlinkenMovieAppendFrame(movie, frame) != 0)
BlinkenLib/BlinkenMng.c 189)     BlinkenFrameFree(frame);

BlinkenLib/BlinkenMng.c 190) }
BlinkenLib/BlinkenMng.c 191) 
BlinkenLib/BlinkenMng.c 192) // compress pixel data in a frame

BlinkenLib/BlinkenMng.c 193) void BlMng_compress_frame(stBlinkenFrame *frame, unsigned char **p_out_ptr,

BlinkenLib/BlinkenMng.c 194)                           unsigned int *p_out_len)

BlinkenLib/BlinkenMng.c 195) {

BlinkenLib/BlinkenMng.c 196)   unsigned int width = BlinkenFrameGetWidth(frame);
BlinkenLib/BlinkenMng.c 197)   unsigned int height = BlinkenFrameGetHeight(frame);
BlinkenLib/BlinkenMng.c 198)   // channels is always 3, maxval is always 255 - this function is only
BlinkenLib/BlinkenMng.c 199)   // called with frames from moivies with those parameters

BlinkenLib/BlinkenMng.c 200)   unsigned int row_stride, raw_len, y, x, c;

BlinkenLib/BlinkenMng.c 201)   unsigned char *raw_ptr, *ptr, *out_ptr;

BlinkenLib/BlinkenMng.c 202)   unsigned long out_len;
BlinkenLib/BlinkenMng.c 203) 
BlinkenLib/BlinkenMng.c 204)   // assemble raw data to compress

BlinkenLib/BlinkenMng.c 205)   row_stride = width * 3 + 1;   // rows are preceeded by filter ID

BlinkenLib/BlinkenMng.c 206)   raw_len = row_stride * height;

BlinkenLib/BlinkenMng.c 207)   raw_ptr = (unsigned char *)malloc(raw_len);

BlinkenLib/BlinkenMng.c 208)   ptr = raw_ptr;

BlinkenLib/BlinkenMng.c 209)   for (y = 0; y < height; y++) {

BlinkenLib/BlinkenMng.c 210)     // filter ID

BlinkenLib/BlinkenMng.c 211)     *ptr = MNG_FILTER_NONE;     // no filtering

BlinkenLib/BlinkenMng.c 212)     ptr++;
BlinkenLib/BlinkenMng.c 213)     // pixel data of row

BlinkenLib/BlinkenMng.c 214)     for (x = 0; x < width; x++) {
BlinkenLib/BlinkenMng.c 215)       for (c = 0; c < 3; c++) {
BlinkenLib/BlinkenMng.c 216)         *ptr = BlinkenFrameGetPixel(frame, y, x, c);

BlinkenLib/BlinkenMng.c 217)         ptr++;
BlinkenLib/BlinkenMng.c 218)       }
BlinkenLib/BlinkenMng.c 219)     }

BlinkenLib/BlinkenMng.c 220)   }     // for( y ...

BlinkenLib/BlinkenMng.c 221) 
BlinkenLib/BlinkenMng.c 222)   // compress data

BlinkenLib/BlinkenMng.c 223)   out_len = raw_len + (raw_len + 999) / 1000 + 12;      // must be at least
BlinkenLib/BlinkenMng.c 224)   // <source length> *
BlinkenLib/BlinkenMng.c 225)   // 1.001 + 12
BlinkenLib/BlinkenMng.c 226)   out_ptr = (unsigned char *)malloc(out_len);
BlinkenLib/BlinkenMng.c 227)   compress2(out_ptr, &out_len, raw_ptr, raw_len, Z_BEST_COMPRESSION);
BlinkenLib/BlinkenMng.c 228)   free(raw_ptr);

BlinkenLib/BlinkenMng.c 229) 
BlinkenLib/BlinkenMng.c 230)   // return allocated compressed data
BlinkenLib/BlinkenMng.c 231)   *p_out_ptr = out_ptr;
BlinkenLib/BlinkenMng.c 232)   *p_out_len = (unsigned int)out_len;
BlinkenLib/BlinkenMng.c 233) }
BlinkenLib/BlinkenMng.c 234) 
BlinkenLib/BlinkenMng.c 235) // load a MNG file as BlinkenMovie

BlinkenLib/BlinkenMng.c 236) stBlinkenMovie *BlinkenMngLoad(const char *pFilename)

BlinkenLib/BlinkenMng.c 237) {

BlinkenLib/BlinkenMng.c 238)   BlMng_userdata *data;

BlinkenLib/BlinkenMng.c 239)   mng_handle hMNG;

BlinkenLib/BlinkenMng.c 240)   stBlinkenMovie *movie = NULL;

BlinkenLib/BlinkenMng.c 241) 

BlinkenLib/BlinkenMng.c 242)   if (pFilename == NULL)

BlinkenLib/BlinkenMng.c 243)     return NULL;
BlinkenLib/BlinkenMng.c 244) 
BlinkenLib/BlinkenMng.c 245)   // create new structure for state of operation

BlinkenLib/BlinkenMng.c 246)   data = (BlMng_userdata *) malloc(sizeof(BlMng_userdata));
BlinkenLib/BlinkenMng.c 247)   if (data != NULL) {

BlinkenLib/BlinkenMng.c 248)     data->hFile = NULL;
BlinkenLib/BlinkenMng.c 249)     data->width = 0;
BlinkenLib/BlinkenMng.c 250)     data->height = 0;
BlinkenLib/BlinkenMng.c 251)     data->canvas = NULL;
BlinkenLib/BlinkenMng.c 252)     data->movie = NULL;
BlinkenLib/BlinkenMng.c 253) 
BlinkenLib/BlinkenMng.c 254)     // open MNG file for reading

BlinkenLib/BlinkenMng.c 255)     data->hFile = fopen(pFilename, "rb");
BlinkenLib/BlinkenMng.c 256)     if (data->hFile != NULL) {

BlinkenLib/BlinkenMng.c 257) 
BlinkenLib/BlinkenMng.c 258)       // initialize MNG library

BlinkenLib/BlinkenMng.c 259)       hMNG =
BlinkenLib/BlinkenMng.c 260)           mng_initialize((mng_ptr) data, BlMng_alloc, BlMng_free, MNG_NULL);
BlinkenLib/BlinkenMng.c 261)       if (hMNG) {

BlinkenLib/BlinkenMng.c 262) 
BlinkenLib/BlinkenMng.c 263)         // set MNG callbacks

BlinkenLib/BlinkenMng.c 264)         if (mng_setcb_openstream(hMNG, BlMng_openstream) == 0 &&
BlinkenLib/BlinkenMng.c 265)             mng_setcb_closestream(hMNG, BlMng_closestream) == 0 &&
BlinkenLib/BlinkenMng.c 266)             mng_setcb_readdata(hMNG, BlMng_readdata) == 0 &&
BlinkenLib/BlinkenMng.c 267)             mng_setcb_processheader(hMNG, BlMng_processheader) == 0 &&
BlinkenLib/BlinkenMng.c 268)             mng_setcb_getcanvasline(hMNG, BlMng_getcanvasline) == 0 &&
BlinkenLib/BlinkenMng.c 269)             mng_setcb_refresh(hMNG, BlMng_refresh) == 0 &&
BlinkenLib/BlinkenMng.c 270)             mng_setcb_gettickcount(hMNG, BlMng_gettickcount) == 0 &&
BlinkenLib/BlinkenMng.c 271)             mng_setcb_settimer(hMNG, BlMng_settimer) == 0 &&
BlinkenLib/BlinkenMng.c 272)             mng_set_canvasstyle(hMNG, MNG_CANVAS_RGB8) == 0) {

BlinkenLib/BlinkenMng.c 273) 

BlinkenLib/BlinkenMng.c 274)           // request not to do lopping
BlinkenLib/BlinkenMng.c 275)           // (stop with error at end of first iteration intead)

BlinkenLib/BlinkenMng.c 276)           if (mng_set_cacheplayback(hMNG, MNG_FALSE) == 0) {

BlinkenLib/BlinkenMng.c 277) 

BlinkenLib/BlinkenMng.c 278)             // read MNG file to memory and start "displaying"

BlinkenLib/BlinkenMng.c 279)             mng_retcode iRC = mng_readdisplay(hMNG);
BlinkenLib/BlinkenMng.c 280)             if (iRC == 0 || iRC == MNG_NEEDTIMERWAIT) {

BlinkenLib/BlinkenMng.c 281) 
BlinkenLib/BlinkenMng.c 282)               // "display" loop
BlinkenLib/BlinkenMng.c 283)               int b_saved = 0;

BlinkenLib/BlinkenMng.c 284)               unsigned int frame_idx = 0;

BlinkenLib/BlinkenMng.c 285)               while (iRC == MNG_NEEDTIMERWAIT && data->timer_msec > 0) {

BlinkenLib/BlinkenMng.c 286) 
BlinkenLib/BlinkenMng.c 287)                 // save fame to movie

BlinkenLib/BlinkenMng.c 288)                 BlMng_save_frame(data->movie, data->timer_msec, data->width,
BlinkenLib/BlinkenMng.c 289)                                  data->height, data->canvas);

BlinkenLib/BlinkenMng.c 290)                 b_saved = 1;

BlinkenLib/BlinkenMng.c 291)                 ++frame_idx;

BlinkenLib/BlinkenMng.c 292) 

BlinkenLib/BlinkenMng.c 293)                 // let required time elapse for MNG library

BlinkenLib/BlinkenMng.c 294)                 data->counter_msec += data->timer_msec;
BlinkenLib/BlinkenMng.c 295)                 data->timer_msec = 0;
BlinkenLib/BlinkenMng.c 296) 
BlinkenLib/BlinkenMng.c 297)                 // "display" next frame

BlinkenLib/BlinkenMng.c 298)                 iRC = mng_display_resume(hMNG);
BlinkenLib/BlinkenMng.c 299)                 if (iRC != 0 && iRC != MNG_NEEDTIMERWAIT)

BlinkenLib/BlinkenMng.c 300)                   break;
BlinkenLib/BlinkenMng.c 301) 
BlinkenLib/BlinkenMng.c 302)               } // while( iRC == MNG_NEEDTIMERWAIT && data->timer_msec > 0 )
BlinkenLib/BlinkenMng.c 303) 

BlinkenLib/BlinkenMng.c 304)               // save single frame if no frame saved yet (i.e. not an
BlinkenLib/BlinkenMng.c 305)               // animated MNG image)
BlinkenLib/BlinkenMng.c 306)               if (!b_saved)
BlinkenLib/BlinkenMng.c 307)                 BlMng_save_frame(data->movie, data->timer_msec, data->width,
BlinkenLib/BlinkenMng.c 308)                                  data->height, data->canvas);
BlinkenLib/BlinkenMng.c 309) 
BlinkenLib/BlinkenMng.c 310)               // if movie has more than one frame and the last frame is empty 
BlinkenLib/BlinkenMng.c 311)               // 

BlinkenLib/BlinkenMng.c 312)               // 
BlinkenLib/BlinkenMng.c 313)               // 
BlinkenLib/BlinkenMng.c 314)               // 
BlinkenLib/BlinkenMng.c 315)               // 

BlinkenLib/BlinkenMng.c 316)               // with duration of 1ms, remove last frame
BlinkenLib/BlinkenMng.c 317)               // - a black frame with 1ms duration is inserted by MNG library 
BlinkenLib/BlinkenMng.c 318)               // 

BlinkenLib/BlinkenMng.c 319)               // 
BlinkenLib/BlinkenMng.c 320)               // 
BlinkenLib/BlinkenMng.c 321)               // 
BlinkenLib/BlinkenMng.c 322)               // 

BlinkenLib/BlinkenMng.c 323)               // when MNG requests to clean canvas after displaying
BlinkenLib/BlinkenMng.c 324)               // - the reqauest to clear canvas after end of MNG anmation is
BlinkenLib/BlinkenMng.c 325)               // needed to preserve duration of last frame (when converting
BlinkenLib/BlinkenMng.c 326)               // from native format to MNG)
BlinkenLib/BlinkenMng.c 327)               // - remove this frame that is created by the described side
BlinkenLib/BlinkenMng.c 328)               // effect

BlinkenLib/BlinkenMng.c 329)               {

BlinkenLib/BlinkenMng.c 330)                 unsigned int frame_cnt = BlinkenMovieGetFrameCnt(data->movie);
BlinkenLib/BlinkenMng.c 331)                 if (frame_cnt >= 1) {
BlinkenLib/BlinkenMng.c 332)                   stBlinkenFrame *frame =
BlinkenLib/BlinkenMng.c 333)                       BlinkenMovieGetFrame(data->movie, frame_cnt - 1);
BlinkenLib/BlinkenMng.c 334)                   if (frame != NULL && BlinkenFrameIsEmpty(frame))
BlinkenLib/BlinkenMng.c 335)                     BlinkenMovieDeleteFrame(data->movie, frame_cnt - 1);

BlinkenLib/BlinkenMng.c 336)                 }
BlinkenLib/BlinkenMng.c 337)               }
BlinkenLib/BlinkenMng.c 338) 
BlinkenLib/BlinkenMng.c 339)               // stop "displaying"

BlinkenLib/BlinkenMng.c 340)               mng_display_freeze(hMNG);
BlinkenLib/BlinkenMng.c 341) 
BlinkenLib/BlinkenMng.c 342)             }   // if( iRC == 0 || iRC == MNG_NEEDTIMERWAIT )
BlinkenLib/BlinkenMng.c 343) 
BlinkenLib/BlinkenMng.c 344)           }     // if (mng_set_cacheplayback ... )
BlinkenLib/BlinkenMng.c 345) 
BlinkenLib/BlinkenMng.c 346)         }       // if( mng_setcb_... )
BlinkenLib/BlinkenMng.c 347) 

BlinkenLib/BlinkenMng.c 348)         // shutdown MNG library

BlinkenLib/BlinkenMng.c 349)         mng_cleanup(&hMNG);

BlinkenLib/BlinkenMng.c 350) 
BlinkenLib/BlinkenMng.c 351)       } // if( hMNG )
BlinkenLib/BlinkenMng.c 352) 
BlinkenLib/BlinkenMng.c 353)       // close file

BlinkenLib/BlinkenMng.c 354)       fclose(data->hFile);

BlinkenLib/BlinkenMng.c 355) 

BlinkenLib/BlinkenMng.c 356)     }   // if( data->hFile != NULL )

BlinkenLib/BlinkenMng.c 357) 
BlinkenLib/BlinkenMng.c 358)     // fetch created movie from state
BlinkenLib/BlinkenMng.c 359)     movie = data->movie;
BlinkenLib/BlinkenMng.c 360)     data->movie = NULL;
BlinkenLib/BlinkenMng.c 361) 
BlinkenLib/BlinkenMng.c 362)     // free data structure for state

BlinkenLib/BlinkenMng.c 363)     if (data->canvas != NULL)
BlinkenLib/BlinkenMng.c 364)       free(data->canvas);
BlinkenLib/BlinkenMng.c 365)     free(data);

BlinkenLib/BlinkenMng.c 366) 

BlinkenLib/BlinkenMng.c 367)   }     // if( data != NULL )

BlinkenLib/BlinkenMng.c 368) 
BlinkenLib/BlinkenMng.c 369)   return movie;
BlinkenLib/BlinkenMng.c 370) }
BlinkenLib/BlinkenMng.c 371) 

BlinkenLib/BlinkenMng.c 372) int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)

BlinkenLib/BlinkenMng.c 373) {

BlinkenLib/BlinkenMng.c 374)   BlMng_userdata *data;

BlinkenLib/BlinkenMng.c 375)   mng_handle hMNG;
BlinkenLib/BlinkenMng.c 376)   int b_success = 0;
BlinkenLib/BlinkenMng.c 377) 

BlinkenLib/BlinkenMng.c 378)   if (pMovie == NULL || pFilename == NULL)

BlinkenLib/BlinkenMng.c 379)     return -1;
BlinkenLib/BlinkenMng.c 380) 
BlinkenLib/BlinkenMng.c 381)   // create new structure for state of operation

BlinkenLib/BlinkenMng.c 382)   data = (BlMng_userdata *) malloc(sizeof(BlMng_userdata));
BlinkenLib/BlinkenMng.c 383)   if (data != NULL) {

BlinkenLib/BlinkenMng.c 384)     data->hFile = NULL;

BlinkenLib/BlinkenMng.c 385)     data->width = BlinkenMovieGetWidth(pMovie);
BlinkenLib/BlinkenMng.c 386)     data->height = BlinkenMovieGetHeight(pMovie);

BlinkenLib/BlinkenMng.c 387)     data->canvas = NULL;
BlinkenLib/BlinkenMng.c 388)     data->movie = NULL;
BlinkenLib/BlinkenMng.c 389) 
BlinkenLib/BlinkenMng.c 390)     // convert movie to suitable format

BlinkenLib/BlinkenMng.c 391)     data->movie = BlinkenMovieClone(pMovie);
BlinkenLib/BlinkenMng.c 392)     if (data->movie != NULL) {
BlinkenLib/BlinkenMng.c 393)       BlinkenMovieResize(data->movie, data->height, data->width, 3, 255);

BlinkenLib/BlinkenMng.c 394) 
BlinkenLib/BlinkenMng.c 395)       // open MNG file for writing

BlinkenLib/BlinkenMng.c 396)       data->hFile = fopen(pFilename, "wb");
BlinkenLib/BlinkenMng.c 397)       if (data->hFile != NULL) {

BlinkenLib/BlinkenMng.c 398) 
BlinkenLib/BlinkenMng.c 399)         // initialize MNG library

BlinkenLib/BlinkenMng.c 400)         hMNG =
BlinkenLib/BlinkenMng.c 401)             mng_initialize((mng_ptr) data, BlMng_alloc, BlMng_free, MNG_NULL);
BlinkenLib/BlinkenMng.c 402)         if (hMNG) {

BlinkenLib/BlinkenMng.c 403) 
BlinkenLib/BlinkenMng.c 404)           // set MNG callbacks

BlinkenLib/BlinkenMng.c 405)           if (mng_setcb_openstream(hMNG, BlMng_openstream) == 0 &&
BlinkenLib/BlinkenMng.c 406)               mng_setcb_closestream(hMNG, BlMng_closestream) == 0 &&
BlinkenLib/BlinkenMng.c 407)               mng_setcb_writedata(hMNG, BlMng_writedata) == 0) {

BlinkenLib/BlinkenMng.c 408) 
BlinkenLib/BlinkenMng.c 409)             // create new MNG image in memory

BlinkenLib/BlinkenMng.c 410)             if (mng_create(hMNG) == 0) {

BlinkenLib/BlinkenMng.c 411) 
BlinkenLib/BlinkenMng.c 412)               // write MNG chunks
BlinkenLib/BlinkenMng.c 413)               do {

BlinkenLib/BlinkenMng.c 414)                 unsigned int frame_cnt = BlinkenMovieGetFrameCnt(data->movie);
BlinkenLib/BlinkenMng.c 415)                 unsigned int total_duration =
BlinkenLib/BlinkenMng.c 416)                     BlinkenMovieGetDuration(data->movie);

BlinkenLib/BlinkenMng.c 417)                 unsigned int frame_no;
BlinkenLib/BlinkenMng.c 418) 
BlinkenLib/BlinkenMng.c 419)                 // write MG header chunks

BlinkenLib/BlinkenMng.c 420)                 if (mng_putchunk_mhdr(hMNG, data->width, data->height,  // dimensions
BlinkenLib/BlinkenMng.c 421)                                       1000, 0, frame_cnt, total_duration,       // ticks 
BlinkenLib/BlinkenMng.c 422)                                                                                 // 

BlinkenLib/BlinkenMng.c 423)                                       // 
BlinkenLib/BlinkenMng.c 424)                                       // 
BlinkenLib/BlinkenMng.c 425)                                       // 
BlinkenLib/BlinkenMng.c 426)                                       // 

BlinkenLib/BlinkenMng.c 427)                                       // per 
BlinkenLib/BlinkenMng.c 428)                                       // second, 
BlinkenLib/BlinkenMng.c 429)                                       // layer, 
BlinkenLib/BlinkenMng.c 430)                                       // frame 
BlinkenLib/BlinkenMng.c 431)                                       // count, 
BlinkenLib/BlinkenMng.c 432)                                       // duration
BlinkenLib/BlinkenMng.c 433)                                       MNG_SIMPLICITY_VALID | MNG_SIMPLICITY_SIMPLEFEATURES | MNG_SIMPLICITY_COMPLEXFEATURES     // simplicity
BlinkenLib/BlinkenMng.c 434)                     ) != 0)

BlinkenLib/BlinkenMng.c 435)                   break;
BlinkenLib/BlinkenMng.c 436) 

BlinkenLib/BlinkenMng.c 437)                 if (mng_putchunk_save(hMNG, MNG_TRUE,   // empty SAVE chunk
BlinkenLib/BlinkenMng.c 438)                                       0, 0      // no offset, no count
BlinkenLib/BlinkenMng.c 439)                     ) != 0)

BlinkenLib/BlinkenMng.c 440)                   break;
BlinkenLib/BlinkenMng.c 441) 
BlinkenLib/BlinkenMng.c 442)                 // tell MNG player to clear canvas after end of MNG animation

BlinkenLib/BlinkenMng.c 443)                 // - this is needed to preserve duration of last frame
BlinkenLib/BlinkenMng.c 444)                 // - this results in a black frame with 1ms duration at the
BlinkenLib/BlinkenMng.c 445)                 // end of the MNG as side effect
BlinkenLib/BlinkenMng.c 446)                 if (mng_putchunk_term(hMNG, MNG_TERMACTION_CLEAR, MNG_ITERACTION_CLEAR, // show 
BlinkenLib/BlinkenMng.c 447)                                                                                         // 

BlinkenLib/BlinkenMng.c 448)                                       // 
BlinkenLib/BlinkenMng.c 449)                                       // 
BlinkenLib/BlinkenMng.c 450)                                       // 
BlinkenLib/BlinkenMng.c 451)                                       // 

BlinkenLib/BlinkenMng.c 452)                                       // last 
BlinkenLib/BlinkenMng.c 453)                                       // frame 
BlinkenLib/BlinkenMng.c 454)                                       // forever 
BlinkenLib/BlinkenMng.c 455)                                       // after 
BlinkenLib/BlinkenMng.c 456)                                       // end 
BlinkenLib/BlinkenMng.c 457)                                       // of 
BlinkenLib/BlinkenMng.c 458)                                       // animation
BlinkenLib/BlinkenMng.c 459)                                       0, 0      // no repeat delay, no
BlinkenLib/BlinkenMng.c 460)                                       // maximum iteration count
BlinkenLib/BlinkenMng.c 461)                     ) != 0)

BlinkenLib/BlinkenMng.c 462)                   break;
BlinkenLib/BlinkenMng.c 463) 
BlinkenLib/BlinkenMng.c 464)                 // write frames

BlinkenLib/BlinkenMng.c 465)                 for (frame_no = 0; frame_no < frame_cnt; frame_no++) {

BlinkenLib/BlinkenMng.c 466) 
BlinkenLib/BlinkenMng.c 467)                   // get current frame

BlinkenLib/BlinkenMng.c 468)                   stBlinkenFrame *frame =
BlinkenLib/BlinkenMng.c 469)                       BlinkenMovieGetFrame(data->movie, frame_no);
BlinkenLib/BlinkenMng.c 470)                   unsigned int frame_duration =
BlinkenLib/BlinkenMng.c 471)                       BlinkenFrameGetDuration(frame);

BlinkenLib/BlinkenMng.c 472) 
BlinkenLib/BlinkenMng.c 473)                   // write MNG frame header chunks

BlinkenLib/BlinkenMng.c 474)                   if (mng_putchunk_seek(hMNG, 0, MNG_NULL       // no name
BlinkenLib/BlinkenMng.c 475)                       ) != 0)

BlinkenLib/BlinkenMng.c 476)                     break;
BlinkenLib/BlinkenMng.c 477) 

BlinkenLib/BlinkenMng.c 478)                   if (mng_putchunk_fram(hMNG, MNG_FALSE, frame_no == 0 ? MNG_FRAMINGMODE_1 : MNG_FRAMINGMODE_NOCHANGE,  // empty, 
BlinkenLib/BlinkenMng.c 479)                                                                                                                         // 

BlinkenLib/BlinkenMng.c 480)                                         // 
BlinkenLib/BlinkenMng.c 481)                                         // 
BlinkenLib/BlinkenMng.c 482)                                         // 
BlinkenLib/BlinkenMng.c 483)                                         // 

BlinkenLib/BlinkenMng.c 484)                                         // mode
BlinkenLib/BlinkenMng.c 485)                                         0, MNG_NULL,    // frame name
BlinkenLib/BlinkenMng.c 486)                                         MNG_CHANGEDELAY_DEFAULT, MNG_CHANGETIMOUT_NO, MNG_CHANGECLIPPING_NO, MNG_CHANGESYNCID_NO,       // changing 
BlinkenLib/BlinkenMng.c 487)                                                                                                                                         // 

BlinkenLib/BlinkenMng.c 488)                                         // 
BlinkenLib/BlinkenMng.c 489)                                         // 
BlinkenLib/BlinkenMng.c 490)                                         // 
BlinkenLib/BlinkenMng.c 491)                                         // 

BlinkenLib/BlinkenMng.c 492)                                         // only 
BlinkenLib/BlinkenMng.c 493)                                         // delay
BlinkenLib/BlinkenMng.c 494)                                         frame_duration, 0,      // new delay, 
BlinkenLib/BlinkenMng.c 495)                                                                 // 

BlinkenLib/BlinkenMng.c 496)                                         // 
BlinkenLib/BlinkenMng.c 497)                                         // 
BlinkenLib/BlinkenMng.c 498)                                         // 
BlinkenLib/BlinkenMng.c 499)                                         // 

BlinkenLib/BlinkenMng.c 500)                                         // no new
BlinkenLib/BlinkenMng.c 501)                                         // timeout
BlinkenLib/BlinkenMng.c 502)                                         0, 0, 0, 0, 0,  // no new boundary
BlinkenLib/BlinkenMng.c 503)                                         0, 0    // no count, no IDs
BlinkenLib/BlinkenMng.c 504)                       ) != 0)

BlinkenLib/BlinkenMng.c 505)                     break;
BlinkenLib/BlinkenMng.c 506) 

BlinkenLib/BlinkenMng.c 507)                   if (mng_putchunk_defi(hMNG, 0, MNG_DONOTSHOW_VISIBLE, MNG_ABSTRACT,   // no 
BlinkenLib/BlinkenMng.c 508)                                                                                         // 

BlinkenLib/BlinkenMng.c 509)                                         // 
BlinkenLib/BlinkenMng.c 510)                                         // 
BlinkenLib/BlinkenMng.c 511)                                         // 
BlinkenLib/BlinkenMng.c 512)                                         // 

BlinkenLib/BlinkenMng.c 513)                                         // ID, 
BlinkenLib/BlinkenMng.c 514)                                         // visible, 
BlinkenLib/BlinkenMng.c 515)                                         // abstract
BlinkenLib/BlinkenMng.c 516)                                         MNG_TRUE, 0, 0, // top left location
BlinkenLib/BlinkenMng.c 517)                                         MNG_FALSE, 0, 0, 0, 0   // no
BlinkenLib/BlinkenMng.c 518)                                         // clipping
BlinkenLib/BlinkenMng.c 519)                       ) != 0)

BlinkenLib/BlinkenMng.c 520)                     break;
BlinkenLib/BlinkenMng.c 521) 

BlinkenLib/BlinkenMng.c 522)                   if (mng_putchunk_ihdr(hMNG, data->width, data->height, 8, MNG_COLORTYPE_RGB,  // dimensions 
BlinkenLib/BlinkenMng.c 523)                                                                                                 // 

BlinkenLib/BlinkenMng.c 524)                                         // 
BlinkenLib/BlinkenMng.c 525)                                         // 
BlinkenLib/BlinkenMng.c 526)                                         // 
BlinkenLib/BlinkenMng.c 527)                                         // 

BlinkenLib/BlinkenMng.c 528)                                         // and 
BlinkenLib/BlinkenMng.c 529)                                         // 8 
BlinkenLib/BlinkenMng.c 530)                                         // bit 
BlinkenLib/BlinkenMng.c 531)                                         // RGB
BlinkenLib/BlinkenMng.c 532)                                         MNG_COMPRESSION_DEFLATE, MNG_FILTER_ADAPTIVE, MNG_INTERLACE_NONE        // deflate 
BlinkenLib/BlinkenMng.c 533)                                                                                                                 // 

BlinkenLib/BlinkenMng.c 534)                                         // 
BlinkenLib/BlinkenMng.c 535)                                         // 
BlinkenLib/BlinkenMng.c 536)                                         // 
BlinkenLib/BlinkenMng.c 537)                                         // 

BlinkenLib/BlinkenMng.c 538)                                         // compression, 
BlinkenLib/BlinkenMng.c 539)                                         // adaptive 
BlinkenLib/BlinkenMng.c 540)                                         // filter, 
BlinkenLib/BlinkenMng.c 541)                                         // no 
BlinkenLib/BlinkenMng.c 542)                                         // interlacing
BlinkenLib/BlinkenMng.c 543)                       ) != 0)

BlinkenLib/BlinkenMng.c 544)                     break;
BlinkenLib/BlinkenMng.c 545) 
BlinkenLib/BlinkenMng.c 546)                   // write MNG frame data
BlinkenLib/BlinkenMng.c 547)                   {

BlinkenLib/BlinkenMng.c 548)                     unsigned char *ptr;

BlinkenLib/BlinkenMng.c 549)                     unsigned int len;
BlinkenLib/BlinkenMng.c 550)                     mng_retcode iRC;
BlinkenLib/BlinkenMng.c 551) 

BlinkenLib/BlinkenMng.c 552)                     BlMng_compress_frame(frame, &ptr, &len);

BlinkenLib/BlinkenMng.c 553) 

BlinkenLib/BlinkenMng.c 554)                     iRC =
BlinkenLib/BlinkenMng.c 555)                         mng_putchunk_idat(hMNG, (mng_uint32) len,
BlinkenLib/BlinkenMng.c 556)                                           (mng_ptr) ptr);
BlinkenLib/BlinkenMng.c 557)                     free(ptr);
BlinkenLib/BlinkenMng.c 558)                     if (iRC != 0)

BlinkenLib/BlinkenMng.c 559)                       break;
BlinkenLib/BlinkenMng.c 560)                   }
BlinkenLib/BlinkenMng.c 561) 
BlinkenLib/BlinkenMng.c 562)                   // write MNG frame footer

BlinkenLib/BlinkenMng.c 563)                   if (mng_putchunk_iend(hMNG) != 0)

BlinkenLib/BlinkenMng.c 564)                     break;
BlinkenLib/BlinkenMng.c 565) 

BlinkenLib/BlinkenMng.c 566)                 }       // for( frame ...
BlinkenLib/BlinkenMng.c 567)                 if (frame_no < frame_cnt)       // if not all frames have
BlinkenLib/BlinkenMng.c 568)                   // been processed there was
BlinkenLib/BlinkenMng.c 569)                   // en error

BlinkenLib/BlinkenMng.c 570)                   break;
BlinkenLib/BlinkenMng.c 571) 
BlinkenLib/BlinkenMng.c 572)                 // output MNG end chunk

BlinkenLib/BlinkenMng.c 573)                 if (mng_putchunk_mend(hMNG) != 0)

BlinkenLib/BlinkenMng.c 574)                   break;
BlinkenLib/BlinkenMng.c 575) 
BlinkenLib/BlinkenMng.c 576)                 // write MNG chuks to file

BlinkenLib/BlinkenMng.c 577)                 if (mng_write(hMNG) != 0)

BlinkenLib/BlinkenMng.c 578)                   break;
BlinkenLib/BlinkenMng.c 579) 
BlinkenLib/BlinkenMng.c 580)                 b_success = 1;
BlinkenLib/BlinkenMng.c 581) 

BlinkenLib/BlinkenMng.c 582)               } while (0);
BlinkenLib/BlinkenMng.c 583) 
BlinkenLib/BlinkenMng.c 584)             }   // if( mng_create( hMNG ) == 0 )

BlinkenLib/BlinkenMng.c 585) 

BlinkenLib/BlinkenMng.c 586)           }     // if( mng_setcb_... )

BlinkenLib/BlinkenMng.c 587) 
BlinkenLib/BlinkenMng.c 588)           // shutdown MNG library

BlinkenLib/BlinkenMng.c 589)           mng_cleanup(&hMNG);

BlinkenLib/BlinkenMng.c 590) 

BlinkenLib/BlinkenMng.c 591)         }       // if( hMNG )

BlinkenLib/BlinkenMng.c 592) 
BlinkenLib/BlinkenMng.c 593)         // close file

BlinkenLib/BlinkenMng.c 594)         fclose(data->hFile);

BlinkenLib/BlinkenMng.c 595) 
BlinkenLib/BlinkenMng.c 596)       } // if( data->hFile != NULL )
BlinkenLib/BlinkenMng.c 597) 
BlinkenLib/BlinkenMng.c 598)       // free movie

BlinkenLib/BlinkenMng.c 599)       BlinkenMovieFree(data->movie);

BlinkenLib/BlinkenMng.c 600) 

BlinkenLib/BlinkenMng.c 601)     }   // if( data->movie != NULL )

BlinkenLib/BlinkenMng.c 602) 
BlinkenLib/BlinkenMng.c 603)     // free data structure for state

BlinkenLib/BlinkenMng.c 604)     if (data->canvas != NULL)
BlinkenLib/BlinkenMng.c 605)       free(data->canvas);
BlinkenLib/BlinkenMng.c 606)     free(data);

BlinkenLib/BlinkenMng.c 607) 

BlinkenLib/BlinkenMng.c 608)   }     // if( data != NULL )