BlinkenLib

BlinkenLib/BlinkenConv.c    1) /* BlinkenLib

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

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

BlinkenConv.c               5) 
BlinkenConv.c               6) #include <stdio.h>
BlinkenConv.c               7) #include <stdlib.h>

BlinkenConv.c               8) #include <string.h>

BlinkenConv.c               9) 

BlinkenLib/BlinkenConv.c   10) #include <BlinkenLib/BlinkenLib.h>

BlinkenConv.c              11) 

BlinkenLib/BlinkenConv.c   12) /**
BlinkenLib/BlinkenConv.c   13)  * @brief generate test movie
BlinkenLib/BlinkenConv.c   14)  * @param[in,out] *pMovie pointer to old/new/changed movie
BlinkenLib/BlinkenConv.c   15)  * @param[in] str_format format of new video to generate,
BlinkenLib/BlinkenConv.c   16)  *                       may be NULL for appending to video

BlinkenLib/BlinkenConv.c   17)  * @param[in] str_mode test movie mode: black, white, dots, lines, trans,
BlinkenLib/BlinkenConv.c   18)  *                                      rainbow

BlinkenLib/BlinkenConv.c   19)  * @param[in] str_duration duration of each frame in ms (as string)
BlinkenLib/BlinkenConv.c   20)  */

BlinkenLib/BlinkenConv.c   21) static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,

tools/BlinkenConv.c        22)                            const char *str_mode, const char *str_duration) {

BlinkenLib/BlinkenConv.c   23)   unsigned int height, width, channels, colors;

BlinkenLib/BlinkenConv.c   24)   enum {

tools/BlinkenConv.c        25)     ModeNone,
tools/BlinkenConv.c        26)     ModeBlack,
tools/BlinkenConv.c        27)     ModeWhite,
tools/BlinkenConv.c        28)     ModeGradient,
tools/BlinkenConv.c        29)     ModeDots,
tools/BlinkenConv.c        30)     ModeLines,
tools/BlinkenConv.c        31)     ModeTrans,
tools/BlinkenConv.c        32)     ModeRainbow,

BlinkenLib/BlinkenConv.c   33)   } mode = ModeNone;

BlinkenLib/BlinkenConv.c   34)   int fmt_ok, append, duration;

BlinkenLib/BlinkenConv.c   35) 

tools/BlinkenConv.c        36)   // format

BlinkenLib/BlinkenConv.c   37)   if (str_format == NULL) {
BlinkenLib/BlinkenConv.c   38)     if (*ppMovie == NULL) {
BlinkenLib/BlinkenConv.c   39)       str_format = "<none>";
BlinkenLib/BlinkenConv.c   40)       fmt_ok = 0;
BlinkenLib/BlinkenConv.c   41)       append = 0;
BlinkenLib/BlinkenConv.c   42)     } else {
BlinkenLib/BlinkenConv.c   43)       height = BlinkenMovieGetHeight(*ppMovie);
BlinkenLib/BlinkenConv.c   44)       width = BlinkenMovieGetWidth(*ppMovie);
BlinkenLib/BlinkenConv.c   45)       channels = BlinkenMovieGetChannels(*ppMovie);
BlinkenLib/BlinkenConv.c   46)       colors = BlinkenMovieGetMaxval(*ppMovie) + 1;
BlinkenLib/BlinkenConv.c   47)       fmt_ok = 1;
BlinkenLib/BlinkenConv.c   48)       append = 1;
BlinkenLib/BlinkenConv.c   49)     }
BlinkenLib/BlinkenConv.c   50)   } else {

tools/BlinkenConv.c        51)     fmt_ok = sscanf(str_format, "%ux%u-%u/%u", &width, &height, &channels,
tools/BlinkenConv.c        52)                     &colors) == 4;

BlinkenLib/BlinkenConv.c   53)     append = 0;
BlinkenLib/BlinkenConv.c   54)   }

tools/BlinkenConv.c        55)   // mode

BlinkenLib/BlinkenConv.c   56)   if (strcmp(str_mode, "black") == 0)
BlinkenLib/BlinkenConv.c   57)     mode = ModeBlack;

BlinkenLib/BlinkenConv.c   58)   else if (strcmp(str_mode, "white") == 0)

BlinkenLib/BlinkenConv.c   59)     mode = ModeWhite;

BlinkenLib/BlinkenConv.c   60)   else if (strcmp(str_mode, "gradient") == 0)
BlinkenLib/BlinkenConv.c   61)     mode = ModeGradient;
BlinkenLib/BlinkenConv.c   62)   else if (strcmp(str_mode, "dots") == 0)

BlinkenLib/BlinkenConv.c   63)     mode = ModeDots;

BlinkenLib/BlinkenConv.c   64)   else if (strcmp(str_mode, "lines") == 0)

BlinkenLib/BlinkenConv.c   65)     mode = ModeLines;

BlinkenLib/BlinkenConv.c   66)   else if (strcmp(str_mode, "trans") == 0)

BlinkenLib/BlinkenConv.c   67)     mode = ModeTrans;

BlinkenLib/BlinkenConv.c   68)   else if (strcmp(str_mode, "rainbow") == 0)
BlinkenLib/BlinkenConv.c   69)     mode = ModeRainbow;

tools/BlinkenConv.c        70)   // check
tools/BlinkenConv.c        71)   if (!fmt_ok)

BlinkenLib/BlinkenConv.c   72)     printf("invalid movie format \"%s\" for \"-t\" or \"-ta\"\n", str_format);

BlinkenLib/BlinkenConv.c   73)   else if (mode == ModeNone)

BlinkenLib/BlinkenConv.c   74)     printf("invalid test mode \"%s\" for \"-t\" or \"-ta\"\n", str_mode);

BlinkenLib/BlinkenConv.c   75)   else if (sscanf(str_duration, "%u", &duration) != 1)

BlinkenLib/BlinkenConv.c   76)     printf("invalid duration \"%s\" for \"-t\" or \"-ta\"\n", str_duration);

BlinkenLib/BlinkenConv.c   77)   else {
BlinkenLib/BlinkenConv.c   78) 

tools/BlinkenConv.c        79)     if (!append) {

BlinkenLib/BlinkenConv.c   80)       if (*ppMovie != NULL)
BlinkenLib/BlinkenConv.c   81)         BlinkenMovieFree(*ppMovie);
BlinkenLib/BlinkenConv.c   82)       *ppMovie = BlinkenMovieNew(height, width, channels, colors - 1);
BlinkenLib/BlinkenConv.c   83)       if (*ppMovie == NULL)
BlinkenLib/BlinkenConv.c   84)         printf("could not create movie with format \"%ux%u-%x/%u\""
BlinkenLib/BlinkenConv.c   85)                " for \"-t\" or \"-ta\"\n",
BlinkenLib/BlinkenConv.c   86)                width, height, channels, colors);
BlinkenLib/BlinkenConv.c   87)     }
BlinkenLib/BlinkenConv.c   88) 
BlinkenLib/BlinkenConv.c   89)     if (*ppMovie != NULL) {

BlinkenLib/BlinkenConv.c   90) 

BlinkenLib/BlinkenConv.c   91)       unsigned int y, x, c, c2, c3, o, b, yy, xx, cc, ccc, oo;
BlinkenLib/BlinkenConv.c   92)       float fx, fy, fc;

BlinkenLib/BlinkenConv.c   93)       stBlinkenFrame *pFrame;
BlinkenLib/BlinkenConv.c   94)       height = BlinkenMovieGetHeight(*ppMovie);
BlinkenLib/BlinkenConv.c   95)       width = BlinkenMovieGetWidth(*ppMovie);
BlinkenLib/BlinkenConv.c   96)       channels = BlinkenMovieGetChannels(*ppMovie);
BlinkenLib/BlinkenConv.c   97)       colors = BlinkenMovieGetMaxval(*ppMovie) + 1;
BlinkenLib/BlinkenConv.c   98)       switch (mode) {
BlinkenLib/BlinkenConv.c   99) 
BlinkenLib/BlinkenConv.c  100)       case ModeNone:
BlinkenLib/BlinkenConv.c  101)         break;
BlinkenLib/BlinkenConv.c  102) 

BlinkenLib/BlinkenConv.c  103)       case ModeBlack:

tools/BlinkenConv.c       104)         pFrame = BlinkenFrameNew(height, width, channels, colors - 1, duration);

BlinkenLib/BlinkenConv.c  105)         for (yy = 0; yy < height; yy++)
BlinkenLib/BlinkenConv.c  106)           for (xx = 0; xx < width; xx++)
BlinkenLib/BlinkenConv.c  107)             for (cc = 0; cc < channels; cc++)
BlinkenLib/BlinkenConv.c  108)               BlinkenFrameSetPixel(pFrame, yy, xx, cc, 0);
BlinkenLib/BlinkenConv.c  109)         BlinkenMovieAppendFrame(*ppMovie, pFrame);
BlinkenLib/BlinkenConv.c  110)         break;
BlinkenLib/BlinkenConv.c  111) 
BlinkenLib/BlinkenConv.c  112)       case ModeWhite:

tools/BlinkenConv.c       113)         pFrame = BlinkenFrameNew(height, width, channels, colors - 1, duration);

BlinkenLib/BlinkenConv.c  114)         for (yy = 0; yy < height; yy++)
BlinkenLib/BlinkenConv.c  115)           for (xx = 0; xx < width; xx++)
BlinkenLib/BlinkenConv.c  116)             for (cc = 0; cc < channels; cc++)
BlinkenLib/BlinkenConv.c  117)               BlinkenFrameSetPixel(pFrame, yy, xx, cc, colors - 1);
BlinkenLib/BlinkenConv.c  118)         BlinkenMovieAppendFrame(*ppMovie, pFrame);
BlinkenLib/BlinkenConv.c  119)         break;
BlinkenLib/BlinkenConv.c  120) 

BlinkenLib/BlinkenConv.c  121)       case ModeGradient:

tools/BlinkenConv.c       122)         pFrame = BlinkenFrameNew(height, width, channels, colors - 1, duration);

BlinkenLib/BlinkenConv.c  123)         for (yy = 0; yy < height; yy++) {
BlinkenLib/BlinkenConv.c  124)           fy = (float)yy / (float)(height - 1);
BlinkenLib/BlinkenConv.c  125)           for (xx = 0; xx < width; xx++) {
BlinkenLib/BlinkenConv.c  126)             fx = (float)xx / (float)(width - 1);
BlinkenLib/BlinkenConv.c  127)             for (cc = 0, ccc = 0; cc < channels; cc++) {
BlinkenLib/BlinkenConv.c  128)               switch (ccc) {

tools/BlinkenConv.c       129)               case 0:
tools/BlinkenConv.c       130)                 fc = fx;
tools/BlinkenConv.c       131)                 ccc = 1;
tools/BlinkenConv.c       132)                 break;
tools/BlinkenConv.c       133)               case 1:
tools/BlinkenConv.c       134)                 fc = fy;
tools/BlinkenConv.c       135)                 ccc = 2;
tools/BlinkenConv.c       136)                 break;
tools/BlinkenConv.c       137)               case 2:
tools/BlinkenConv.c       138)                 fc = 1.0f - 0.5f * (fx + fy);
tools/BlinkenConv.c       139)                 ccc = 0;
tools/BlinkenConv.c       140)                 break;
tools/BlinkenConv.c       141)               default:
tools/BlinkenConv.c       142)                 fc = 0.0f;
tools/BlinkenConv.c       143)                 ccc = 0;
tools/BlinkenConv.c       144)                 break;

BlinkenLib/BlinkenConv.c  145)               }
BlinkenLib/BlinkenConv.c  146)               BlinkenFrameSetPixel(pFrame, yy, xx, cc,
BlinkenLib/BlinkenConv.c  147)                                    (int)(fc * (float)(colors - 1) + .5f));
BlinkenLib/BlinkenConv.c  148)             }
BlinkenLib/BlinkenConv.c  149)           }
BlinkenLib/BlinkenConv.c  150)         }
BlinkenLib/BlinkenConv.c  151)         BlinkenMovieAppendFrame(*ppMovie, pFrame);
BlinkenLib/BlinkenConv.c  152)         break;
BlinkenLib/BlinkenConv.c  153) 

BlinkenLib/BlinkenConv.c  154)       case ModeDots:
BlinkenLib/BlinkenConv.c  155)         for (c = 0; c < channels; c++)
BlinkenLib/BlinkenConv.c  156)           for (y = 0; y < height; y++)
BlinkenLib/BlinkenConv.c  157)             for (x = 0; x < width; x++) {

tools/BlinkenConv.c       158)               pFrame = BlinkenFrameNew(height, width, channels, colors - 1,
tools/BlinkenConv.c       159)                                        duration);

BlinkenLib/BlinkenConv.c  160)               for (yy = 0; yy < height; yy++)
BlinkenLib/BlinkenConv.c  161)                 for (xx = 0; xx < width; xx++)
BlinkenLib/BlinkenConv.c  162)                   for (cc = 0; cc < channels; cc++)

tools/BlinkenConv.c       163)                     BlinkenFrameSetPixel(
tools/BlinkenConv.c       164)                         pFrame, yy, xx, cc,
tools/BlinkenConv.c       165)                         yy == y && xx == x && cc == c ? colors - 1 : 0);

BlinkenLib/BlinkenConv.c  166)               BlinkenMovieAppendFrame(*ppMovie, pFrame);

BlinkenLib/BlinkenConv.c  167)             }

BlinkenLib/BlinkenConv.c  168)         break;
BlinkenLib/BlinkenConv.c  169) 
BlinkenLib/BlinkenConv.c  170)       case ModeLines:
BlinkenLib/BlinkenConv.c  171)         for (c = 0; c < channels; c++) {
BlinkenLib/BlinkenConv.c  172)           for (x = 0; x < width; x++) {
BlinkenLib/BlinkenConv.c  173)             pFrame =

tools/BlinkenConv.c       174)                 BlinkenFrameNew(height, width, channels, colors - 1, duration);

BlinkenLib/BlinkenConv.c  175)             for (yy = 0; yy < height; yy++)
BlinkenLib/BlinkenConv.c  176)               for (xx = 0; xx < width; xx++)
BlinkenLib/BlinkenConv.c  177)                 for (cc = 0; cc < channels; cc++)
BlinkenLib/BlinkenConv.c  178)                   BlinkenFrameSetPixel(pFrame, yy, xx, cc,
BlinkenLib/BlinkenConv.c  179)                                        xx == x && cc == c ? colors - 1 : 0);
BlinkenLib/BlinkenConv.c  180)             BlinkenMovieAppendFrame(*ppMovie, pFrame);

BlinkenLib/BlinkenConv.c  181)           }

BlinkenLib/BlinkenConv.c  182)           for (y = 0; y < height; y++) {
BlinkenLib/BlinkenConv.c  183)             pFrame =

tools/BlinkenConv.c       184)                 BlinkenFrameNew(height, width, channels, colors - 1, duration);

BlinkenLib/BlinkenConv.c  185)             for (yy = 0; yy < height; yy++)
BlinkenLib/BlinkenConv.c  186)               for (xx = 0; xx < width; xx++)
BlinkenLib/BlinkenConv.c  187)                 for (cc = 0; cc < channels; cc++)
BlinkenLib/BlinkenConv.c  188)                   BlinkenFrameSetPixel(pFrame, yy, xx, cc,
BlinkenLib/BlinkenConv.c  189)                                        yy == y && cc == c ? colors - 1 : 0);
BlinkenLib/BlinkenConv.c  190)             BlinkenMovieAppendFrame(*ppMovie, pFrame);

BlinkenLib/BlinkenConv.c  191)           }

BlinkenLib/BlinkenConv.c  192)         }
BlinkenLib/BlinkenConv.c  193)         break;
BlinkenLib/BlinkenConv.c  194) 
BlinkenLib/BlinkenConv.c  195)       case ModeTrans:
BlinkenLib/BlinkenConv.c  196)         for (c = 0; c < channels; c++)
BlinkenLib/BlinkenConv.c  197)           for (b = 0; b < 2; b++)
BlinkenLib/BlinkenConv.c  198)             for (c2 = 0; c2 < channels; c2++)
BlinkenLib/BlinkenConv.c  199)               for (o = 0; o < colors - 1; o++) {

tools/BlinkenConv.c       200)                 pFrame = BlinkenFrameNew(height, width, channels, colors - 1,
tools/BlinkenConv.c       201)                                          duration);

BlinkenLib/BlinkenConv.c  202)                 for (cc = 0; cc < channels; cc++) {
BlinkenLib/BlinkenConv.c  203)                   c3 = (cc + channels - c) % channels;

tools/BlinkenConv.c       204)                   oo = b ? (c3 < c2   ? 0
tools/BlinkenConv.c       205)                             : c3 > c2 ? colors - 1
tools/BlinkenConv.c       206)                                       : colors - 1 - o)
tools/BlinkenConv.c       207)                          : (c3 < c2   ? colors - 1
tools/BlinkenConv.c       208)                             : c3 > c2 ? 0
tools/BlinkenConv.c       209)                                       : o);

BlinkenLib/BlinkenConv.c  210)                   for (yy = 0; yy < height; yy++)
BlinkenLib/BlinkenConv.c  211)                     for (xx = 0; xx < width; xx++)
BlinkenLib/BlinkenConv.c  212)                       BlinkenFrameSetPixel(pFrame, yy, xx, cc, oo);
BlinkenLib/BlinkenConv.c  213)                 }
BlinkenLib/BlinkenConv.c  214)                 BlinkenMovieAppendFrame(*ppMovie, pFrame);
BlinkenLib/BlinkenConv.c  215)               }
BlinkenLib/BlinkenConv.c  216)         break;

BlinkenLib/BlinkenConv.c  217) 

BlinkenLib/BlinkenConv.c  218)       case ModeRainbow:
BlinkenLib/BlinkenConv.c  219)         for (b = 0; b < width * height; b++) {

tools/BlinkenConv.c       220)           pFrame =
tools/BlinkenConv.c       221)               BlinkenFrameNew(height, width, channels, colors - 1, duration);

BlinkenLib/BlinkenConv.c  222)           for (yy = 0; yy < height; yy++) {
BlinkenLib/BlinkenConv.c  223)             for (xx = 0; xx < width; xx++) {
BlinkenLib/BlinkenConv.c  224)               for (cc = 0; cc < channels; cc++) {
BlinkenLib/BlinkenConv.c  225)                 y = b + yy + xx + cc * 8;
BlinkenLib/BlinkenConv.c  226)                 switch (y % 24) {

tools/BlinkenConv.c       227)                 case 0:
tools/BlinkenConv.c       228)                   oo = 0;
tools/BlinkenConv.c       229)                   break;
tools/BlinkenConv.c       230)                 case 1:
tools/BlinkenConv.c       231)                   oo = 1;
tools/BlinkenConv.c       232)                   break;
tools/BlinkenConv.c       233)                 case 2:
tools/BlinkenConv.c       234)                   oo = 2;
tools/BlinkenConv.c       235)                   break;
tools/BlinkenConv.c       236)                 case 3:
tools/BlinkenConv.c       237)                   oo = 3;
tools/BlinkenConv.c       238)                   break;
tools/BlinkenConv.c       239)                 case 4:
tools/BlinkenConv.c       240)                   oo = 4;
tools/BlinkenConv.c       241)                   break;
tools/BlinkenConv.c       242)                 case 5:
tools/BlinkenConv.c       243)                   oo = 4;
tools/BlinkenConv.c       244)                   break;
tools/BlinkenConv.c       245)                 case 6:
tools/BlinkenConv.c       246)                   oo = 4;
tools/BlinkenConv.c       247)                   break;
tools/BlinkenConv.c       248)                 case 7:
tools/BlinkenConv.c       249)                   oo = 4;
tools/BlinkenConv.c       250)                   break;
tools/BlinkenConv.c       251)                 case 8:
tools/BlinkenConv.c       252)                   oo = 4;
tools/BlinkenConv.c       253)                   break;
tools/BlinkenConv.c       254)                 case 9:
tools/BlinkenConv.c       255)                   oo = 4;
tools/BlinkenConv.c       256)                   break;
tools/BlinkenConv.c       257)                 case 10:
tools/BlinkenConv.c       258)                   oo = 4;
tools/BlinkenConv.c       259)                   break;
tools/BlinkenConv.c       260)                 case 11:
tools/BlinkenConv.c       261)                   oo = 4;
tools/BlinkenConv.c       262)                   break;
tools/BlinkenConv.c       263)                 case 12:
tools/BlinkenConv.c       264)                   oo = 4;
tools/BlinkenConv.c       265)                   break;
tools/BlinkenConv.c       266)                 case 13:
tools/BlinkenConv.c       267)                   oo = 3;
tools/BlinkenConv.c       268)                   break;
tools/BlinkenConv.c       269)                 case 14:
tools/BlinkenConv.c       270)                   oo = 2;
tools/BlinkenConv.c       271)                   break;
tools/BlinkenConv.c       272)                 case 15:
tools/BlinkenConv.c       273)                   oo = 1;
tools/BlinkenConv.c       274)                   break;
tools/BlinkenConv.c       275)                 default:
tools/BlinkenConv.c       276)                   oo = 0;
tools/BlinkenConv.c       277)                   break;

BlinkenLib/BlinkenConv.c  278)                 }
BlinkenLib/BlinkenConv.c  279)                 oo = oo * colors / 4;
BlinkenLib/BlinkenConv.c  280)                 if (oo > colors - 1)
BlinkenLib/BlinkenConv.c  281)                   oo = colors - 1;
BlinkenLib/BlinkenConv.c  282)                 BlinkenFrameSetPixel(pFrame, yy, xx, cc, oo);
BlinkenLib/BlinkenConv.c  283)               }
BlinkenLib/BlinkenConv.c  284)             }
BlinkenLib/BlinkenConv.c  285)           }
BlinkenLib/BlinkenConv.c  286)           BlinkenMovieAppendFrame(*ppMovie, pFrame);
BlinkenLib/BlinkenConv.c  287)         }
BlinkenLib/BlinkenConv.c  288)         break;
BlinkenLib/BlinkenConv.c  289) 

BlinkenLib/BlinkenConv.c  290)       } // switch( mode )

BlinkenLib/BlinkenConv.c  291) 

BlinkenLib/BlinkenConv.c  292)       printf("test movie generated, using format %ux%u-%u/%u and mode %s\n",
BlinkenLib/BlinkenConv.c  293)              width, height, channels, colors, str_mode);

BlinkenLib/BlinkenConv.c  294) 

tools/BlinkenConv.c       295)     } // if( *ppMovie == NULL ) ... else

BlinkenLib/BlinkenConv.c  296) 

tools/BlinkenConv.c       297)   }   // else

BlinkenLib/BlinkenConv.c  298) }
BlinkenLib/BlinkenConv.c  299) 

BlinkenLib/BlinkenConv.c  300) static void copy_rect(stBlinkenMovie *pMovie, char *str_file,
BlinkenLib/BlinkenConv.c  301)                       const char *str_src_pos, const char *str_dim,

tools/BlinkenConv.c       302)                       const char *str_dest_pos) {

BlinkenLib/BlinkenConv.c  303)   unsigned int sy, sx, h, w, dy, dx;
BlinkenLib/BlinkenConv.c  304)   stBlinkenMovie *pSrcMovie;
BlinkenLib/BlinkenConv.c  305) 
BlinkenLib/BlinkenConv.c  306)   if (sscanf(str_src_pos, "%u,%u", &sx, &sy) != 2)
BlinkenLib/BlinkenConv.c  307)     printf("invalid source position \"%s\" for \"-C\"\n", str_src_pos);
BlinkenLib/BlinkenConv.c  308)   else if (sscanf(str_dim, "%ux%u", &w, &h) != 2)
BlinkenLib/BlinkenConv.c  309)     printf("invalid dimensions \"%s\" for \"-C\"\n", str_dim);
BlinkenLib/BlinkenConv.c  310)   else if (sscanf(str_dest_pos, "%u,%u", &dx, &dy) != 2)
BlinkenLib/BlinkenConv.c  311)     printf("invalid destination position \"%s\" for \"-C\"\n", str_dest_pos);
BlinkenLib/BlinkenConv.c  312)   else {
BlinkenLib/BlinkenConv.c  313) 
BlinkenLib/BlinkenConv.c  314)     pSrcMovie = BlinkenMovieLoad(str_file);
BlinkenLib/BlinkenConv.c  315)     if (pSrcMovie == NULL)
BlinkenLib/BlinkenConv.c  316)       printf("could not read movie \"%s\"\n", str_file);
BlinkenLib/BlinkenConv.c  317)     else {
BlinkenLib/BlinkenConv.c  318) 
BlinkenLib/BlinkenConv.c  319)       BlinkenMovieCopyRect(pMovie, dy, dx, pSrcMovie, sy, sx, h, w);
BlinkenLib/BlinkenConv.c  320)       BlinkenMovieFree(pSrcMovie);

tools/BlinkenConv.c       321)       printf("copied %ux%u pixels from movie \"%s\" %u,%u to %u,%u\n", w, h,
tools/BlinkenConv.c       322)              str_file, sx, sy, dx, dy);

BlinkenLib/BlinkenConv.c  323)     }
BlinkenLib/BlinkenConv.c  324)   }
BlinkenLib/BlinkenConv.c  325) }
BlinkenLib/BlinkenConv.c  326) 

tools/BlinkenConv.c       327) static stBlinkenMovie *scroll(stBlinkenMovie *pMovie, const char *str_direction,
tools/BlinkenConv.c       328)                               const char *str_width_height,
tools/BlinkenConv.c       329)                               const char *str_duration) {

BlinkenLib/BlinkenConv.c  330)   enum {

tools/BlinkenConv.c       331)     DirNone,
tools/BlinkenConv.c       332)     DirLeft,
tools/BlinkenConv.c       333)     DirRight,
tools/BlinkenConv.c       334)     DirUp,
tools/BlinkenConv.c       335)     DirDown,

BlinkenLib/BlinkenConv.c  336)   } dir = DirNone;

tools/BlinkenConv.c       337)   int width_height, duration, height, width, channels, maxval, new_height,
tools/BlinkenConv.c       338)       new_width, sy, sx, dy, dx, steps, step;

BlinkenLib/BlinkenConv.c  339)   stBlinkenFrame *pScroll, *pFrame;
BlinkenLib/BlinkenConv.c  340) 
BlinkenLib/BlinkenConv.c  341)   // direction
BlinkenLib/BlinkenConv.c  342)   if (strcmp(str_direction, "left") == 0)
BlinkenLib/BlinkenConv.c  343)     dir = DirLeft;
BlinkenLib/BlinkenConv.c  344)   else if (strcmp(str_direction, "right") == 0)
BlinkenLib/BlinkenConv.c  345)     dir = DirRight;
BlinkenLib/BlinkenConv.c  346)   else if (strcmp(str_direction, "up") == 0)
BlinkenLib/BlinkenConv.c  347)     dir = DirUp;
BlinkenLib/BlinkenConv.c  348)   else if (strcmp(str_direction, "down") == 0)
BlinkenLib/BlinkenConv.c  349)     dir = DirDown;
BlinkenLib/BlinkenConv.c  350) 
BlinkenLib/BlinkenConv.c  351)   // check
BlinkenLib/BlinkenConv.c  352)   if (dir == DirNone) {
BlinkenLib/BlinkenConv.c  353)     printf("invalid direction \"%s\" for \"-S\" (left, right, up, down)\n",
BlinkenLib/BlinkenConv.c  354)            str_direction);
BlinkenLib/BlinkenConv.c  355)     return pMovie;
BlinkenLib/BlinkenConv.c  356)   }
BlinkenLib/BlinkenConv.c  357)   if (sscanf(str_width_height, "%u", &width_height) != 1 || width_height < 1) {
BlinkenLib/BlinkenConv.c  358)     printf("invalid width/height \"%s\" for \"-S\"\n", str_width_height);
BlinkenLib/BlinkenConv.c  359)     return pMovie;
BlinkenLib/BlinkenConv.c  360)   }
BlinkenLib/BlinkenConv.c  361)   if (sscanf(str_duration, "%u", &duration) != 1 || duration < 1) {
BlinkenLib/BlinkenConv.c  362)     printf("invalid duration \"%s\" for \"-S\"\n", str_duration);
BlinkenLib/BlinkenConv.c  363)     return pMovie;
BlinkenLib/BlinkenConv.c  364)   }
BlinkenLib/BlinkenConv.c  365)   if (BlinkenMovieGetFrameCnt(pMovie) < 1) {
BlinkenLib/BlinkenConv.c  366)     printf("empty movie not allowed for \"-S\"\n");
BlinkenLib/BlinkenConv.c  367)     return pMovie;
BlinkenLib/BlinkenConv.c  368)   }
BlinkenLib/BlinkenConv.c  369) 
BlinkenLib/BlinkenConv.c  370)   // get number of steps
BlinkenLib/BlinkenConv.c  371)   height = BlinkenMovieGetHeight(pMovie);
BlinkenLib/BlinkenConv.c  372)   width = BlinkenMovieGetWidth(pMovie);
BlinkenLib/BlinkenConv.c  373)   channels = BlinkenMovieGetChannels(pMovie);
BlinkenLib/BlinkenConv.c  374)   maxval = BlinkenMovieGetMaxval(pMovie);
BlinkenLib/BlinkenConv.c  375)   new_height = height;
BlinkenLib/BlinkenConv.c  376)   new_width = width;
BlinkenLib/BlinkenConv.c  377)   sy = 0;
BlinkenLib/BlinkenConv.c  378)   sx = 0;
BlinkenLib/BlinkenConv.c  379)   dy = 1;
BlinkenLib/BlinkenConv.c  380)   dx = 1;
BlinkenLib/BlinkenConv.c  381)   switch (dir) {

tools/BlinkenConv.c       382)   case DirNone:
tools/BlinkenConv.c       383)     return pMovie;
tools/BlinkenConv.c       384)   case DirRight:
tools/BlinkenConv.c       385)     sx = 1; // prepare for sx *= steps
tools/BlinkenConv.c       386)     dx = -1;
tools/BlinkenConv.c       387)     // fall through
tools/BlinkenConv.c       388)   case DirLeft:
tools/BlinkenConv.c       389)     dy = 0;
tools/BlinkenConv.c       390)     steps = width - width_height + 1;
tools/BlinkenConv.c       391)     sx *= (steps - 1); // before this line, sx was 0 or 1
tools/BlinkenConv.c       392)     if (steps < 1) {
tools/BlinkenConv.c       393)       printf("invalid width %u for \"-S left/right\" on movie of width %u\n",
tools/BlinkenConv.c       394)              width_height, width);

BlinkenLib/BlinkenConv.c  395)       return pMovie;

tools/BlinkenConv.c       396)     }
tools/BlinkenConv.c       397)     new_width = width_height;
tools/BlinkenConv.c       398)     break;
tools/BlinkenConv.c       399)   case DirDown:
tools/BlinkenConv.c       400)     sy = 1; // prepare for sy *= steps
tools/BlinkenConv.c       401)     dy = -1;
tools/BlinkenConv.c       402)     // fall through
tools/BlinkenConv.c       403)   case DirUp:
tools/BlinkenConv.c       404)     dx = 0;
tools/BlinkenConv.c       405)     steps = height - width_height + 1;
tools/BlinkenConv.c       406)     sy *= (steps - 1); // before this line, sy was 0 or 1
tools/BlinkenConv.c       407)     if (steps < 1) {
tools/BlinkenConv.c       408)       printf("invalid height %u for \"-S up/down\" on movie of height %u\n",
tools/BlinkenConv.c       409)              width_height, width);
tools/BlinkenConv.c       410)       return pMovie;
tools/BlinkenConv.c       411)     }
tools/BlinkenConv.c       412)     new_height = width_height;
tools/BlinkenConv.c       413)     break;

BlinkenLib/BlinkenConv.c  414)   }
BlinkenLib/BlinkenConv.c  415) 
BlinkenLib/BlinkenConv.c  416)   // get copy of first frame
BlinkenLib/BlinkenConv.c  417)   pScroll = BlinkenFrameClone(BlinkenMovieGetFrame(pMovie, 1));
BlinkenLib/BlinkenConv.c  418)   BlinkenFrameSetDuration(pScroll, duration);
BlinkenLib/BlinkenConv.c  419) 
BlinkenLib/BlinkenConv.c  420)   // free old movie
BlinkenLib/BlinkenConv.c  421)   BlinkenMovieFree(pMovie);
BlinkenLib/BlinkenConv.c  422) 
BlinkenLib/BlinkenConv.c  423)   // create new movie scrolling the frame
BlinkenLib/BlinkenConv.c  424)   pMovie = BlinkenMovieNew(new_height, new_width, channels, maxval);
BlinkenLib/BlinkenConv.c  425)   for (step = 0; step < steps; ++step, sy += dy, sx += dx) {
BlinkenLib/BlinkenConv.c  426)     pFrame = BlinkenFrameClone(pScroll);
BlinkenLib/BlinkenConv.c  427)     BlinkenFrameCrop(pFrame, sy, sx, new_height, new_width);
BlinkenLib/BlinkenConv.c  428)     BlinkenMovieAppendFrame(pMovie, pFrame);
BlinkenLib/BlinkenConv.c  429)   }
BlinkenLib/BlinkenConv.c  430) 
BlinkenLib/BlinkenConv.c  431)   // free scrolled frame
BlinkenLib/BlinkenConv.c  432)   BlinkenFrameFree(pScroll);
BlinkenLib/BlinkenConv.c  433) 

BlinkenLib/BlinkenConv.c  434)   printf("scrolled %ux%u-%u/%u frame to %ux%u-%u/%u movie (direction %s)\n",

tools/BlinkenConv.c       435)          width, height, channels, maxval + 1, new_width, new_height, channels,
tools/BlinkenConv.c       436)          maxval + 1, str_direction);

BlinkenLib/BlinkenConv.c  437) 

BlinkenLib/BlinkenConv.c  438)   return pMovie;
BlinkenLib/BlinkenConv.c  439) }
BlinkenLib/BlinkenConv.c  440) 

tools/BlinkenConv.c       441) int main(int argCnt, char **args) {

BlinkenLib/BlinkenConv.c  442)   stBlinkenMovie *pMovie;

BlinkenConv.c             443)   int i;

BlinkenLib/BlinkenConv.c  444)   char *str;

BlinkenLib/BlinkenConv.c  445)   unsigned int height, width, channels, colors, times, top, left;

BlinkenLib/BlinkenConv.c  446)   int mode;
BlinkenLib/BlinkenConv.c  447) 
BlinkenLib/BlinkenConv.c  448)   // print info
BlinkenLib/BlinkenConv.c  449)   printf("BlinkenLib - BlinkenConv\n"
BlinkenLib/BlinkenConv.c  450)          "version %d.%d.%d\n"
BlinkenLib/BlinkenConv.c  451)          "config " BLINKENLIB_CONFIG "\n"

BlinkenLib/BlinkenConv.c  452)          "Copyright 2004-2016 Stefan Schuermans <stefan@schuermans.info>\n"

BlinkenLib/BlinkenConv.c  453)          "Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html\n"

BlinkenLib/BlinkenConv.c  454)          "a blinkenarea.org project\n\n",
BlinkenLib/BlinkenConv.c  455)          BLINKENLIB_VERSION_MAJOR, BLINKENLIB_VERSION_MINOR,
BlinkenLib/BlinkenConv.c  456)          BLINKENLIB_VERSION_REVISION);
BlinkenLib/BlinkenConv.c  457) 
BlinkenLib/BlinkenConv.c  458)   // print syntax
BlinkenLib/BlinkenConv.c  459)   if (argCnt <= 1) {

BlinkenLib/BlinkenConv.c  460) #ifdef BLINKENLIB_CFG_MNG

tools/BlinkenConv.c       461) #define MNGEXT ", *.mng"

BlinkenLib/BlinkenConv.c  462) #else

tools/BlinkenConv.c       463) #define MNGEXT

BlinkenLib/BlinkenConv.c  464) #endif
BlinkenLib/BlinkenConv.c  465) #ifdef BLINKENLIB_CFG_GIF

tools/BlinkenConv.c       466) #define GIFEXT ", *.gif"

BlinkenLib/BlinkenConv.c  467) #else

tools/BlinkenConv.c       468) #define GIFEXT

BlinkenLib/BlinkenConv.c  469) #endif

tools/BlinkenConv.c       470)     printf(
tools/BlinkenConv.c       471)         "syntax: %s <parameter> [...]\n\n"
tools/BlinkenConv.c       472)         "parameters:\n"
tools/BlinkenConv.c       473)         "  -i <file>\n"
tools/BlinkenConv.c       474)         "     read movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT
tools/BlinkenConv.c       475)         ")\n"
tools/BlinkenConv.c       476)         "  -a <file>\n"
tools/BlinkenConv.c       477)         "     append movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT
tools/BlinkenConv.c       478)         ")\n"
tools/BlinkenConv.c       479)         "  -l <number>\n"
tools/BlinkenConv.c       480)         "     loop video a number of times\n"
tools/BlinkenConv.c       481)         "  -f\n"
tools/BlinkenConv.c       482)         "     output format, frame count and duration of movie\n"
tools/BlinkenConv.c       483)         "  -p\n"
tools/BlinkenConv.c       484)         "     print movie\n"
tools/BlinkenConv.c       485)         "  -r <width>x<height>-<channels>/<colors>\n"
tools/BlinkenConv.c       486)         "     resize movie\n"
tools/BlinkenConv.c       487)         "  -cr <src-x>,<src-y> <width>x<height>\n"
tools/BlinkenConv.c       488)         "     crop movie\n"
tools/BlinkenConv.c       489)         "  -s <width>x<height>\n"
tools/BlinkenConv.c       490)         "     scale movie\n"
tools/BlinkenConv.c       491)         "  -c <channels> [solid|rainbow]\n"
tools/BlinkenConv.c       492)         "     colorize movie\n"
tools/BlinkenConv.c       493)         "  -R\n"
tools/BlinkenConv.c       494)         "     reverse movie\n"
tools/BlinkenConv.c       495)         "  -ct <begin> <end>\n"
tools/BlinkenConv.c       496)         "     cut movie to time span from begin (in ms) till end (in ms)\n"
tools/BlinkenConv.c       497)         "  -dur <duration>\n"
tools/BlinkenConv.c       498)         "     adapt duration (in ms) of movie\n"
tools/BlinkenConv.c       499)         "  -maxframedur <duration>\n"
tools/BlinkenConv.c       500)         "     adapt maximum duration (in ms) per frame\n"
tools/BlinkenConv.c       501)         "  -d <first> <count>\n"
tools/BlinkenConv.c       502)         "     delete frames\n"
tools/BlinkenConv.c       503)         "  -t <width>x<height>-<channels>/<colors> <test_mode> <duration>\n"
tools/BlinkenConv.c       504)         "     generate a test movie (duration in ms)\n"
tools/BlinkenConv.c       505)         "  -ta <test_mode> <duration>\n"
tools/BlinkenConv.c       506)         "     generate a test movie and append it to current video\n"
tools/BlinkenConv.c       507)         "  -C <file> <src-x>,<src-y> <width>x<height> <dest-x>,<dest-y>\n"
tools/BlinkenConv.c       508)         "     copy rectangular section of other movie\n"
tools/BlinkenConv.c       509)         "  -S {left|right|up|down} <width/height> <duration>\n"
tools/BlinkenConv.c       510)         "     scroll first frame of current movie (duration in ms)\n"
tools/BlinkenConv.c       511)         "  -Rcw\n"
tools/BlinkenConv.c       512)         "     rotate movie 90 degrees clockwise\n"
tools/BlinkenConv.c       513)         "  -Rccw\n"
tools/BlinkenConv.c       514)         "     rotate movie 90 degrees counter-clockwise\n"
tools/BlinkenConv.c       515)         "  -Rh\n"
tools/BlinkenConv.c       516)         "     rotate movie 180 degrees\n"
tools/BlinkenConv.c       517)         "  -Mh\n"
tools/BlinkenConv.c       518)         "     mirror movie horizontally\n"
tools/BlinkenConv.c       519)         "  -Mv\n"
tools/BlinkenConv.c       520)         "     mirror movie vertically\n"
tools/BlinkenConv.c       521)         "  -Md\n"
tools/BlinkenConv.c       522)         "     mirror movie diagonally (\\)\n"
tools/BlinkenConv.c       523)         "  -Md2\n"
tools/BlinkenConv.c       524)         "     mirror movie diagonally (/)\n"
tools/BlinkenConv.c       525)         "  -o <file>\n"
tools/BlinkenConv.c       526)         "     write movie to file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT
tools/BlinkenConv.c       527)         ")\n\n"
tools/BlinkenConv.c       528)         "test_modes: black, white, gradient, dots, lines, trans, rainbow\n\n"
tools/BlinkenConv.c       529)         "old syntax: %s <input-file> [<output-file>]\n\n",
tools/BlinkenConv.c       530)         args[0], args[0]);

BlinkenConv.c             531)     return 0;

BlinkenConv.c             532)   }

BlinkenLib/BlinkenConv.c  533)   // no movie loaded

BlinkenConv.c             534)   pMovie = NULL;
BlinkenConv.c             535) 

BlinkenLib/BlinkenConv.c  536)   // process parameters
BlinkenLib/BlinkenConv.c  537)   for (i = 1; i < argCnt; i++) {

BlinkenConv.c             538) 

BlinkenLib/BlinkenConv.c  539)     // read movie
BlinkenLib/BlinkenConv.c  540)     if (strcmp(args[i], "-i") == 0) {
BlinkenLib/BlinkenConv.c  541)       if (i + 1 < argCnt) {

BlinkenConv.c             542)         i++;

BlinkenLib/BlinkenConv.c  543)         if (pMovie != NULL)
BlinkenLib/BlinkenConv.c  544)           BlinkenMovieFree(pMovie);
BlinkenLib/BlinkenConv.c  545)         pMovie = BlinkenMovieLoad(args[i]);
BlinkenLib/BlinkenConv.c  546)         if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  547)           printf("could not read movie \"%s\"\n", args[i]);

BlinkenConv.c             548)         else

BlinkenLib/BlinkenConv.c  549)           printf("movie \"%s\" read\n", args[i]);
BlinkenLib/BlinkenConv.c  550)       } else
BlinkenLib/BlinkenConv.c  551)         printf("missing input filename for \"-i\"\n");

BlinkenConv.c             552)     }

BlinkenLib/BlinkenConv.c  553)     // append movie
BlinkenLib/BlinkenConv.c  554)     else if (strcmp(args[i], "-a") == 0) {
BlinkenLib/BlinkenConv.c  555)       if (i + 1 < argCnt) {

BlinkenLib/BlinkenConv.c  556)         i++;

BlinkenLib/BlinkenConv.c  557)         if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  558)           printf("no movie loaded to append to\n");

BlinkenLib/BlinkenConv.c  559)         else {

BlinkenLib/BlinkenConv.c  560)           stBlinkenMovie *pMovie2;
BlinkenLib/BlinkenConv.c  561)           pMovie2 = BlinkenMovieLoad(args[i]);
BlinkenLib/BlinkenConv.c  562)           if (pMovie2 == NULL)
BlinkenLib/BlinkenConv.c  563)             printf("could not read movie \"%s\"\n", args[i]);

BlinkenLib/BlinkenConv.c  564)           else {

BlinkenLib/BlinkenConv.c  565)             if (BlinkenMovieConcat(pMovie, pMovie2) < 0) {
BlinkenLib/BlinkenConv.c  566)               BlinkenMovieFree(pMovie2);

tools/BlinkenConv.c       567)               printf("movie read from \"%s\" could not be appended\n", args[i]);

BlinkenLib/BlinkenConv.c  568)             } else

BlinkenLib/BlinkenConv.c  569)               printf("movie \"%s\" read and appended\n", args[i]);

BlinkenLib/BlinkenConv.c  570)           }
BlinkenLib/BlinkenConv.c  571)         }

BlinkenLib/BlinkenConv.c  572)       } else
BlinkenLib/BlinkenConv.c  573)         printf("missing input filename for \"-a\"\n");

BlinkenLib/BlinkenConv.c  574)     }

BlinkenLib/BlinkenConv.c  575)     // loop movie
BlinkenLib/BlinkenConv.c  576)     else if (strcmp(args[i], "-l") == 0) {
BlinkenLib/BlinkenConv.c  577)       if (i + 1 < argCnt) {

BlinkenLib/BlinkenConv.c  578)         i++;

BlinkenLib/BlinkenConv.c  579)         if (sscanf(args[i], "%u", &times) != 1 || times < 1)
BlinkenLib/BlinkenConv.c  580)           printf("invalid number of times \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c  581)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  582)           printf("no movie loaded to loop\n");
BlinkenLib/BlinkenConv.c  583)         else {
BlinkenLib/BlinkenConv.c  584)           stBlinkenMovie *pMovie2, *pMovie3;

BlinkenLib/BlinkenConv.c  585)           int err = 0;
BlinkenLib/BlinkenConv.c  586)           unsigned int t;

BlinkenLib/BlinkenConv.c  587)           pMovie2 = BlinkenMovieClone(pMovie);
BlinkenLib/BlinkenConv.c  588)           if (pMovie2 == NULL)

BlinkenLib/BlinkenConv.c  589)             err = 1;
BlinkenLib/BlinkenConv.c  590)           else {

tools/BlinkenConv.c       591)             for (t = 1 /* loop one time means nothing to do */; t < times;

BlinkenLib/BlinkenConv.c  592)                  t++) {
BlinkenLib/BlinkenConv.c  593)               pMovie3 = BlinkenMovieClone(pMovie2);
BlinkenLib/BlinkenConv.c  594)               if (pMovie3 == NULL)

BlinkenLib/BlinkenConv.c  595)                 err = 1;
BlinkenLib/BlinkenConv.c  596)               else {

BlinkenLib/BlinkenConv.c  597)                 if (BlinkenMovieConcat(pMovie, pMovie3) < 0) {
BlinkenLib/BlinkenConv.c  598)                   BlinkenMovieFree(pMovie3);

BlinkenLib/BlinkenConv.c  599)                   err = 1;
BlinkenLib/BlinkenConv.c  600)                 }
BlinkenLib/BlinkenConv.c  601)               }
BlinkenLib/BlinkenConv.c  602)             }

BlinkenLib/BlinkenConv.c  603)             BlinkenMovieFree(pMovie2);

BlinkenLib/BlinkenConv.c  604)           }

BlinkenLib/BlinkenConv.c  605)           if (err)
BlinkenLib/BlinkenConv.c  606)             printf("could not loop movie\n");

BlinkenLib/BlinkenConv.c  607)           else

BlinkenLib/BlinkenConv.c  608)             printf("movie looped %u times\n", times);

BlinkenLib/BlinkenConv.c  609)         }

BlinkenLib/BlinkenConv.c  610)       } else

BlinkenLib/BlinkenConv.c  611)         printf("missing loop count for \"-l\"\n");

BlinkenLib/BlinkenConv.c  612)     }

BlinkenLib/BlinkenConv.c  613)     // output format, frame count and duration of movie
BlinkenLib/BlinkenConv.c  614)     else if (strcmp(args[i], "-f") == 0) {
BlinkenLib/BlinkenConv.c  615)       if (pMovie == NULL)

tools/BlinkenConv.c       616)         printf(
tools/BlinkenConv.c       617)             "no movie loaded to output format, frame count and duration of\n");

BlinkenLib/BlinkenConv.c  618)       else

tools/BlinkenConv.c       619)         printf(
tools/BlinkenConv.c       620)             "format:      %ux%u-%u/%u\nframe count: %u\nduration:    %u ms\n",
tools/BlinkenConv.c       621)             BlinkenMovieGetWidth(pMovie), BlinkenMovieGetHeight(pMovie),
tools/BlinkenConv.c       622)             BlinkenMovieGetChannels(pMovie), BlinkenMovieGetMaxval(pMovie) + 1,
tools/BlinkenConv.c       623)             BlinkenMovieGetFrameCnt(pMovie), BlinkenMovieGetDuration(pMovie));

BlinkenLib/BlinkenConv.c  624)     }

BlinkenLib/BlinkenConv.c  625)     // print movie
BlinkenLib/BlinkenConv.c  626)     else if (strcmp(args[i], "-p") == 0) {
BlinkenLib/BlinkenConv.c  627)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  628)         printf("no movie loaded to print\n");
BlinkenLib/BlinkenConv.c  629)       else {
BlinkenLib/BlinkenConv.c  630)         str = BlinkenMovieToString(pMovie);
BlinkenLib/BlinkenConv.c  631)         if (str == NULL)
BlinkenLib/BlinkenConv.c  632)           printf("could not print movie\n");
BlinkenLib/BlinkenConv.c  633)         else {
BlinkenLib/BlinkenConv.c  634)           printf("%s", str);
BlinkenLib/BlinkenConv.c  635)           free(str);

BlinkenConv.c             636)         }

BlinkenConv.c             637)       }
BlinkenConv.c             638)     }

BlinkenLib/BlinkenConv.c  639)     // resize movie
BlinkenLib/BlinkenConv.c  640)     else if (strcmp(args[i], "-r") == 0) {
BlinkenLib/BlinkenConv.c  641)       if (i + 1 < argCnt) {

BlinkenConv.c             642)         i++;

tools/BlinkenConv.c       643)         if (sscanf(args[i], "%ux%u-%u/%u", &width, &height, &channels,
tools/BlinkenConv.c       644)                    &colors) != 4)

BlinkenLib/BlinkenConv.c  645)           printf("invalid movie format \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c  646)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  647)           printf("no movie loaded to resize\n");
BlinkenLib/BlinkenConv.c  648)         else {
BlinkenLib/BlinkenConv.c  649)           BlinkenMovieResize(pMovie, height, width, channels, colors - 1);
BlinkenLib/BlinkenConv.c  650)           printf("movie resized to %ux%u-%u/%u\n", width, height, channels,
BlinkenLib/BlinkenConv.c  651)                  colors);

BlinkenConv.c             652)         }

BlinkenLib/BlinkenConv.c  653)       } else
BlinkenLib/BlinkenConv.c  654)         printf("missing movie format for \"-r\"\n");

BlinkenConv.c             655)     }

BlinkenLib/BlinkenConv.c  656)     // crop movie
BlinkenLib/BlinkenConv.c  657)     else if (strcmp(args[i], "-cr") == 0) {
BlinkenLib/BlinkenConv.c  658)       if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c  659)         const char *topleft, *dimensions;
BlinkenLib/BlinkenConv.c  660)         i++;
BlinkenLib/BlinkenConv.c  661)         topleft = args[i];
BlinkenLib/BlinkenConv.c  662)         i++;
BlinkenLib/BlinkenConv.c  663)         dimensions = args[i];

tools/BlinkenConv.c       664)         if (sscanf(topleft, "%u,%u", &left, &top) != 2)

BlinkenLib/BlinkenConv.c  665)           printf("invalid top-left position \"%s\"\n", topleft);

tools/BlinkenConv.c       666)         else if (sscanf(dimensions, "%ux%u", &width, &height) != 2)

BlinkenLib/BlinkenConv.c  667)           printf("invalid movie dimensions \"%s\"\n", dimensions);
BlinkenLib/BlinkenConv.c  668)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  669)           printf("no movie loaded to crop\n");
BlinkenLib/BlinkenConv.c  670)         else {
BlinkenLib/BlinkenConv.c  671)           BlinkenMovieCrop(pMovie, top, left, height, width);
BlinkenLib/BlinkenConv.c  672)           printf("movie cropped to %u,%u %ux%u\n", left, top, width, height);
BlinkenLib/BlinkenConv.c  673)         }
BlinkenLib/BlinkenConv.c  674)       } else if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c  675)         printf("missing dimensions for \"-cr\"\n");
BlinkenLib/BlinkenConv.c  676)         i++;
BlinkenLib/BlinkenConv.c  677)       } else
BlinkenLib/BlinkenConv.c  678)         printf("missing top-left position for \"-cr\"\n");
BlinkenLib/BlinkenConv.c  679)     }

BlinkenLib/BlinkenConv.c  680)     // scale movie
BlinkenLib/BlinkenConv.c  681)     else if (strcmp(args[i], "-s") == 0) {
BlinkenLib/BlinkenConv.c  682)       if (i + 1 < argCnt) {

BlinkenConv.c             683)         i++;

BlinkenLib/BlinkenConv.c  684)         if (sscanf(args[i], "%ux%u", &width, &height) != 2)
BlinkenLib/BlinkenConv.c  685)           printf("invalid movie dimensions \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c  686)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  687)           printf("no movie loaded to scale\n");
BlinkenLib/BlinkenConv.c  688)         else {
BlinkenLib/BlinkenConv.c  689)           BlinkenMovieScale(pMovie, height, width);
BlinkenLib/BlinkenConv.c  690)           printf("movie scaled to %ux%u\n", width, height);

BlinkenConv.c             691)         }

BlinkenLib/BlinkenConv.c  692)       } else
BlinkenLib/BlinkenConv.c  693)         printf("missing movie dimensions for \"-s\"\n");

BlinkenConv.c             694)     }

BlinkenLib/BlinkenConv.c  695)     // colorize movie
BlinkenLib/BlinkenConv.c  696)     else if (strcmp(args[i], "-c") == 0) {
BlinkenLib/BlinkenConv.c  697)       if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c  698)         const char *str_channels, *str_mode;

BlinkenConv.c             699)         i++;

BlinkenLib/BlinkenConv.c  700)         str_channels = args[i];
BlinkenLib/BlinkenConv.c  701)         i++;
BlinkenLib/BlinkenConv.c  702)         str_mode = args[i];

BlinkenLib/BlinkenConv.c  703)         if (sscanf(str_channels, "%u", &channels) != 1)
BlinkenLib/BlinkenConv.c  704)           printf("invalid number of channels \"%s\"\n", str_channels);
BlinkenLib/BlinkenConv.c  705)         else {
BlinkenLib/BlinkenConv.c  706)           mode = BlinkenColorizerStr2Mode(str_mode);
BlinkenLib/BlinkenConv.c  707)           if (mode < 0)
BlinkenLib/BlinkenConv.c  708)             printf("invalid colorizing mode \"%s\"\n", str_mode);
BlinkenLib/BlinkenConv.c  709)           else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  710)             printf("no movie loaded to colorize\n");
BlinkenLib/BlinkenConv.c  711)           else {
BlinkenLib/BlinkenConv.c  712)             BlinkenMovieColorize(pMovie, channels, mode);
BlinkenLib/BlinkenConv.c  713)             printf("movie colorized to %u channels using mode %s\n", channels,
BlinkenLib/BlinkenConv.c  714)                    BlinkenColorizerMode2Str(mode));

BlinkenConv.c             715)           }
BlinkenConv.c             716)         }

BlinkenLib/BlinkenConv.c  717)       } else if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c  718)         printf("missing colorizing mode for \"-c\"\n");

BlinkenLib/BlinkenConv.c  719)         i++;

BlinkenLib/BlinkenConv.c  720)       } else
BlinkenLib/BlinkenConv.c  721)         printf("missing number of channels for \"-c\"\n");

BlinkenConv.c             722)     }

BlinkenLib/BlinkenConv.c  723)     // reverse movie
BlinkenLib/BlinkenConv.c  724)     else if (strcmp(args[i], "-R") == 0) {
BlinkenLib/BlinkenConv.c  725)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  726)         printf("no movie loaded to reverse\n");

BlinkenLib/BlinkenConv.c  727)       else {

BlinkenLib/BlinkenConv.c  728)         BlinkenMovieReverse(pMovie);
BlinkenLib/BlinkenConv.c  729)         printf("movie reversed\n");

BlinkenLib/BlinkenConv.c  730)       }
BlinkenLib/BlinkenConv.c  731)     }

BlinkenLib/BlinkenConv.c  732)     // cut movie to time span
BlinkenLib/BlinkenConv.c  733)     else if (strcmp(args[i], "-ct") == 0) {
BlinkenLib/BlinkenConv.c  734)       if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c  735)         const char *str_begin, *str_end;
BlinkenLib/BlinkenConv.c  736)         unsigned int begin, end;
BlinkenLib/BlinkenConv.c  737)         i++;
BlinkenLib/BlinkenConv.c  738)         str_begin = args[i];
BlinkenLib/BlinkenConv.c  739)         i++;
BlinkenLib/BlinkenConv.c  740)         str_end = args[i];
BlinkenLib/BlinkenConv.c  741)         if (sscanf(str_begin, "%u", &begin) != 1)
BlinkenLib/BlinkenConv.c  742)           printf("invalid begin time \"%s\"\n", str_begin);
BlinkenLib/BlinkenConv.c  743)         else if (sscanf(str_end, "%u", &end) != 1)
BlinkenLib/BlinkenConv.c  744)           printf("invalid end time \"%s\"\n", str_end);
BlinkenLib/BlinkenConv.c  745)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  746)           printf("no movie loaded to cut to time span\n");
BlinkenLib/BlinkenConv.c  747)         else {
BlinkenLib/BlinkenConv.c  748)           BlinkenMovieCutTime(pMovie, begin, end);
BlinkenLib/BlinkenConv.c  749)           printf("movie cut to time %u-%u\n", begin, end);
BlinkenLib/BlinkenConv.c  750)         }

tools/BlinkenConv.c       751)       } else if (i + 1 < argCnt) {

BlinkenLib/BlinkenConv.c  752)         printf("missing end time for \"-ct\"\n");
BlinkenLib/BlinkenConv.c  753)         i++;
BlinkenLib/BlinkenConv.c  754)       } else
BlinkenLib/BlinkenConv.c  755)         printf("missing begin time for \"-ct\"\n");
BlinkenLib/BlinkenConv.c  756)     }

BlinkenLib/BlinkenConv.c  757)     // adapt duration of movie
BlinkenLib/BlinkenConv.c  758)     else if (strcmp(args[i], "-dur") == 0) {
BlinkenLib/BlinkenConv.c  759)       if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c  760)         unsigned int duration;
BlinkenLib/BlinkenConv.c  761)         i++;
BlinkenLib/BlinkenConv.c  762)         if (sscanf(args[i], "%u", &duration) != 1)
BlinkenLib/BlinkenConv.c  763)           printf("invalid duration \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c  764)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  765)           printf("no movie loaded to adapt duration of\n");
BlinkenLib/BlinkenConv.c  766)         else {
BlinkenLib/BlinkenConv.c  767)           BlinkenMovieAdaptDuration(pMovie, duration);
BlinkenLib/BlinkenConv.c  768)           printf("duration adapted to %u ms\n", duration);
BlinkenLib/BlinkenConv.c  769)         }
BlinkenLib/BlinkenConv.c  770)       } else
BlinkenLib/BlinkenConv.c  771)         printf("missing new duration for movie for \"-dur\"\n");
BlinkenLib/BlinkenConv.c  772)     }

BlinkenLib/BlinkenConv.c  773)     // adapt maximum frame duration
BlinkenLib/BlinkenConv.c  774)     else if (strcmp(args[i], "-maxframedur") == 0) {
BlinkenLib/BlinkenConv.c  775)       if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c  776)         unsigned int duration;
BlinkenLib/BlinkenConv.c  777)         i++;
BlinkenLib/BlinkenConv.c  778)         if (sscanf(args[i], "%u", &duration) != 1)
BlinkenLib/BlinkenConv.c  779)           printf("invalid duration \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c  780)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  781)           printf("no movie loaded to adapt maximum frame duration of\n");
BlinkenLib/BlinkenConv.c  782)         else {
BlinkenLib/BlinkenConv.c  783)           BlinkenMovieAdaptMaxFrameDuration(pMovie, duration);
BlinkenLib/BlinkenConv.c  784)           printf("maximum frame duration adapted to %u ms\n", duration);
BlinkenLib/BlinkenConv.c  785)         }
BlinkenLib/BlinkenConv.c  786)       } else
BlinkenLib/BlinkenConv.c  787)         printf("missing maximum frame duration for \"-maxframedur\"\n");
BlinkenLib/BlinkenConv.c  788)     }

BlinkenLib/BlinkenConv.c  789)     // delete frames
BlinkenLib/BlinkenConv.c  790)     else if (strcmp(args[i], "-d") == 0) {
BlinkenLib/BlinkenConv.c  791)       if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c  792)         const char *str_first, *str_count;

BlinkenLib/BlinkenConv.c  793)         unsigned int first, count, c;
BlinkenLib/BlinkenConv.c  794)         i++;
BlinkenLib/BlinkenConv.c  795)         str_first = args[i];
BlinkenLib/BlinkenConv.c  796)         i++;
BlinkenLib/BlinkenConv.c  797)         str_count = args[i];

BlinkenLib/BlinkenConv.c  798)         if (sscanf(str_first, "%u", &first) != 1)
BlinkenLib/BlinkenConv.c  799)           printf("invalid number of first frame \"%s\"\n", str_first);

BlinkenLib/BlinkenConv.c  800)         else {

BlinkenLib/BlinkenConv.c  801)           if (sscanf(str_count, "%u", &count) != 1)
BlinkenLib/BlinkenConv.c  802)             printf("invalid number of frames \"%s\"\n", str_count);
BlinkenLib/BlinkenConv.c  803)           else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  804)             printf("no movie loaded to delete frames from\n");
BlinkenLib/BlinkenConv.c  805)           else if (first + count >
BlinkenLib/BlinkenConv.c  806)                    (unsigned int)BlinkenMovieGetFrameCnt(pMovie))

tools/BlinkenConv.c       807)             printf("invalid frame range (%u-%u) for deletion from %u frames\n",
tools/BlinkenConv.c       808)                    first, first + count,
tools/BlinkenConv.c       809)                    (unsigned int)BlinkenMovieGetFrameCnt(pMovie));

BlinkenLib/BlinkenConv.c  810)           else {

BlinkenLib/BlinkenConv.c  811)             for (c = 0; c < count; c++)
BlinkenLib/BlinkenConv.c  812)               BlinkenMovieDeleteFrame(pMovie, first);
BlinkenLib/BlinkenConv.c  813)             printf("deleted frames %u-%u\n", first, first + count);

BlinkenLib/BlinkenConv.c  814)           }
BlinkenLib/BlinkenConv.c  815)         }

BlinkenLib/BlinkenConv.c  816)       } else if (i + 1 < argCnt) {

BlinkenLib/BlinkenConv.c  817)         printf("missing number of frames for \"-d\"\n");

BlinkenLib/BlinkenConv.c  818)         i++;

BlinkenLib/BlinkenConv.c  819)       } else

BlinkenLib/BlinkenConv.c  820)         printf("missing number of first frame for \"-d\"\n");

BlinkenLib/BlinkenConv.c  821)     }

BlinkenLib/BlinkenConv.c  822)     // generate test movie
BlinkenLib/BlinkenConv.c  823)     else if (strcmp(args[i], "-t") == 0) {
BlinkenLib/BlinkenConv.c  824)       if (i + 3 < argCnt) {
BlinkenLib/BlinkenConv.c  825)         const char *str_format, *str_mode, *str_duration;

BlinkenLib/BlinkenConv.c  826)         i++;
BlinkenLib/BlinkenConv.c  827)         str_format = args[i];
BlinkenLib/BlinkenConv.c  828)         i++;
BlinkenLib/BlinkenConv.c  829)         str_mode = args[i];
BlinkenLib/BlinkenConv.c  830)         i++;
BlinkenLib/BlinkenConv.c  831)         str_duration = args[i];

BlinkenLib/BlinkenConv.c  832)         gen_test_movie(&pMovie, str_format, str_mode, str_duration);
BlinkenLib/BlinkenConv.c  833)       } else if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c  834)         printf("missing duration for \"-t\"\n");

BlinkenLib/BlinkenConv.c  835)         i += 2;

BlinkenLib/BlinkenConv.c  836)       } else if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c  837)         printf("missing test mode for \"-t\"\n");

BlinkenLib/BlinkenConv.c  838)         i++;

BlinkenLib/BlinkenConv.c  839)       } else
BlinkenLib/BlinkenConv.c  840)         printf("missing format for \"-t\"\n");

BlinkenLib/BlinkenConv.c  841)     }

BlinkenLib/BlinkenConv.c  842)     // generate test movie and append it to current video
BlinkenLib/BlinkenConv.c  843)     else if (strcmp(args[i], "-ta") == 0) {
BlinkenLib/BlinkenConv.c  844)       if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c  845)         const char *str_mode, *str_duration;
BlinkenLib/BlinkenConv.c  846)         i++;
BlinkenLib/BlinkenConv.c  847)         str_mode = args[i];
BlinkenLib/BlinkenConv.c  848)         i++;
BlinkenLib/BlinkenConv.c  849)         str_duration = args[i];
BlinkenLib/BlinkenConv.c  850)         if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  851)           printf("no movie loaded to append to\n");
BlinkenLib/BlinkenConv.c  852)         else
BlinkenLib/BlinkenConv.c  853)           gen_test_movie(&pMovie, NULL /* append */, str_mode, str_duration);
BlinkenLib/BlinkenConv.c  854)       } else if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c  855)         printf("missing duration for \"-ta\"\n");
BlinkenLib/BlinkenConv.c  856)         i += 1;
BlinkenLib/BlinkenConv.c  857)       } else if (i < argCnt)
BlinkenLib/BlinkenConv.c  858)         printf("missing test mode for \"-ta\"\n");
BlinkenLib/BlinkenConv.c  859)     }

BlinkenLib/BlinkenConv.c  860)     // copy rectangular section of other movie
BlinkenLib/BlinkenConv.c  861)     else if (strcmp(args[i], "-C") == 0) {
BlinkenLib/BlinkenConv.c  862)       if (i + 4 < argCnt) {
BlinkenLib/BlinkenConv.c  863)         char *str_file;
BlinkenLib/BlinkenConv.c  864)         const char *str_src_pos, *str_dim, *str_dest_pos;
BlinkenLib/BlinkenConv.c  865)         i++;
BlinkenLib/BlinkenConv.c  866)         str_file = args[i];
BlinkenLib/BlinkenConv.c  867)         i++;
BlinkenLib/BlinkenConv.c  868)         str_src_pos = args[i];
BlinkenLib/BlinkenConv.c  869)         i++;
BlinkenLib/BlinkenConv.c  870)         str_dim = args[i];
BlinkenLib/BlinkenConv.c  871)         i++;
BlinkenLib/BlinkenConv.c  872)         str_dest_pos = args[i];
BlinkenLib/BlinkenConv.c  873)         copy_rect(pMovie, str_file, str_src_pos, str_dim, str_dest_pos);
BlinkenLib/BlinkenConv.c  874)       } else if (i + 3 < argCnt) {
BlinkenLib/BlinkenConv.c  875)         printf("missing destination position for \"-C\"\n");
BlinkenLib/BlinkenConv.c  876)         i += 3;
BlinkenLib/BlinkenConv.c  877)       } else if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c  878)         printf("missing dimensions for \"-C\"\n");
BlinkenLib/BlinkenConv.c  879)         i += 2;
BlinkenLib/BlinkenConv.c  880)       } else if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c  881)         printf("missing source position for \"-C\"\n");
BlinkenLib/BlinkenConv.c  882)         i++;
BlinkenLib/BlinkenConv.c  883)       } else
BlinkenLib/BlinkenConv.c  884)         printf("missing file name of source movie for \"-C\"\n");
BlinkenLib/BlinkenConv.c  885)     }

BlinkenLib/BlinkenConv.c  886)     // scroll first frame of current movie
BlinkenLib/BlinkenConv.c  887)     else if (strcmp(args[i], "-S") == 0) {
BlinkenLib/BlinkenConv.c  888)       if (i + 3 < argCnt) {
BlinkenLib/BlinkenConv.c  889)         const char *str_direction, *str_width_height, *str_duration;
BlinkenLib/BlinkenConv.c  890)         i++;
BlinkenLib/BlinkenConv.c  891)         str_direction = args[i];
BlinkenLib/BlinkenConv.c  892)         i++;
BlinkenLib/BlinkenConv.c  893)         str_width_height = args[i];
BlinkenLib/BlinkenConv.c  894)         i++;
BlinkenLib/BlinkenConv.c  895)         str_duration = args[i];
BlinkenLib/BlinkenConv.c  896)         pMovie = scroll(pMovie, str_direction, str_width_height, str_duration);
BlinkenLib/BlinkenConv.c  897)       } else if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c  898)         printf("missing duration for \"-S\"\n");
BlinkenLib/BlinkenConv.c  899)         i += 2;
BlinkenLib/BlinkenConv.c  900)       } else if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c  901)         printf("missing width/height for \"-S\"\n");
BlinkenLib/BlinkenConv.c  902)         i++;
BlinkenLib/BlinkenConv.c  903)       } else
BlinkenLib/BlinkenConv.c  904)         printf("missing direction (left, right, up, down) for \"-S\"\n");
BlinkenLib/BlinkenConv.c  905)     }

BlinkenLib/BlinkenConv.c  906)     // rotate movie 90 degrees clockwise
BlinkenLib/BlinkenConv.c  907)     else if (strcmp(args[i], "-Rcw") == 0) {
BlinkenLib/BlinkenConv.c  908)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  909)         printf("no movie loaded to rotate\n");
BlinkenLib/BlinkenConv.c  910)       else {
BlinkenLib/BlinkenConv.c  911)         BlinkenMovieRotateCw(pMovie);
BlinkenLib/BlinkenConv.c  912)         printf("movie rotated 90 degrees clockwise\n");
BlinkenLib/BlinkenConv.c  913)       }
BlinkenLib/BlinkenConv.c  914)     }
BlinkenLib/BlinkenConv.c  915)     // rotate movie 90 degrees counter-clockwise
BlinkenLib/BlinkenConv.c  916)     else if (strcmp(args[i], "-Rccw") == 0) {
BlinkenLib/BlinkenConv.c  917)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  918)         printf("no movie loaded to rotate\n");
BlinkenLib/BlinkenConv.c  919)       else {
BlinkenLib/BlinkenConv.c  920)         BlinkenMovieRotateCcw(pMovie);
BlinkenLib/BlinkenConv.c  921)         printf("movie rotated 90 degrees counter-clockwise\n");
BlinkenLib/BlinkenConv.c  922)       }
BlinkenLib/BlinkenConv.c  923)     }
BlinkenLib/BlinkenConv.c  924)     // rotate movie 180 degrees
BlinkenLib/BlinkenConv.c  925)     else if (strcmp(args[i], "-Rh") == 0) {
BlinkenLib/BlinkenConv.c  926)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  927)         printf("no movie loaded to rotate\n");
BlinkenLib/BlinkenConv.c  928)       else {
BlinkenLib/BlinkenConv.c  929)         BlinkenMovieRotateHalf(pMovie);
BlinkenLib/BlinkenConv.c  930)         printf("movie rotated 180 degrees\n");
BlinkenLib/BlinkenConv.c  931)       }
BlinkenLib/BlinkenConv.c  932)     }
BlinkenLib/BlinkenConv.c  933)     // mirror movie horizontally
BlinkenLib/BlinkenConv.c  934)     else if (strcmp(args[i], "-Mh") == 0) {
BlinkenLib/BlinkenConv.c  935)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  936)         printf("no movie loaded to mirror\n");
BlinkenLib/BlinkenConv.c  937)       else {
BlinkenLib/BlinkenConv.c  938)         BlinkenMovieMirrorHor(pMovie);
BlinkenLib/BlinkenConv.c  939)         printf("movie mirrored horizontally\n");
BlinkenLib/BlinkenConv.c  940)       }
BlinkenLib/BlinkenConv.c  941)     }
BlinkenLib/BlinkenConv.c  942)     // mirror movie vertically
BlinkenLib/BlinkenConv.c  943)     else if (strcmp(args[i], "-Mv") == 0) {
BlinkenLib/BlinkenConv.c  944)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  945)         printf("no movie loaded to mirror\n");
BlinkenLib/BlinkenConv.c  946)       else {
BlinkenLib/BlinkenConv.c  947)         BlinkenMovieMirrorVer(pMovie);
BlinkenLib/BlinkenConv.c  948)         printf("movie mirrored vertically\n");
BlinkenLib/BlinkenConv.c  949)       }
BlinkenLib/BlinkenConv.c  950)     }
BlinkenLib/BlinkenConv.c  951)     // mirror movie diagonally
BlinkenLib/BlinkenConv.c  952)     else if (strcmp(args[i], "-Md") == 0) {
BlinkenLib/BlinkenConv.c  953)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  954)         printf("no movie loaded to mirror\n");
BlinkenLib/BlinkenConv.c  955)       else {
BlinkenLib/BlinkenConv.c  956)         BlinkenMovieMirrorDiag(pMovie);
BlinkenLib/BlinkenConv.c  957)         printf("movie mirrored diagonally (\\)\n");
BlinkenLib/BlinkenConv.c  958)       }
BlinkenLib/BlinkenConv.c  959)     }
BlinkenLib/BlinkenConv.c  960)     // mirror movie diagonally
BlinkenLib/BlinkenConv.c  961)     else if (strcmp(args[i], "-Md2") == 0) {
BlinkenLib/BlinkenConv.c  962)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  963)         printf("no movie loaded to mirror\n");
BlinkenLib/BlinkenConv.c  964)       else {
BlinkenLib/BlinkenConv.c  965)         BlinkenMovieMirrorDiag2(pMovie);
BlinkenLib/BlinkenConv.c  966)         printf("movie mirrored diagonally (/)\n");
BlinkenLib/BlinkenConv.c  967)       }
BlinkenLib/BlinkenConv.c  968)     }

BlinkenLib/BlinkenConv.c  969)     // write movie
BlinkenLib/BlinkenConv.c  970)     else if (strcmp(args[i], "-o") == 0) {
BlinkenLib/BlinkenConv.c  971)       if (i + 1 < argCnt) {

BlinkenConv.c             972)         i++;

BlinkenLib/BlinkenConv.c  973)         if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  974)           printf("no movie loaded to write to \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c  975)         else if (BlinkenMovieSave(pMovie, args[i]) < 0)
BlinkenLib/BlinkenConv.c  976)           printf("could not write movie \"%s\"\n", args[i]);

BlinkenConv.c             977)         else

BlinkenLib/BlinkenConv.c  978)           printf("movie \"%s\" written\n", args[i]);
BlinkenLib/BlinkenConv.c  979)       } else
BlinkenLib/BlinkenConv.c  980)         printf("missing output filename for \"-o\"\n");

BlinkenConv.c             981)     }

BlinkenLib/BlinkenConv.c  982)     // old style input filename
BlinkenLib/BlinkenConv.c  983)     else if (i == 1 && args[i][0] != '-') {

tools/BlinkenConv.c       984)       printf("old style input filename \"%s\", better use \"-i %s\"\n", args[i],
tools/BlinkenConv.c       985)              args[i]);

BlinkenLib/BlinkenConv.c  986)       if (pMovie != NULL)
BlinkenLib/BlinkenConv.c  987)         BlinkenMovieFree(pMovie);
BlinkenLib/BlinkenConv.c  988)       pMovie = BlinkenMovieLoad(args[i]);
BlinkenLib/BlinkenConv.c  989)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  990)         printf("could not read movie \"%s\"\n", args[i]);

BlinkenConv.c             991)       else

BlinkenLib/BlinkenConv.c  992)         printf("movie \"%s\" read\n", args[i]);

BlinkenConv.c             993)     }

BlinkenLib/BlinkenConv.c  994)     // old style output filename
BlinkenLib/BlinkenConv.c  995)     else if (i == 2 && args[i][0] != '-') {
BlinkenLib/BlinkenConv.c  996)       printf("old style output filename \"%s\", better use \"-o %s\"\n",
BlinkenLib/BlinkenConv.c  997)              args[i], args[i]);
BlinkenLib/BlinkenConv.c  998)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c  999)         printf("no movie loaded to write to \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c 1000)       else if (BlinkenMovieSave(pMovie, args[i]) < 0)
BlinkenLib/BlinkenConv.c 1001)         printf("could not write movie \"%s\"\n", args[i]);

BlinkenConv.c            1002)       else

BlinkenLib/BlinkenConv.c 1003)         printf("movie \"%s\" written\n", args[i]);

BlinkenConv.c            1004)     }

BlinkenLib/BlinkenConv.c 1005)     // unknown parameter

BlinkenConv.c            1006)     else

tools/BlinkenConv.c      1007)       printf("unknown parameter \"%s\", call without parameters to get help\n",
tools/BlinkenConv.c      1008)              args[i]);

BlinkenLib/BlinkenConv.c 1009) 

tools/BlinkenConv.c      1010)   } // for( i ...

BlinkenLib/BlinkenConv.c 1011) 
BlinkenLib/BlinkenConv.c 1012)   // old style print
BlinkenLib/BlinkenConv.c 1013)   if (argCnt == 2 && pMovie != NULL) {
BlinkenLib/BlinkenConv.c 1014)     str = BlinkenMovieToString(pMovie);
BlinkenLib/BlinkenConv.c 1015)     if (str == NULL)
BlinkenLib/BlinkenConv.c 1016)       printf("could not print movie\n");
BlinkenLib/BlinkenConv.c 1017)     else {
BlinkenLib/BlinkenConv.c 1018)       printf("%s", str);
BlinkenLib/BlinkenConv.c 1019)       free(str);

BlinkenConv.c            1020)     }

BlinkenConv.c            1021)   }

BlinkenLib/BlinkenConv.c 1022)   // free movie
BlinkenLib/BlinkenConv.c 1023)   if (pMovie != NULL)
BlinkenLib/BlinkenConv.c 1024)     BlinkenMovieFree(pMovie);

BlinkenConv.c            1025)