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/BlinkenFrame.h>
BlinkenLib/BlinkenMng.c  20) #include <BlinkenLib/BlinkenMovie.h>

src/BlinkenMng.c         21) #include <BlinkenLib/config.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 {

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

BlinkenLib/BlinkenMng.c  30)   unsigned int height;

src/BlinkenMng.c         31)   unsigned char *canvas; // canvas (i.e. pixel data, size is height *

BlinkenLib/BlinkenMng.c  32)   // width * 3)

src/BlinkenMng.c         33)   unsigned int counter_msec; // current number of milliseconds
src/BlinkenMng.c         34)   unsigned int timer_msec;   // the MNG library will be called after this

BlinkenLib/BlinkenMng.c  35)   // number of milliseconds

src/BlinkenMng.c         36)   stBlinkenMovie *movie; // movie being created

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

src/BlinkenMng.c         39) mng_ptr BlMng_alloc(mng_size_t iSize) {

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

src/BlinkenMng.c         43)   return (mng_ptr)ptr;

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

src/BlinkenMng.c         46) void BlMng_free(mng_ptr pPtr, mng_size_t __attribute__((unused)) iSize) {

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

BlinkenLib/BlinkenMng.c  48) }
BlinkenLib/BlinkenMng.c  49) 

src/BlinkenMng.c         50) mng_bool BlMng_openstream(mng_handle __attribute__((unused)) hMNG) {

BlinkenLib/BlinkenMng.c  51)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c  52) }
BlinkenLib/BlinkenMng.c  53) 

src/BlinkenMng.c         54) mng_bool BlMng_closestream(mng_handle __attribute__((unused)) hMNG) {

BlinkenLib/BlinkenMng.c  55)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c  56) }
BlinkenLib/BlinkenMng.c  57) 
BlinkenLib/BlinkenMng.c  58) // read data from the open file

BlinkenLib/BlinkenMng.c  59) mng_bool BlMng_readdata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,

src/BlinkenMng.c         60)                         mng_uint32 *iRead) {
src/BlinkenMng.c         61)   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);

BlinkenLib/BlinkenMng.c  62)   *iRead = fread(pBuf, 1, iSize, data->hFile);

BlinkenLib/BlinkenMng.c  63)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c  64) }
BlinkenLib/BlinkenMng.c  65) 
BlinkenLib/BlinkenMng.c  66) // write data to the open file

BlinkenLib/BlinkenMng.c  67) mng_bool BlMng_writedata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,

src/BlinkenMng.c         68)                          mng_uint32 *iWritten) {
src/BlinkenMng.c         69)   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);

BlinkenLib/BlinkenMng.c  70)   *iWritten = fwrite(pBuf, 1, iSize, data->hFile);

BlinkenLib/BlinkenMng.c  71)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c  72) }
BlinkenLib/BlinkenMng.c  73) 
BlinkenLib/BlinkenMng.c  74) // MNG library has processed the header information

BlinkenLib/BlinkenMng.c  75) mng_bool BlMng_processheader(mng_handle hMNG, mng_uint32 iWidth,

src/BlinkenMng.c         76)                              mng_uint32 iHeight) {
src/BlinkenMng.c         77)   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);

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

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

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

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

BlinkenLib/BlinkenMng.c  84)   }
BlinkenLib/BlinkenMng.c  85)   // free old movie

BlinkenLib/BlinkenMng.c  86)   if (data->movie) {
BlinkenLib/BlinkenMng.c  87)     BlinkenMovieFree(data->movie);

BlinkenLib/BlinkenMng.c  88)     data->movie = NULL;
BlinkenLib/BlinkenMng.c  89)   }
BlinkenLib/BlinkenMng.c  90)   // remember dimensions and allocate new canvas
BlinkenLib/BlinkenMng.c  91)   data->width = iWidth;
BlinkenLib/BlinkenMng.c  92)   data->height = iHeight;

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

BlinkenLib/BlinkenMng.c  95)     return MNG_FALSE;
BlinkenLib/BlinkenMng.c  96)   data->counter_msec = 0;
BlinkenLib/BlinkenMng.c  97)   data->timer_msec = 0;
BlinkenLib/BlinkenMng.c  98) 
BlinkenLib/BlinkenMng.c  99)   // create new empty movie

src/BlinkenMng.c        100)   data->movie = BlinkenMovieNew(iHeight, iWidth, 3, 255); // always 24

BlinkenLib/BlinkenMng.c 101)   // bit RGB
BlinkenLib/BlinkenMng.c 102)   if (data->movie == NULL)

BlinkenLib/BlinkenMng.c 103)     return MNG_FALSE;
BlinkenLib/BlinkenMng.c 104) 

BlinkenLib/BlinkenMng.c 105)   return MNG_TRUE;

BlinkenLib/BlinkenMng.c 106) }
BlinkenLib/BlinkenMng.c 107) 
BlinkenLib/BlinkenMng.c 108) // get access to a line of the canvas

src/BlinkenMng.c        109) mng_ptr BlMng_getcanvasline(mng_handle hMNG, mng_uint32 iLinenr) {
src/BlinkenMng.c        110)   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);

BlinkenLib/BlinkenMng.c 111) 
BlinkenLib/BlinkenMng.c 112)   // return pointer to line

BlinkenLib/BlinkenMng.c 113)   if (iLinenr < data->height)

src/BlinkenMng.c        114)     return (mng_ptr)(data->canvas + iLinenr * data->width * 3);

BlinkenLib/BlinkenMng.c 115)   else

src/BlinkenMng.c        116)     return (mng_ptr)NULL;

BlinkenLib/BlinkenMng.c 117) }
BlinkenLib/BlinkenMng.c 118) 
BlinkenLib/BlinkenMng.c 119) // the MNG library thinks that (a part of) the canvas should be shown

src/BlinkenMng.c        120) mng_bool BlMng_refresh(mng_handle __attribute__((unused)) hMNG,
src/BlinkenMng.c        121)                        mng_uint32 __attribute__((unused)) iX,
src/BlinkenMng.c        122)                        mng_uint32 __attribute__((unused)) iY,
src/BlinkenMng.c        123)                        mng_uint32 __attribute__((unused)) iWidth,
src/BlinkenMng.c        124)                        mng_uint32 __attribute__((unused)) iHeight) {

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

BlinkenLib/BlinkenMng.c 127)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c 128) }
BlinkenLib/BlinkenMng.c 129) 
BlinkenLib/BlinkenMng.c 130) // the MNG library want to know how many milliseconds have passed

src/BlinkenMng.c        131) mng_uint32 BlMng_gettickcount(mng_handle hMNG) {
src/BlinkenMng.c        132)   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);

BlinkenLib/BlinkenMng.c 133) 

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

BlinkenLib/BlinkenMng.c 136)   return data->counter_msec;
BlinkenLib/BlinkenMng.c 137) }
BlinkenLib/BlinkenMng.c 138) 
BlinkenLib/BlinkenMng.c 139) // the MNG library wants to be be called again after some milliseconds

src/BlinkenMng.c        140) mng_bool BlMng_settimer(mng_handle hMNG, mng_uint32 iMsecs) {
src/BlinkenMng.c        141)   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);

BlinkenLib/BlinkenMng.c 142) 
BlinkenLib/BlinkenMng.c 143)   // just remember the number of milliseconds
BlinkenLib/BlinkenMng.c 144)   data->timer_msec = iMsecs;
BlinkenLib/BlinkenMng.c 145) 
BlinkenLib/BlinkenMng.c 146)   return MNG_TRUE;
BlinkenLib/BlinkenMng.c 147) }
BlinkenLib/BlinkenMng.c 148) 
BlinkenLib/BlinkenMng.c 149) // save as new frame to current movie

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

BlinkenLib/BlinkenMng.c 151)                       unsigned int width, unsigned int height,

src/BlinkenMng.c        152)                       unsigned char *data) {

BlinkenLib/BlinkenMng.c 153)   stBlinkenFrame *frame;

BlinkenLib/BlinkenMng.c 154)   unsigned int c, x, y;
BlinkenLib/BlinkenMng.c 155) 
BlinkenLib/BlinkenMng.c 156)   // check that a movie is present

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

BlinkenLib/BlinkenMng.c 158)     return;
BlinkenLib/BlinkenMng.c 159) 
BlinkenLib/BlinkenMng.c 160)   // create new frame (24 bit RGB)

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

BlinkenLib/BlinkenMng.c 163)     return;
BlinkenLib/BlinkenMng.c 164) 
BlinkenLib/BlinkenMng.c 165)   // set pixels of frame

BlinkenLib/BlinkenMng.c 166)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenMng.c 167)     for (x = 0; x < width; x++) {
BlinkenLib/BlinkenMng.c 168)       for (c = 0; c < 3; c++) {
BlinkenLib/BlinkenMng.c 169)         BlinkenFrameSetPixel(frame, y, x, c, *data);

BlinkenLib/BlinkenMng.c 170)         data++;
BlinkenLib/BlinkenMng.c 171)       }
BlinkenLib/BlinkenMng.c 172)     }
BlinkenLib/BlinkenMng.c 173)   }
BlinkenLib/BlinkenMng.c 174) 
BlinkenLib/BlinkenMng.c 175)   // append frame to movie

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

BlinkenLib/BlinkenMng.c 178) }
BlinkenLib/BlinkenMng.c 179) 
BlinkenLib/BlinkenMng.c 180) // compress pixel data in a frame

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

src/BlinkenMng.c        182)                           unsigned int *p_out_len) {

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

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

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

BlinkenLib/BlinkenMng.c 189)   unsigned long out_len;
BlinkenLib/BlinkenMng.c 190) 
BlinkenLib/BlinkenMng.c 191)   // assemble raw data to compress

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

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

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

BlinkenLib/BlinkenMng.c 195)   ptr = raw_ptr;

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

BlinkenLib/BlinkenMng.c 197)     // filter ID

src/BlinkenMng.c        198)     *ptr = MNG_FILTER_NONE; // no filtering

BlinkenLib/BlinkenMng.c 199)     ptr++;
BlinkenLib/BlinkenMng.c 200)     // pixel data of row

BlinkenLib/BlinkenMng.c 201)     for (x = 0; x < width; x++) {
BlinkenLib/BlinkenMng.c 202)       for (c = 0; c < 3; c++) {
BlinkenLib/BlinkenMng.c 203)         *ptr = BlinkenFrameGetPixel(frame, y, x, c);

BlinkenLib/BlinkenMng.c 204)         ptr++;
BlinkenLib/BlinkenMng.c 205)       }
BlinkenLib/BlinkenMng.c 206)     }

src/BlinkenMng.c        207)   } // for( y ...

BlinkenLib/BlinkenMng.c 208) 
BlinkenLib/BlinkenMng.c 209)   // compress data

src/BlinkenMng.c        210)   out_len = raw_len + (raw_len + 999) / 1000 + 12; // must be at least

BlinkenLib/BlinkenMng.c 211)   // <source length> *
BlinkenLib/BlinkenMng.c 212)   // 1.001 + 12
BlinkenLib/BlinkenMng.c 213)   out_ptr = (unsigned char *)malloc(out_len);
BlinkenLib/BlinkenMng.c 214)   compress2(out_ptr, &out_len, raw_ptr, raw_len, Z_BEST_COMPRESSION);
BlinkenLib/BlinkenMng.c 215)   free(raw_ptr);

BlinkenLib/BlinkenMng.c 216) 
BlinkenLib/BlinkenMng.c 217)   // return allocated compressed data
BlinkenLib/BlinkenMng.c 218)   *p_out_ptr = out_ptr;
BlinkenLib/BlinkenMng.c 219)   *p_out_len = (unsigned int)out_len;
BlinkenLib/BlinkenMng.c 220) }
BlinkenLib/BlinkenMng.c 221) 
BlinkenLib/BlinkenMng.c 222) // load a MNG file as BlinkenMovie

src/BlinkenMng.c        223) stBlinkenMovie *BlinkenMngLoad(const char *pFilename) {

BlinkenLib/BlinkenMng.c 224)   BlMng_userdata *data;

BlinkenLib/BlinkenMng.c 225)   mng_handle hMNG;

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

BlinkenLib/BlinkenMng.c 227) 

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

BlinkenLib/BlinkenMng.c 229)     return NULL;
BlinkenLib/BlinkenMng.c 230) 
BlinkenLib/BlinkenMng.c 231)   // create new structure for state of operation

src/BlinkenMng.c        232)   data = (BlMng_userdata *)malloc(sizeof(BlMng_userdata));

BlinkenLib/BlinkenMng.c 233)   if (data != NULL) {

BlinkenLib/BlinkenMng.c 234)     data->hFile = NULL;
BlinkenLib/BlinkenMng.c 235)     data->width = 0;
BlinkenLib/BlinkenMng.c 236)     data->height = 0;
BlinkenLib/BlinkenMng.c 237)     data->canvas = NULL;
BlinkenLib/BlinkenMng.c 238)     data->movie = NULL;
BlinkenLib/BlinkenMng.c 239) 
BlinkenLib/BlinkenMng.c 240)     // open MNG file for reading

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

BlinkenLib/BlinkenMng.c 243) 
BlinkenLib/BlinkenMng.c 244)       // initialize MNG library

src/BlinkenMng.c        245)       hMNG = mng_initialize((mng_ptr)data, BlMng_alloc, BlMng_free, MNG_NULL);

BlinkenLib/BlinkenMng.c 246)       if (hMNG) {

BlinkenLib/BlinkenMng.c 247) 
BlinkenLib/BlinkenMng.c 248)         // set MNG callbacks

BlinkenLib/BlinkenMng.c 249)         if (mng_setcb_openstream(hMNG, BlMng_openstream) == 0 &&
BlinkenLib/BlinkenMng.c 250)             mng_setcb_closestream(hMNG, BlMng_closestream) == 0 &&
BlinkenLib/BlinkenMng.c 251)             mng_setcb_readdata(hMNG, BlMng_readdata) == 0 &&
BlinkenLib/BlinkenMng.c 252)             mng_setcb_processheader(hMNG, BlMng_processheader) == 0 &&
BlinkenLib/BlinkenMng.c 253)             mng_setcb_getcanvasline(hMNG, BlMng_getcanvasline) == 0 &&
BlinkenLib/BlinkenMng.c 254)             mng_setcb_refresh(hMNG, BlMng_refresh) == 0 &&
BlinkenLib/BlinkenMng.c 255)             mng_setcb_gettickcount(hMNG, BlMng_gettickcount) == 0 &&
BlinkenLib/BlinkenMng.c 256)             mng_setcb_settimer(hMNG, BlMng_settimer) == 0 &&
BlinkenLib/BlinkenMng.c 257)             mng_set_canvasstyle(hMNG, MNG_CANVAS_RGB8) == 0) {

BlinkenLib/BlinkenMng.c 258) 

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

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

BlinkenLib/BlinkenMng.c 262) 

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

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

BlinkenLib/BlinkenMng.c 266) 
BlinkenLib/BlinkenMng.c 267)               // "display" loop
BlinkenLib/BlinkenMng.c 268)               int b_saved = 0;

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

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

BlinkenLib/BlinkenMng.c 271) 
BlinkenLib/BlinkenMng.c 272)                 // save fame to movie

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

BlinkenLib/BlinkenMng.c 275)                 b_saved = 1;

BlinkenLib/BlinkenMng.c 276)                 ++frame_idx;

BlinkenLib/BlinkenMng.c 277) 

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

BlinkenLib/BlinkenMng.c 279)                 data->counter_msec += data->timer_msec;
BlinkenLib/BlinkenMng.c 280)                 data->timer_msec = 0;
BlinkenLib/BlinkenMng.c 281) 
BlinkenLib/BlinkenMng.c 282)                 // "display" next frame

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

BlinkenLib/BlinkenMng.c 285)                   break;
BlinkenLib/BlinkenMng.c 286) 
BlinkenLib/BlinkenMng.c 287)               } // while( iRC == MNG_NEEDTIMERWAIT && data->timer_msec > 0 )
BlinkenLib/BlinkenMng.c 288) 

BlinkenLib/BlinkenMng.c 289)               // save single frame if no frame saved yet (i.e. not an
BlinkenLib/BlinkenMng.c 290)               // animated MNG image)
BlinkenLib/BlinkenMng.c 291)               if (!b_saved)
BlinkenLib/BlinkenMng.c 292)                 BlMng_save_frame(data->movie, data->timer_msec, data->width,
BlinkenLib/BlinkenMng.c 293)                                  data->height, data->canvas);
BlinkenLib/BlinkenMng.c 294) 

src/BlinkenMng.c        295)               // if movie has more than one frame and the last frame is empty
src/BlinkenMng.c        296)               //
src/BlinkenMng.c        297)               //
src/BlinkenMng.c        298)               //
src/BlinkenMng.c        299)               //
src/BlinkenMng.c        300)               //

BlinkenLib/BlinkenMng.c 301)               // with duration of 1ms, remove last frame

src/BlinkenMng.c        302)               // - a black frame with 1ms duration is inserted by MNG library
src/BlinkenMng.c        303)               //
src/BlinkenMng.c        304)               //
src/BlinkenMng.c        305)               //
src/BlinkenMng.c        306)               //
src/BlinkenMng.c        307)               //

BlinkenLib/BlinkenMng.c 308)               // when MNG requests to clean canvas after displaying
BlinkenLib/BlinkenMng.c 309)               // - the reqauest to clear canvas after end of MNG anmation is
BlinkenLib/BlinkenMng.c 310)               // needed to preserve duration of last frame (when converting
BlinkenLib/BlinkenMng.c 311)               // from native format to MNG)
BlinkenLib/BlinkenMng.c 312)               // - remove this frame that is created by the described side
BlinkenLib/BlinkenMng.c 313)               // effect

BlinkenLib/BlinkenMng.c 314)               {

BlinkenLib/BlinkenMng.c 315)                 unsigned int frame_cnt = BlinkenMovieGetFrameCnt(data->movie);
BlinkenLib/BlinkenMng.c 316)                 if (frame_cnt >= 1) {
BlinkenLib/BlinkenMng.c 317)                   stBlinkenFrame *frame =
BlinkenLib/BlinkenMng.c 318)                       BlinkenMovieGetFrame(data->movie, frame_cnt - 1);
BlinkenLib/BlinkenMng.c 319)                   if (frame != NULL && BlinkenFrameIsEmpty(frame))
BlinkenLib/BlinkenMng.c 320)                     BlinkenMovieDeleteFrame(data->movie, frame_cnt - 1);

BlinkenLib/BlinkenMng.c 321)                 }
BlinkenLib/BlinkenMng.c 322)               }
BlinkenLib/BlinkenMng.c 323) 
BlinkenLib/BlinkenMng.c 324)               // stop "displaying"

BlinkenLib/BlinkenMng.c 325)               mng_display_freeze(hMNG);
BlinkenLib/BlinkenMng.c 326) 

src/BlinkenMng.c        327)             } // if( iRC == 0 || iRC == MNG_NEEDTIMERWAIT )

BlinkenLib/BlinkenMng.c 328) 

src/BlinkenMng.c        329)           }   // if (mng_set_cacheplayback ... )

BlinkenLib/BlinkenMng.c 330) 

src/BlinkenMng.c        331)         }     // if( mng_setcb_... )

BlinkenLib/BlinkenMng.c 332) 

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

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

BlinkenLib/BlinkenMng.c 335) 
BlinkenLib/BlinkenMng.c 336)       } // if( hMNG )
BlinkenLib/BlinkenMng.c 337) 
BlinkenLib/BlinkenMng.c 338)       // close file

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

BlinkenLib/BlinkenMng.c 340) 

src/BlinkenMng.c        341)     } // if( data->hFile != NULL )

BlinkenLib/BlinkenMng.c 342) 
BlinkenLib/BlinkenMng.c 343)     // fetch created movie from state
BlinkenLib/BlinkenMng.c 344)     movie = data->movie;
BlinkenLib/BlinkenMng.c 345)     data->movie = NULL;
BlinkenLib/BlinkenMng.c 346) 
BlinkenLib/BlinkenMng.c 347)     // free data structure for state

BlinkenLib/BlinkenMng.c 348)     if (data->canvas != NULL)
BlinkenLib/BlinkenMng.c 349)       free(data->canvas);
BlinkenLib/BlinkenMng.c 350)     free(data);

BlinkenLib/BlinkenMng.c 351) 

src/BlinkenMng.c        352)   } // if( data != NULL )

BlinkenLib/BlinkenMng.c 353) 
BlinkenLib/BlinkenMng.c 354)   return movie;
BlinkenLib/BlinkenMng.c 355) }
BlinkenLib/BlinkenMng.c 356) 

src/BlinkenMng.c        357) int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename) {

BlinkenLib/BlinkenMng.c 358)   BlMng_userdata *data;

BlinkenLib/BlinkenMng.c 359)   mng_handle hMNG;
BlinkenLib/BlinkenMng.c 360)   int b_success = 0;
BlinkenLib/BlinkenMng.c 361) 

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

BlinkenLib/BlinkenMng.c 363)     return -1;
BlinkenLib/BlinkenMng.c 364) 
BlinkenLib/BlinkenMng.c 365)   // create new structure for state of operation

src/BlinkenMng.c        366)   data = (BlMng_userdata *)malloc(sizeof(BlMng_userdata));

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

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

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

BlinkenLib/BlinkenMng.c 371)     data->canvas = NULL;
BlinkenLib/BlinkenMng.c 372)     data->movie = NULL;
BlinkenLib/BlinkenMng.c 373) 
BlinkenLib/BlinkenMng.c 374)     // convert movie to suitable format

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

BlinkenLib/BlinkenMng.c 378) 
BlinkenLib/BlinkenMng.c 379)       // open MNG file for writing

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

BlinkenLib/BlinkenMng.c 382) 
BlinkenLib/BlinkenMng.c 383)         // initialize MNG library

src/BlinkenMng.c        384)         hMNG = mng_initialize((mng_ptr)data, BlMng_alloc, BlMng_free, MNG_NULL);

BlinkenLib/BlinkenMng.c 385)         if (hMNG) {

BlinkenLib/BlinkenMng.c 386) 
BlinkenLib/BlinkenMng.c 387)           // set MNG callbacks

BlinkenLib/BlinkenMng.c 388)           if (mng_setcb_openstream(hMNG, BlMng_openstream) == 0 &&
BlinkenLib/BlinkenMng.c 389)               mng_setcb_closestream(hMNG, BlMng_closestream) == 0 &&
BlinkenLib/BlinkenMng.c 390)               mng_setcb_writedata(hMNG, BlMng_writedata) == 0) {

BlinkenLib/BlinkenMng.c 391) 
BlinkenLib/BlinkenMng.c 392)             // create new MNG image in memory

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

BlinkenLib/BlinkenMng.c 394) 
BlinkenLib/BlinkenMng.c 395)               // write MNG chunks
BlinkenLib/BlinkenMng.c 396)               do {

BlinkenLib/BlinkenMng.c 397)                 unsigned int frame_cnt = BlinkenMovieGetFrameCnt(data->movie);
BlinkenLib/BlinkenMng.c 398)                 unsigned int total_duration =
BlinkenLib/BlinkenMng.c 399)                     BlinkenMovieGetDuration(data->movie);

BlinkenLib/BlinkenMng.c 400)                 unsigned int frame_no;
BlinkenLib/BlinkenMng.c 401) 
BlinkenLib/BlinkenMng.c 402)                 // write MG header chunks

src/BlinkenMng.c        403)                 if (mng_putchunk_mhdr(
src/BlinkenMng.c        404)                         hMNG, data->width, data->height,    // dimensions
src/BlinkenMng.c        405)                         1000, 0, frame_cnt, total_duration, // ticks
src/BlinkenMng.c        406)                                                             //
src/BlinkenMng.c        407)                         //
src/BlinkenMng.c        408)                         //
src/BlinkenMng.c        409)                         //
src/BlinkenMng.c        410)                         //
src/BlinkenMng.c        411)                         // per
src/BlinkenMng.c        412)                         // second,
src/BlinkenMng.c        413)                         // layer,
src/BlinkenMng.c        414)                         // frame
src/BlinkenMng.c        415)                         // count,
src/BlinkenMng.c        416)                         // duration
src/BlinkenMng.c        417)                         MNG_SIMPLICITY_VALID | MNG_SIMPLICITY_SIMPLEFEATURES |
src/BlinkenMng.c        418)                             MNG_SIMPLICITY_COMPLEXFEATURES // simplicity
src/BlinkenMng.c        419)                         ) != 0)

BlinkenLib/BlinkenMng.c 420)                   break;
BlinkenLib/BlinkenMng.c 421) 

src/BlinkenMng.c        422)                 if (mng_putchunk_save(hMNG, MNG_TRUE, // empty SAVE chunk
src/BlinkenMng.c        423)                                       0, 0            // no offset, no count
src/BlinkenMng.c        424)                                       ) != 0)

BlinkenLib/BlinkenMng.c 425)                   break;
BlinkenLib/BlinkenMng.c 426) 
BlinkenLib/BlinkenMng.c 427)                 // tell MNG player to clear canvas after end of MNG animation

BlinkenLib/BlinkenMng.c 428)                 // - this is needed to preserve duration of last frame
BlinkenLib/BlinkenMng.c 429)                 // - this results in a black frame with 1ms duration at the
BlinkenLib/BlinkenMng.c 430)                 // end of the MNG as side effect

src/BlinkenMng.c        431)                 if (mng_putchunk_term(hMNG, MNG_TERMACTION_CLEAR,
src/BlinkenMng.c        432)                                       MNG_ITERACTION_CLEAR, // show
src/BlinkenMng.c        433)                                                             //
src/BlinkenMng.c        434)                                       //
src/BlinkenMng.c        435)                                       //
src/BlinkenMng.c        436)                                       //
src/BlinkenMng.c        437)                                       //
src/BlinkenMng.c        438)                                       // last
src/BlinkenMng.c        439)                                       // frame
src/BlinkenMng.c        440)                                       // forever
src/BlinkenMng.c        441)                                       // after
src/BlinkenMng.c        442)                                       // end
src/BlinkenMng.c        443)                                       // of

BlinkenLib/BlinkenMng.c 444)                                       // animation

src/BlinkenMng.c        445)                                       0, 0 // no repeat delay, no
src/BlinkenMng.c        446)                                            // maximum iteration count
src/BlinkenMng.c        447)                                       ) != 0)

BlinkenLib/BlinkenMng.c 448)                   break;
BlinkenLib/BlinkenMng.c 449) 
BlinkenLib/BlinkenMng.c 450)                 // write frames

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

BlinkenLib/BlinkenMng.c 452) 
BlinkenLib/BlinkenMng.c 453)                   // get current frame

BlinkenLib/BlinkenMng.c 454)                   stBlinkenFrame *frame =
BlinkenLib/BlinkenMng.c 455)                       BlinkenMovieGetFrame(data->movie, frame_no);

src/BlinkenMng.c        456)                   unsigned int frame_duration = BlinkenFrameGetDuration(frame);

BlinkenLib/BlinkenMng.c 457) 
BlinkenLib/BlinkenMng.c 458)                   // write MNG frame header chunks

src/BlinkenMng.c        459)                   if (mng_putchunk_seek(hMNG, 0, MNG_NULL // no name
src/BlinkenMng.c        460)                                         ) != 0)

BlinkenLib/BlinkenMng.c 461)                     break;
BlinkenLib/BlinkenMng.c 462) 

src/BlinkenMng.c        463)                   if (mng_putchunk_fram(
src/BlinkenMng.c        464)                           hMNG, MNG_FALSE,
src/BlinkenMng.c        465)                           frame_no == 0 ? MNG_FRAMINGMODE_1
src/BlinkenMng.c        466)                                         : MNG_FRAMINGMODE_NOCHANGE, // empty,
src/BlinkenMng.c        467)                                                                     //
src/BlinkenMng.c        468)                           //
src/BlinkenMng.c        469)                           //
src/BlinkenMng.c        470)                           //
src/BlinkenMng.c        471)                           //
src/BlinkenMng.c        472)                           // mode
src/BlinkenMng.c        473)                           0, MNG_NULL, // frame name
src/BlinkenMng.c        474)                           MNG_CHANGEDELAY_DEFAULT, MNG_CHANGETIMOUT_NO,
src/BlinkenMng.c        475)                           MNG_CHANGECLIPPING_NO,
src/BlinkenMng.c        476)                           MNG_CHANGESYNCID_NO, // changing
src/BlinkenMng.c        477)                                                //
src/BlinkenMng.c        478)                           //
src/BlinkenMng.c        479)                           //
src/BlinkenMng.c        480)                           //
src/BlinkenMng.c        481)                           //
src/BlinkenMng.c        482)                           // only
src/BlinkenMng.c        483)                           // delay
src/BlinkenMng.c        484)                           frame_duration, 0, // new delay,
src/BlinkenMng.c        485)                                              //
src/BlinkenMng.c        486)                           //
src/BlinkenMng.c        487)                           //
src/BlinkenMng.c        488)                           //
src/BlinkenMng.c        489)                           //
src/BlinkenMng.c        490)                           // no new
src/BlinkenMng.c        491)                           // timeout
src/BlinkenMng.c        492)                           0, 0, 0, 0, 0, // no new boundary
src/BlinkenMng.c        493)                           0, 0           // no count, no IDs
src/BlinkenMng.c        494)                           ) != 0)

BlinkenLib/BlinkenMng.c 495)                     break;
BlinkenLib/BlinkenMng.c 496) 

src/BlinkenMng.c        497)                   if (mng_putchunk_defi(hMNG, 0, MNG_DONOTSHOW_VISIBLE,
src/BlinkenMng.c        498)                                         MNG_ABSTRACT, // no
src/BlinkenMng.c        499)                                                       //
src/BlinkenMng.c        500)                                         //
src/BlinkenMng.c        501)                                         //
src/BlinkenMng.c        502)                                         //
src/BlinkenMng.c        503)                                         //
src/BlinkenMng.c        504)                                         // ID,
src/BlinkenMng.c        505)                                         // visible,

BlinkenLib/BlinkenMng.c 506)                                         // abstract
BlinkenLib/BlinkenMng.c 507)                                         MNG_TRUE, 0, 0, // top left location

src/BlinkenMng.c        508)                                         MNG_FALSE, 0, 0, 0, 0 // no
src/BlinkenMng.c        509)                                                               // clipping
src/BlinkenMng.c        510)                                         ) != 0)

BlinkenLib/BlinkenMng.c 511)                     break;
BlinkenLib/BlinkenMng.c 512) 

src/BlinkenMng.c        513)                   if (mng_putchunk_ihdr(hMNG, data->width, data->height, 8,
src/BlinkenMng.c        514)                                         MNG_COLORTYPE_RGB, // dimensions
src/BlinkenMng.c        515)                                                            //
src/BlinkenMng.c        516)                                         //
src/BlinkenMng.c        517)                                         //
src/BlinkenMng.c        518)                                         //
src/BlinkenMng.c        519)                                         //
src/BlinkenMng.c        520)                                         // and
src/BlinkenMng.c        521)                                         // 8
src/BlinkenMng.c        522)                                         // bit

BlinkenLib/BlinkenMng.c 523)                                         // RGB

src/BlinkenMng.c        524)                                         MNG_COMPRESSION_DEFLATE,
src/BlinkenMng.c        525)                                         MNG_FILTER_ADAPTIVE,
src/BlinkenMng.c        526)                                         MNG_INTERLACE_NONE // deflate
src/BlinkenMng.c        527)                                                            //
src/BlinkenMng.c        528)                                                            //
src/BlinkenMng.c        529)                                                            //
src/BlinkenMng.c        530)                                                            //
src/BlinkenMng.c        531)                                                            //
src/BlinkenMng.c        532)                                                            // compression,
src/BlinkenMng.c        533)                                                            // adaptive
src/BlinkenMng.c        534)                                                            // filter,
src/BlinkenMng.c        535)                                                            // no
src/BlinkenMng.c        536)                                                            // interlacing
src/BlinkenMng.c        537)                                         ) != 0)

BlinkenLib/BlinkenMng.c 538)                     break;
BlinkenLib/BlinkenMng.c 539) 
BlinkenLib/BlinkenMng.c 540)                   // write MNG frame data
BlinkenLib/BlinkenMng.c 541)                   {

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

BlinkenLib/BlinkenMng.c 543)                     unsigned int len;
BlinkenLib/BlinkenMng.c 544)                     mng_retcode iRC;
BlinkenLib/BlinkenMng.c 545) 

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

BlinkenLib/BlinkenMng.c 547) 

BlinkenLib/BlinkenMng.c 548)                     iRC =

src/BlinkenMng.c        549)                         mng_putchunk_idat(hMNG, (mng_uint32)len, (mng_ptr)ptr);

BlinkenLib/BlinkenMng.c 550)                     free(ptr);
BlinkenLib/BlinkenMng.c 551)                     if (iRC != 0)

BlinkenLib/BlinkenMng.c 552)                       break;
BlinkenLib/BlinkenMng.c 553)                   }
BlinkenLib/BlinkenMng.c 554) 
BlinkenLib/BlinkenMng.c 555)                   // write MNG frame footer

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

BlinkenLib/BlinkenMng.c 557)                     break;
BlinkenLib/BlinkenMng.c 558) 

src/BlinkenMng.c        559)                 }                         // for( frame ...
src/BlinkenMng.c        560)                 if (frame_no < frame_cnt) // if not all frames have

BlinkenLib/BlinkenMng.c 561)                   // been processed there was
BlinkenLib/BlinkenMng.c 562)                   // en error

BlinkenLib/BlinkenMng.c 563)                   break;
BlinkenLib/BlinkenMng.c 564) 
BlinkenLib/BlinkenMng.c 565)                 // output MNG end chunk

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

BlinkenLib/BlinkenMng.c 567)                   break;
BlinkenLib/BlinkenMng.c 568) 
BlinkenLib/BlinkenMng.c 569)                 // write MNG chuks to file

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

BlinkenLib/BlinkenMng.c 571)                   break;
BlinkenLib/BlinkenMng.c 572) 
BlinkenLib/BlinkenMng.c 573)                 b_success = 1;
BlinkenLib/BlinkenMng.c 574) 

BlinkenLib/BlinkenMng.c 575)               } while (0);
BlinkenLib/BlinkenMng.c 576) 

src/BlinkenMng.c        577)             } // if( mng_create( hMNG ) == 0 )

BlinkenLib/BlinkenMng.c 578) 

src/BlinkenMng.c        579)           }   // if( mng_setcb_... )

BlinkenLib/BlinkenMng.c 580) 
BlinkenLib/BlinkenMng.c 581)           // shutdown MNG library

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

BlinkenLib/BlinkenMng.c 583) 

src/BlinkenMng.c        584)         } // if( hMNG )

BlinkenLib/BlinkenMng.c 585) 
BlinkenLib/BlinkenMng.c 586)         // close file

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

BlinkenLib/BlinkenMng.c 588) 
BlinkenLib/BlinkenMng.c 589)       } // if( data->hFile != NULL )
BlinkenLib/BlinkenMng.c 590) 
BlinkenLib/BlinkenMng.c 591)       // free movie

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

BlinkenLib/BlinkenMng.c 593) 

src/BlinkenMng.c        594)     } // if( data->movie != NULL )

BlinkenLib/BlinkenMng.c 595) 
BlinkenLib/BlinkenMng.c 596)     // free data structure for state

BlinkenLib/BlinkenMng.c 597)     if (data->canvas != NULL)
BlinkenLib/BlinkenMng.c 598)       free(data->canvas);
BlinkenLib/BlinkenMng.c 599)     free(data);

BlinkenLib/BlinkenMng.c 600) 

src/BlinkenMng.c        601)   } // if( data != NULL )