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,

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

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

BlinkenLib/BlinkenConv.c  25)   enum {

BlinkenLib/BlinkenConv.c  26)     ModeNone, ModeBlack, ModeWhite, ModeGradient,

BlinkenLib/BlinkenConv.c  27)     ModeDots, ModeLines, ModeTrans, ModeRainbow,

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

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

BlinkenLib/BlinkenConv.c  30) 

BlinkenLib/BlinkenConv.c  31)   //format
BlinkenLib/BlinkenConv.c  32)   if (str_format == NULL) {
BlinkenLib/BlinkenConv.c  33)     if (*ppMovie == NULL) {
BlinkenLib/BlinkenConv.c  34)       str_format = "<none>";
BlinkenLib/BlinkenConv.c  35)       fmt_ok = 0;
BlinkenLib/BlinkenConv.c  36)       append = 0;
BlinkenLib/BlinkenConv.c  37)     } else {
BlinkenLib/BlinkenConv.c  38)       height = BlinkenMovieGetHeight(*ppMovie);
BlinkenLib/BlinkenConv.c  39)       width = BlinkenMovieGetWidth(*ppMovie);
BlinkenLib/BlinkenConv.c  40)       channels = BlinkenMovieGetChannels(*ppMovie);
BlinkenLib/BlinkenConv.c  41)       colors = BlinkenMovieGetMaxval(*ppMovie) + 1;
BlinkenLib/BlinkenConv.c  42)       fmt_ok = 1;
BlinkenLib/BlinkenConv.c  43)       append = 1;
BlinkenLib/BlinkenConv.c  44)     }
BlinkenLib/BlinkenConv.c  45)   } else {
BlinkenLib/BlinkenConv.c  46)     fmt_ok = sscanf(str_format, "%ux%u-%u/%u",
BlinkenLib/BlinkenConv.c  47)                     &width, &height, &channels, &colors) == 4;
BlinkenLib/BlinkenConv.c  48)     append = 0;
BlinkenLib/BlinkenConv.c  49)   }
BlinkenLib/BlinkenConv.c  50)   //mode

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

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

BlinkenLib/BlinkenConv.c  54)     mode = ModeWhite;

BlinkenLib/BlinkenConv.c  55)   else if (strcmp(str_mode, "gradient") == 0)
BlinkenLib/BlinkenConv.c  56)     mode = ModeGradient;
BlinkenLib/BlinkenConv.c  57)   else if (strcmp(str_mode, "dots") == 0)

BlinkenLib/BlinkenConv.c  58)     mode = ModeDots;

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

BlinkenLib/BlinkenConv.c  60)     mode = ModeLines;

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

BlinkenLib/BlinkenConv.c  62)     mode = ModeTrans;

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

BlinkenLib/BlinkenConv.c  65)   //check
BlinkenLib/BlinkenConv.c  66)   if (! fmt_ok)
BlinkenLib/BlinkenConv.c  67)     printf("invalid movie format \"%s\" for \"-t\" or \"-ta\"\n", str_format);

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

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

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

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

BlinkenLib/BlinkenConv.c  72)   else {
BlinkenLib/BlinkenConv.c  73) 

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

BlinkenLib/BlinkenConv.c  85) 

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

BlinkenLib/BlinkenConv.c  88)       stBlinkenFrame *pFrame;
BlinkenLib/BlinkenConv.c  89)       height = BlinkenMovieGetHeight(*ppMovie);
BlinkenLib/BlinkenConv.c  90)       width = BlinkenMovieGetWidth(*ppMovie);
BlinkenLib/BlinkenConv.c  91)       channels = BlinkenMovieGetChannels(*ppMovie);
BlinkenLib/BlinkenConv.c  92)       colors = BlinkenMovieGetMaxval(*ppMovie) + 1;
BlinkenLib/BlinkenConv.c  93)       switch (mode) {
BlinkenLib/BlinkenConv.c  94) 
BlinkenLib/BlinkenConv.c  95)       case ModeNone:
BlinkenLib/BlinkenConv.c  96)         break;
BlinkenLib/BlinkenConv.c  97) 

BlinkenLib/BlinkenConv.c  98)       case ModeBlack:
BlinkenLib/BlinkenConv.c  99)         pFrame =
BlinkenLib/BlinkenConv.c 100)             BlinkenFrameNew(height, width, channels, colors - 1,
BlinkenLib/BlinkenConv.c 101)                             duration);
BlinkenLib/BlinkenConv.c 102)         for (yy = 0; yy < height; yy++)
BlinkenLib/BlinkenConv.c 103)           for (xx = 0; xx < width; xx++)
BlinkenLib/BlinkenConv.c 104)             for (cc = 0; cc < channels; cc++)
BlinkenLib/BlinkenConv.c 105)               BlinkenFrameSetPixel(pFrame, yy, xx, cc, 0);
BlinkenLib/BlinkenConv.c 106)         BlinkenMovieAppendFrame(*ppMovie, pFrame);
BlinkenLib/BlinkenConv.c 107)         break;
BlinkenLib/BlinkenConv.c 108) 
BlinkenLib/BlinkenConv.c 109)       case ModeWhite:
BlinkenLib/BlinkenConv.c 110)         pFrame =
BlinkenLib/BlinkenConv.c 111)             BlinkenFrameNew(height, width, channels, colors - 1,
BlinkenLib/BlinkenConv.c 112)                             duration);
BlinkenLib/BlinkenConv.c 113)         for (yy = 0; yy < height; yy++)
BlinkenLib/BlinkenConv.c 114)           for (xx = 0; xx < width; xx++)
BlinkenLib/BlinkenConv.c 115)             for (cc = 0; cc < channels; cc++)
BlinkenLib/BlinkenConv.c 116)               BlinkenFrameSetPixel(pFrame, yy, xx, cc, colors - 1);
BlinkenLib/BlinkenConv.c 117)         BlinkenMovieAppendFrame(*ppMovie, pFrame);
BlinkenLib/BlinkenConv.c 118)         break;
BlinkenLib/BlinkenConv.c 119) 

BlinkenLib/BlinkenConv.c 120)       case ModeGradient:
BlinkenLib/BlinkenConv.c 121)         pFrame =
BlinkenLib/BlinkenConv.c 122)             BlinkenFrameNew(height, width, channels, colors - 1,
BlinkenLib/BlinkenConv.c 123)                             duration);
BlinkenLib/BlinkenConv.c 124)         for (yy = 0; yy < height; yy++) {
BlinkenLib/BlinkenConv.c 125)           fy = (float)yy / (float)(height - 1);
BlinkenLib/BlinkenConv.c 126)           for (xx = 0; xx < width; xx++) {
BlinkenLib/BlinkenConv.c 127)             fx = (float)xx / (float)(width - 1);
BlinkenLib/BlinkenConv.c 128)             for (cc = 0, ccc = 0; cc < channels; cc++) {
BlinkenLib/BlinkenConv.c 129)               switch (ccc) {
BlinkenLib/BlinkenConv.c 130)                 case 0:  fc = fx;                      ccc = 1; break;
BlinkenLib/BlinkenConv.c 131)                 case 1:  fc = fy;                      ccc = 2; break;
BlinkenLib/BlinkenConv.c 132)                 case 2:  fc = 1.0f - 0.5f * (fx + fy); ccc = 0; break;
BlinkenLib/BlinkenConv.c 133)                 default: fc = 0.0f;                    ccc = 0; break;
BlinkenLib/BlinkenConv.c 134)               }
BlinkenLib/BlinkenConv.c 135)               BlinkenFrameSetPixel(pFrame, yy, xx, cc,
BlinkenLib/BlinkenConv.c 136)                                    (int)(fc * (float)(colors - 1) + .5f));
BlinkenLib/BlinkenConv.c 137)             }
BlinkenLib/BlinkenConv.c 138)           }
BlinkenLib/BlinkenConv.c 139)         }
BlinkenLib/BlinkenConv.c 140)         BlinkenMovieAppendFrame(*ppMovie, pFrame);
BlinkenLib/BlinkenConv.c 141)         break;
BlinkenLib/BlinkenConv.c 142) 

BlinkenLib/BlinkenConv.c 143)       case ModeDots:
BlinkenLib/BlinkenConv.c 144)         for (c = 0; c < channels; c++)
BlinkenLib/BlinkenConv.c 145)           for (y = 0; y < height; y++)
BlinkenLib/BlinkenConv.c 146)             for (x = 0; x < width; x++) {
BlinkenLib/BlinkenConv.c 147)               pFrame =
BlinkenLib/BlinkenConv.c 148)                   BlinkenFrameNew(height, width, channels, colors - 1,
BlinkenLib/BlinkenConv.c 149)                                   duration);
BlinkenLib/BlinkenConv.c 150)               for (yy = 0; yy < height; yy++)
BlinkenLib/BlinkenConv.c 151)                 for (xx = 0; xx < width; xx++)
BlinkenLib/BlinkenConv.c 152)                   for (cc = 0; cc < channels; cc++)
BlinkenLib/BlinkenConv.c 153)                     BlinkenFrameSetPixel(pFrame, yy, xx, cc,
BlinkenLib/BlinkenConv.c 154)                                          yy == y && xx == x
BlinkenLib/BlinkenConv.c 155)                                          && cc == c ? colors - 1 : 0);
BlinkenLib/BlinkenConv.c 156)               BlinkenMovieAppendFrame(*ppMovie, pFrame);

BlinkenLib/BlinkenConv.c 157)             }

BlinkenLib/BlinkenConv.c 158)         break;
BlinkenLib/BlinkenConv.c 159) 
BlinkenLib/BlinkenConv.c 160)       case ModeLines:
BlinkenLib/BlinkenConv.c 161)         for (c = 0; c < channels; c++) {
BlinkenLib/BlinkenConv.c 162)           for (x = 0; x < width; x++) {
BlinkenLib/BlinkenConv.c 163)             pFrame =
BlinkenLib/BlinkenConv.c 164)                 BlinkenFrameNew(height, width, channels, colors - 1,
BlinkenLib/BlinkenConv.c 165)                                 duration);
BlinkenLib/BlinkenConv.c 166)             for (yy = 0; yy < height; yy++)
BlinkenLib/BlinkenConv.c 167)               for (xx = 0; xx < width; xx++)
BlinkenLib/BlinkenConv.c 168)                 for (cc = 0; cc < channels; cc++)
BlinkenLib/BlinkenConv.c 169)                   BlinkenFrameSetPixel(pFrame, yy, xx, cc,
BlinkenLib/BlinkenConv.c 170)                                        xx == x && cc == c ? colors - 1 : 0);
BlinkenLib/BlinkenConv.c 171)             BlinkenMovieAppendFrame(*ppMovie, pFrame);

BlinkenLib/BlinkenConv.c 172)           }

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

BlinkenLib/BlinkenConv.c 183)           }

BlinkenLib/BlinkenConv.c 184)         }
BlinkenLib/BlinkenConv.c 185)         break;
BlinkenLib/BlinkenConv.c 186) 
BlinkenLib/BlinkenConv.c 187)       case ModeTrans:
BlinkenLib/BlinkenConv.c 188)         for (c = 0; c < channels; c++)
BlinkenLib/BlinkenConv.c 189)           for (b = 0; b < 2; b++)
BlinkenLib/BlinkenConv.c 190)             for (c2 = 0; c2 < channels; c2++)
BlinkenLib/BlinkenConv.c 191)               for (o = 0; o < colors - 1; o++) {
BlinkenLib/BlinkenConv.c 192)                 pFrame =
BlinkenLib/BlinkenConv.c 193)                     BlinkenFrameNew(height, width, channels, colors - 1,
BlinkenLib/BlinkenConv.c 194)                                     duration);
BlinkenLib/BlinkenConv.c 195)                 for (cc = 0; cc < channels; cc++) {
BlinkenLib/BlinkenConv.c 196)                   c3 = (cc + channels - c) % channels;
BlinkenLib/BlinkenConv.c 197)                   oo = b ? (c3 < c2 ? 0 : c3 >
BlinkenLib/BlinkenConv.c 198)                             c2 ? colors - 1 : colors - 1 - o)
BlinkenLib/BlinkenConv.c 199)                       : (c3 < c2 ? colors - 1 : c3 > c2 ? 0 : o);
BlinkenLib/BlinkenConv.c 200)                   for (yy = 0; yy < height; yy++)
BlinkenLib/BlinkenConv.c 201)                     for (xx = 0; xx < width; xx++)
BlinkenLib/BlinkenConv.c 202)                       BlinkenFrameSetPixel(pFrame, yy, xx, cc, oo);
BlinkenLib/BlinkenConv.c 203)                 }
BlinkenLib/BlinkenConv.c 204)                 BlinkenMovieAppendFrame(*ppMovie, pFrame);
BlinkenLib/BlinkenConv.c 205)               }
BlinkenLib/BlinkenConv.c 206)         break;

BlinkenLib/BlinkenConv.c 207) 

BlinkenLib/BlinkenConv.c 208)       case ModeRainbow:
BlinkenLib/BlinkenConv.c 209)         for (b = 0; b < width * height; b++) {
BlinkenLib/BlinkenConv.c 210)           pFrame = BlinkenFrameNew(height, width, channels,
BlinkenLib/BlinkenConv.c 211)                                    colors - 1, duration);
BlinkenLib/BlinkenConv.c 212)           for (yy = 0; yy < height; yy++) {
BlinkenLib/BlinkenConv.c 213)             for (xx = 0; xx < width; xx++) {
BlinkenLib/BlinkenConv.c 214)               for (cc = 0; cc < channels; cc++) {
BlinkenLib/BlinkenConv.c 215)                 y = b + yy + xx + cc * 8;
BlinkenLib/BlinkenConv.c 216)                 switch (y % 24) {
BlinkenLib/BlinkenConv.c 217)                   case  0: oo = 0; break;
BlinkenLib/BlinkenConv.c 218)                   case  1: oo = 1; break;
BlinkenLib/BlinkenConv.c 219)                   case  2: oo = 2; break;
BlinkenLib/BlinkenConv.c 220)                   case  3: oo = 3; break;
BlinkenLib/BlinkenConv.c 221)                   case  4: oo = 4; break;
BlinkenLib/BlinkenConv.c 222)                   case  5: oo = 4; break;
BlinkenLib/BlinkenConv.c 223)                   case  6: oo = 4; break;
BlinkenLib/BlinkenConv.c 224)                   case  7: oo = 4; break;
BlinkenLib/BlinkenConv.c 225)                   case  8: oo = 4; break;
BlinkenLib/BlinkenConv.c 226)                   case  9: oo = 4; break;
BlinkenLib/BlinkenConv.c 227)                   case 10: oo = 4; break;
BlinkenLib/BlinkenConv.c 228)                   case 11: oo = 4; break;
BlinkenLib/BlinkenConv.c 229)                   case 12: oo = 4; break;
BlinkenLib/BlinkenConv.c 230)                   case 13: oo = 3; break;
BlinkenLib/BlinkenConv.c 231)                   case 14: oo = 2; break;
BlinkenLib/BlinkenConv.c 232)                   case 15: oo = 1; break;
BlinkenLib/BlinkenConv.c 233)                   default: oo = 0; break;
BlinkenLib/BlinkenConv.c 234)                 }
BlinkenLib/BlinkenConv.c 235)                 oo = oo * colors / 4;
BlinkenLib/BlinkenConv.c 236)                 if (oo > colors - 1)
BlinkenLib/BlinkenConv.c 237)                   oo = colors - 1;
BlinkenLib/BlinkenConv.c 238)                 BlinkenFrameSetPixel(pFrame, yy, xx, cc, oo);
BlinkenLib/BlinkenConv.c 239)               }
BlinkenLib/BlinkenConv.c 240)             }
BlinkenLib/BlinkenConv.c 241)           }
BlinkenLib/BlinkenConv.c 242)           BlinkenMovieAppendFrame(*ppMovie, pFrame);
BlinkenLib/BlinkenConv.c 243)         }
BlinkenLib/BlinkenConv.c 244)         break;
BlinkenLib/BlinkenConv.c 245) 

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

BlinkenLib/BlinkenConv.c 247) 

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

BlinkenLib/BlinkenConv.c 250) 

BlinkenLib/BlinkenConv.c 251)     }   // if( *ppMovie == NULL ) ... else

BlinkenLib/BlinkenConv.c 252) 

BlinkenLib/BlinkenConv.c 253)   }     // else

BlinkenLib/BlinkenConv.c 254) }
BlinkenLib/BlinkenConv.c 255) 

BlinkenLib/BlinkenConv.c 256) static void copy_rect(stBlinkenMovie *pMovie, char *str_file,
BlinkenLib/BlinkenConv.c 257)                       const char *str_src_pos, const char *str_dim,
BlinkenLib/BlinkenConv.c 258)                       const char *str_dest_pos)
BlinkenLib/BlinkenConv.c 259) {
BlinkenLib/BlinkenConv.c 260)   unsigned int sy, sx, h, w, dy, dx;
BlinkenLib/BlinkenConv.c 261)   stBlinkenMovie *pSrcMovie;
BlinkenLib/BlinkenConv.c 262) 
BlinkenLib/BlinkenConv.c 263)   if (sscanf(str_src_pos, "%u,%u", &sx, &sy) != 2)
BlinkenLib/BlinkenConv.c 264)     printf("invalid source position \"%s\" for \"-C\"\n", str_src_pos);
BlinkenLib/BlinkenConv.c 265)   else if (sscanf(str_dim, "%ux%u", &w, &h) != 2)
BlinkenLib/BlinkenConv.c 266)     printf("invalid dimensions \"%s\" for \"-C\"\n", str_dim);
BlinkenLib/BlinkenConv.c 267)   else if (sscanf(str_dest_pos, "%u,%u", &dx, &dy) != 2)
BlinkenLib/BlinkenConv.c 268)     printf("invalid destination position \"%s\" for \"-C\"\n", str_dest_pos);
BlinkenLib/BlinkenConv.c 269)   else {
BlinkenLib/BlinkenConv.c 270) 
BlinkenLib/BlinkenConv.c 271)     pSrcMovie = BlinkenMovieLoad(str_file);
BlinkenLib/BlinkenConv.c 272)     if (pSrcMovie == NULL)
BlinkenLib/BlinkenConv.c 273)       printf("could not read movie \"%s\"\n", str_file);
BlinkenLib/BlinkenConv.c 274)     else {
BlinkenLib/BlinkenConv.c 275) 
BlinkenLib/BlinkenConv.c 276)       BlinkenMovieCopyRect(pMovie, dy, dx, pSrcMovie, sy, sx, h, w);
BlinkenLib/BlinkenConv.c 277)       BlinkenMovieFree(pSrcMovie);

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

BlinkenLib/BlinkenConv.c 280) 
BlinkenLib/BlinkenConv.c 281)     }
BlinkenLib/BlinkenConv.c 282)   }
BlinkenLib/BlinkenConv.c 283) }
BlinkenLib/BlinkenConv.c 284) 

BlinkenLib/BlinkenConv.c 285) static stBlinkenMovie * scroll(stBlinkenMovie *pMovie,
BlinkenLib/BlinkenConv.c 286)                                const char * str_direction,
BlinkenLib/BlinkenConv.c 287)                                const char * str_width_height,
BlinkenLib/BlinkenConv.c 288)                                const char * str_duration)
BlinkenLib/BlinkenConv.c 289) {
BlinkenLib/BlinkenConv.c 290)   enum {
BlinkenLib/BlinkenConv.c 291)     DirNone, DirLeft, DirRight, DirUp, DirDown,
BlinkenLib/BlinkenConv.c 292)   } dir = DirNone;
BlinkenLib/BlinkenConv.c 293)   int width_height, duration, height, width, channels, maxval,
BlinkenLib/BlinkenConv.c 294)       new_height, new_width, sy, sx, dy, dx, steps, step;
BlinkenLib/BlinkenConv.c 295)   stBlinkenFrame *pScroll, *pFrame;
BlinkenLib/BlinkenConv.c 296) 
BlinkenLib/BlinkenConv.c 297)   // direction
BlinkenLib/BlinkenConv.c 298)   if (strcmp(str_direction, "left") == 0)
BlinkenLib/BlinkenConv.c 299)     dir = DirLeft;
BlinkenLib/BlinkenConv.c 300)   else if (strcmp(str_direction, "right") == 0)
BlinkenLib/BlinkenConv.c 301)     dir = DirRight;
BlinkenLib/BlinkenConv.c 302)   else if (strcmp(str_direction, "up") == 0)
BlinkenLib/BlinkenConv.c 303)     dir = DirUp;
BlinkenLib/BlinkenConv.c 304)   else if (strcmp(str_direction, "down") == 0)
BlinkenLib/BlinkenConv.c 305)     dir = DirDown;
BlinkenLib/BlinkenConv.c 306) 
BlinkenLib/BlinkenConv.c 307)   // check
BlinkenLib/BlinkenConv.c 308)   if (dir == DirNone) {
BlinkenLib/BlinkenConv.c 309)     printf("invalid direction \"%s\" for \"-S\" (left, right, up, down)\n",
BlinkenLib/BlinkenConv.c 310)            str_direction);
BlinkenLib/BlinkenConv.c 311)     return pMovie;
BlinkenLib/BlinkenConv.c 312)   }
BlinkenLib/BlinkenConv.c 313)   if (sscanf(str_width_height, "%u", &width_height) != 1 || width_height < 1) {
BlinkenLib/BlinkenConv.c 314)     printf("invalid width/height \"%s\" for \"-S\"\n", str_width_height);
BlinkenLib/BlinkenConv.c 315)     return pMovie;
BlinkenLib/BlinkenConv.c 316)   }
BlinkenLib/BlinkenConv.c 317)   if (sscanf(str_duration, "%u", &duration) != 1 || duration < 1) {
BlinkenLib/BlinkenConv.c 318)     printf("invalid duration \"%s\" for \"-S\"\n", str_duration);
BlinkenLib/BlinkenConv.c 319)     return pMovie;
BlinkenLib/BlinkenConv.c 320)   }
BlinkenLib/BlinkenConv.c 321)   if (BlinkenMovieGetFrameCnt(pMovie) < 1) {
BlinkenLib/BlinkenConv.c 322)     printf("empty movie not allowed for \"-S\"\n");
BlinkenLib/BlinkenConv.c 323)     return pMovie;
BlinkenLib/BlinkenConv.c 324)   }
BlinkenLib/BlinkenConv.c 325) 
BlinkenLib/BlinkenConv.c 326)   // get number of steps
BlinkenLib/BlinkenConv.c 327)   height = BlinkenMovieGetHeight(pMovie);
BlinkenLib/BlinkenConv.c 328)   width = BlinkenMovieGetWidth(pMovie);
BlinkenLib/BlinkenConv.c 329)   channels = BlinkenMovieGetChannels(pMovie);
BlinkenLib/BlinkenConv.c 330)   maxval = BlinkenMovieGetMaxval(pMovie);
BlinkenLib/BlinkenConv.c 331)   new_height = height;
BlinkenLib/BlinkenConv.c 332)   new_width = width;
BlinkenLib/BlinkenConv.c 333)   sy = 0;
BlinkenLib/BlinkenConv.c 334)   sx = 0;
BlinkenLib/BlinkenConv.c 335)   dy = 1;
BlinkenLib/BlinkenConv.c 336)   dx = 1;
BlinkenLib/BlinkenConv.c 337)   switch (dir) {
BlinkenLib/BlinkenConv.c 338)     case DirNone:
BlinkenLib/BlinkenConv.c 339)       return pMovie;
BlinkenLib/BlinkenConv.c 340)     case DirRight:
BlinkenLib/BlinkenConv.c 341)       sx = 1; // prepare for sx *= steps
BlinkenLib/BlinkenConv.c 342)       dx = -1;
BlinkenLib/BlinkenConv.c 343)       // fall through
BlinkenLib/BlinkenConv.c 344)     case DirLeft:
BlinkenLib/BlinkenConv.c 345)       dy = 0;
BlinkenLib/BlinkenConv.c 346)       steps = width - width_height + 1;
BlinkenLib/BlinkenConv.c 347)       sx *= (steps - 1); // before this line, sx was 0 or 1
BlinkenLib/BlinkenConv.c 348)       if (steps < 1) {
BlinkenLib/BlinkenConv.c 349)         printf("invalid width %u for \"-S left/right\" on movie of width %u\n",
BlinkenLib/BlinkenConv.c 350)                width_height, width);
BlinkenLib/BlinkenConv.c 351)         return pMovie;
BlinkenLib/BlinkenConv.c 352)       }
BlinkenLib/BlinkenConv.c 353)       new_width = width_height;
BlinkenLib/BlinkenConv.c 354)       break;
BlinkenLib/BlinkenConv.c 355)     case DirDown:
BlinkenLib/BlinkenConv.c 356)       sy = 1; // prepare for sy *= steps
BlinkenLib/BlinkenConv.c 357)       dy = -1;
BlinkenLib/BlinkenConv.c 358)       // fall through
BlinkenLib/BlinkenConv.c 359)     case DirUp:
BlinkenLib/BlinkenConv.c 360)       dx = 0;
BlinkenLib/BlinkenConv.c 361)       steps = height - width_height + 1;
BlinkenLib/BlinkenConv.c 362)       sy *= (steps - 1); // before this line, sy was 0 or 1
BlinkenLib/BlinkenConv.c 363)       if (steps < 1) {
BlinkenLib/BlinkenConv.c 364)         printf("invalid height %u for \"-S up/down\" on movie of height %u\n",
BlinkenLib/BlinkenConv.c 365)                width_height, width);
BlinkenLib/BlinkenConv.c 366)         return pMovie;
BlinkenLib/BlinkenConv.c 367)       }
BlinkenLib/BlinkenConv.c 368)       new_height = width_height;
BlinkenLib/BlinkenConv.c 369)       break;
BlinkenLib/BlinkenConv.c 370)   }
BlinkenLib/BlinkenConv.c 371) 
BlinkenLib/BlinkenConv.c 372)   // get copy of first frame
BlinkenLib/BlinkenConv.c 373)   pScroll = BlinkenFrameClone(BlinkenMovieGetFrame(pMovie, 1));
BlinkenLib/BlinkenConv.c 374)   BlinkenFrameSetDuration(pScroll, duration);
BlinkenLib/BlinkenConv.c 375) 
BlinkenLib/BlinkenConv.c 376)   // free old movie
BlinkenLib/BlinkenConv.c 377)   BlinkenMovieFree(pMovie);
BlinkenLib/BlinkenConv.c 378) 
BlinkenLib/BlinkenConv.c 379)   // create new movie scrolling the frame
BlinkenLib/BlinkenConv.c 380)   pMovie = BlinkenMovieNew(new_height, new_width, channels, maxval);
BlinkenLib/BlinkenConv.c 381)   for (step = 0; step < steps; ++step, sy += dy, sx += dx) {
BlinkenLib/BlinkenConv.c 382)     pFrame = BlinkenFrameClone(pScroll);
BlinkenLib/BlinkenConv.c 383)     BlinkenFrameCrop(pFrame, sy, sx, new_height, new_width);
BlinkenLib/BlinkenConv.c 384)     BlinkenMovieAppendFrame(pMovie, pFrame);
BlinkenLib/BlinkenConv.c 385)   }
BlinkenLib/BlinkenConv.c 386) 
BlinkenLib/BlinkenConv.c 387)   // free scrolled frame
BlinkenLib/BlinkenConv.c 388)   BlinkenFrameFree(pScroll);
BlinkenLib/BlinkenConv.c 389) 

BlinkenLib/BlinkenConv.c 390)   printf("scrolled %ux%u-%u/%u frame to %ux%u-%u/%u movie (direction %s)\n",
BlinkenLib/BlinkenConv.c 391)          width, height, channels, maxval + 1,
BlinkenLib/BlinkenConv.c 392)          new_width, new_height, channels, maxval + 1, str_direction);
BlinkenLib/BlinkenConv.c 393) 

BlinkenLib/BlinkenConv.c 394)   return pMovie;
BlinkenLib/BlinkenConv.c 395) }
BlinkenLib/BlinkenConv.c 396) 

BlinkenLib/BlinkenConv.c 397) int main(int argCnt, char **args)

BlinkenConv.c            398) {

BlinkenLib/BlinkenConv.c 399)   stBlinkenMovie *pMovie;

BlinkenConv.c            400)   int i;

BlinkenLib/BlinkenConv.c 401)   char *str;

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

BlinkenLib/BlinkenConv.c 403)   int mode;
BlinkenLib/BlinkenConv.c 404) 
BlinkenLib/BlinkenConv.c 405)   // print info
BlinkenLib/BlinkenConv.c 406)   printf("BlinkenLib - BlinkenConv\n"
BlinkenLib/BlinkenConv.c 407)          "version %d.%d.%d\n"
BlinkenLib/BlinkenConv.c 408)          "config " BLINKENLIB_CONFIG "\n"

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

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

BlinkenLib/BlinkenConv.c 411)          "a blinkenarea.org project\n\n",
BlinkenLib/BlinkenConv.c 412)          BLINKENLIB_VERSION_MAJOR, BLINKENLIB_VERSION_MINOR,
BlinkenLib/BlinkenConv.c 413)          BLINKENLIB_VERSION_REVISION);
BlinkenLib/BlinkenConv.c 414) 
BlinkenLib/BlinkenConv.c 415)   // print syntax
BlinkenLib/BlinkenConv.c 416)   if (argCnt <= 1) {

BlinkenLib/BlinkenConv.c 417) #ifdef BLINKENLIB_CFG_MNG
BlinkenLib/BlinkenConv.c 418) # define MNGEXT ", *.mng"
BlinkenLib/BlinkenConv.c 419) #else
BlinkenLib/BlinkenConv.c 420) # define MNGEXT

BlinkenLib/BlinkenConv.c 421) #endif
BlinkenLib/BlinkenConv.c 422) #ifdef BLINKENLIB_CFG_GIF
BlinkenLib/BlinkenConv.c 423) # define GIFEXT ", *.gif"
BlinkenLib/BlinkenConv.c 424) #else
BlinkenLib/BlinkenConv.c 425) # define GIFEXT

BlinkenLib/BlinkenConv.c 426) #endif

BlinkenLib/BlinkenConv.c 427)     printf("syntax: %s <parameter> [...]\n\n"
BlinkenLib/BlinkenConv.c 428)            "parameters:\n"
BlinkenLib/BlinkenConv.c 429)            "  -i <file>\n"

BlinkenLib/BlinkenConv.c 430)            "     read movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT ")\n"

BlinkenLib/BlinkenConv.c 431)            "  -a <file>\n"

BlinkenLib/BlinkenConv.c 432)            "     append movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT ")\n"

BlinkenLib/BlinkenConv.c 433)            "  -l <number>\n"
BlinkenLib/BlinkenConv.c 434)            "     loop video a number of times\n"
BlinkenLib/BlinkenConv.c 435)            "  -f\n"
BlinkenLib/BlinkenConv.c 436)            "     output format, frame count and duration of movie\n"
BlinkenLib/BlinkenConv.c 437)            "  -p\n"
BlinkenLib/BlinkenConv.c 438)            "     print movie\n"
BlinkenLib/BlinkenConv.c 439)            "  -r <width>x<height>-<channels>/<colors>\n"
BlinkenLib/BlinkenConv.c 440)            "     resize movie\n"

BlinkenLib/BlinkenConv.c 441)            "  -cr <src-x>,<src-y> <width>x<height>\n"
BlinkenLib/BlinkenConv.c 442)            "     crop movie\n"

BlinkenLib/BlinkenConv.c 443)            "  -s <width>x<height>\n"
BlinkenLib/BlinkenConv.c 444)            "     scale movie\n"
BlinkenLib/BlinkenConv.c 445)            "  -c <channels> [solid|rainbow]\n"
BlinkenLib/BlinkenConv.c 446)            "     colorize movie\n"
BlinkenLib/BlinkenConv.c 447)            "  -R\n"
BlinkenLib/BlinkenConv.c 448)            "     reverse movie\n"

BlinkenLib/BlinkenConv.c 449)            "  -ct <begin> <end>\n"
BlinkenLib/BlinkenConv.c 450)            "     cut movie to time span from begin (in ms) till end (in ms)\n"

BlinkenLib/BlinkenConv.c 451)            "  -dur <duration>\n"
BlinkenLib/BlinkenConv.c 452)            "     adapt duration (in ms) of movie\n"

BlinkenLib/BlinkenConv.c 453)            "  -maxframedur <duration>\n"
BlinkenLib/BlinkenConv.c 454)            "     adapt maximum duration (in ms) per frame\n"

BlinkenLib/BlinkenConv.c 455)            "  -d <first> <count>\n"
BlinkenLib/BlinkenConv.c 456)            "     delete frames\n"

BlinkenLib/BlinkenConv.c 457)            "  -t <width>x<height>-<channels>/<colors> <test_mode> <duration>\n"

BlinkenLib/BlinkenConv.c 458)            "     generate a test movie (duration in ms)\n"

BlinkenLib/BlinkenConv.c 459)            "  -ta <test_mode> <duration>\n"
BlinkenLib/BlinkenConv.c 460)            "     generate a test movie and append it to current video\n"

BlinkenLib/BlinkenConv.c 461)            "  -C <file> <src-x>,<src-y> <width>x<height> <dest-x>,<dest-y>\n"
BlinkenLib/BlinkenConv.c 462)            "     copy rectangular section of other movie\n"

BlinkenLib/BlinkenConv.c 463)            "  -S {left|right|up|down} <width/height> <duration>\n"
BlinkenLib/BlinkenConv.c 464)            "     scroll first frame of current movie (duration in ms)\n"

BlinkenLib/BlinkenConv.c 465)            "  -Rcw\n"
BlinkenLib/BlinkenConv.c 466)            "     rotate movie 90 degrees clockwise\n"
BlinkenLib/BlinkenConv.c 467)            "  -Rccw\n"
BlinkenLib/BlinkenConv.c 468)            "     rotate movie 90 degrees counter-clockwise\n"
BlinkenLib/BlinkenConv.c 469)            "  -Rh\n"
BlinkenLib/BlinkenConv.c 470)            "     rotate movie 180 degrees\n"
BlinkenLib/BlinkenConv.c 471)            "  -Mh\n"
BlinkenLib/BlinkenConv.c 472)            "     mirror movie horizontally\n"
BlinkenLib/BlinkenConv.c 473)            "  -Mv\n"
BlinkenLib/BlinkenConv.c 474)            "     mirror movie vertically\n"
BlinkenLib/BlinkenConv.c 475)            "  -Md\n"
BlinkenLib/BlinkenConv.c 476)            "     mirror movie diagonally (\\)\n"
BlinkenLib/BlinkenConv.c 477)            "  -Md2\n"
BlinkenLib/BlinkenConv.c 478)            "     mirror movie diagonally (/)\n"

BlinkenLib/BlinkenConv.c 479)            "  -o <file>\n"

BlinkenLib/BlinkenConv.c 480)            "     write movie to file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT ")\n\n"

BlinkenLib/BlinkenConv.c 481)            "test_modes: black, white, gradient, dots, lines, trans, rainbow\n\n"

BlinkenLib/BlinkenConv.c 482)            "old syntax: %s <input-file> [<output-file>]\n\n",
BlinkenLib/BlinkenConv.c 483)            args[0], args[0]);

BlinkenConv.c            484)     return 0;

BlinkenConv.c            485)   }

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

BlinkenConv.c            487)   pMovie = NULL;
BlinkenConv.c            488) 

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

BlinkenConv.c            491) 

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

BlinkenConv.c            495)         i++;

BlinkenLib/BlinkenConv.c 496)         if (pMovie != NULL)
BlinkenLib/BlinkenConv.c 497)           BlinkenMovieFree(pMovie);
BlinkenLib/BlinkenConv.c 498)         pMovie = BlinkenMovieLoad(args[i]);
BlinkenLib/BlinkenConv.c 499)         if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 500)           printf("could not read movie \"%s\"\n", args[i]);

BlinkenConv.c            501)         else

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

BlinkenConv.c            505)     }

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

BlinkenLib/BlinkenConv.c 509)         i++;

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

BlinkenLib/BlinkenConv.c 512)         else {

BlinkenLib/BlinkenConv.c 513)           stBlinkenMovie *pMovie2;
BlinkenLib/BlinkenConv.c 514)           pMovie2 = BlinkenMovieLoad(args[i]);
BlinkenLib/BlinkenConv.c 515)           if (pMovie2 == NULL)
BlinkenLib/BlinkenConv.c 516)             printf("could not read movie \"%s\"\n", args[i]);

BlinkenLib/BlinkenConv.c 517)           else {

BlinkenLib/BlinkenConv.c 518)             if (BlinkenMovieConcat(pMovie, pMovie2) < 0) {
BlinkenLib/BlinkenConv.c 519)               BlinkenMovieFree(pMovie2);
BlinkenLib/BlinkenConv.c 520)               printf("movie read from \"%s\" could not be appended\n",
BlinkenLib/BlinkenConv.c 521)                      args[i]);

BlinkenLib/BlinkenConv.c 522)             } else

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

BlinkenLib/BlinkenConv.c 524)           }
BlinkenLib/BlinkenConv.c 525)         }

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

BlinkenLib/BlinkenConv.c 528)     }

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

BlinkenLib/BlinkenConv.c 532)         i++;

BlinkenLib/BlinkenConv.c 533)         if (sscanf(args[i], "%u", &times) != 1 || times < 1)
BlinkenLib/BlinkenConv.c 534)           printf("invalid number of times \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c 535)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 536)           printf("no movie loaded to loop\n");
BlinkenLib/BlinkenConv.c 537)         else {
BlinkenLib/BlinkenConv.c 538)           stBlinkenMovie *pMovie2, *pMovie3;

BlinkenLib/BlinkenConv.c 539)           int err = 0;
BlinkenLib/BlinkenConv.c 540)           unsigned int t;

BlinkenLib/BlinkenConv.c 541)           pMovie2 = BlinkenMovieClone(pMovie);
BlinkenLib/BlinkenConv.c 542)           if (pMovie2 == NULL)

BlinkenLib/BlinkenConv.c 543)             err = 1;
BlinkenLib/BlinkenConv.c 544)           else {

BlinkenLib/BlinkenConv.c 545)             for (t = 1 /* loop one time means nothing to do */ ; t < times;
BlinkenLib/BlinkenConv.c 546)                  t++) {
BlinkenLib/BlinkenConv.c 547)               pMovie3 = BlinkenMovieClone(pMovie2);
BlinkenLib/BlinkenConv.c 548)               if (pMovie3 == NULL)

BlinkenLib/BlinkenConv.c 549)                 err = 1;
BlinkenLib/BlinkenConv.c 550)               else {

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

BlinkenLib/BlinkenConv.c 553)                   err = 1;
BlinkenLib/BlinkenConv.c 554)                 }
BlinkenLib/BlinkenConv.c 555)               }
BlinkenLib/BlinkenConv.c 556)             }

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

BlinkenLib/BlinkenConv.c 558)           }

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

BlinkenLib/BlinkenConv.c 561)           else

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

BlinkenLib/BlinkenConv.c 563)         }

BlinkenLib/BlinkenConv.c 564)       } else

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

BlinkenLib/BlinkenConv.c 566)     }

BlinkenLib/BlinkenConv.c 567)     // output format, frame count and duration of movie
BlinkenLib/BlinkenConv.c 568)     else if (strcmp(args[i], "-f") == 0) {
BlinkenLib/BlinkenConv.c 569)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 570)         printf
BlinkenLib/BlinkenConv.c 571)             ("no movie loaded to output format, frame count and duration of\n");

BlinkenLib/BlinkenConv.c 572)       else

BlinkenLib/BlinkenConv.c 573)         printf
BlinkenLib/BlinkenConv.c 574)             ("format:      %ux%u-%u/%u\nframe count: %u\nduration:    %u ms\n",
BlinkenLib/BlinkenConv.c 575)              BlinkenMovieGetWidth(pMovie), BlinkenMovieGetHeight(pMovie),
BlinkenLib/BlinkenConv.c 576)              BlinkenMovieGetChannels(pMovie),
BlinkenLib/BlinkenConv.c 577)              BlinkenMovieGetMaxval(pMovie) + 1,
BlinkenLib/BlinkenConv.c 578)              BlinkenMovieGetFrameCnt(pMovie),
BlinkenLib/BlinkenConv.c 579)              BlinkenMovieGetDuration(pMovie));

BlinkenLib/BlinkenConv.c 580)     }

BlinkenLib/BlinkenConv.c 581)     // print movie
BlinkenLib/BlinkenConv.c 582)     else if (strcmp(args[i], "-p") == 0) {
BlinkenLib/BlinkenConv.c 583)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 584)         printf("no movie loaded to print\n");
BlinkenLib/BlinkenConv.c 585)       else {
BlinkenLib/BlinkenConv.c 586)         str = BlinkenMovieToString(pMovie);
BlinkenLib/BlinkenConv.c 587)         if (str == NULL)
BlinkenLib/BlinkenConv.c 588)           printf("could not print movie\n");
BlinkenLib/BlinkenConv.c 589)         else {
BlinkenLib/BlinkenConv.c 590)           printf("%s", str);
BlinkenLib/BlinkenConv.c 591)           free(str);

BlinkenConv.c            592)         }

BlinkenConv.c            593)       }
BlinkenConv.c            594)     }

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

BlinkenConv.c            598)         i++;

BlinkenLib/BlinkenConv.c 599)         if (sscanf
BlinkenLib/BlinkenConv.c 600)             (args[i], "%ux%u-%u/%u", &width, &height, &channels,
BlinkenLib/BlinkenConv.c 601)              &colors) != 4)
BlinkenLib/BlinkenConv.c 602)           printf("invalid movie format \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c 603)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 604)           printf("no movie loaded to resize\n");
BlinkenLib/BlinkenConv.c 605)         else {
BlinkenLib/BlinkenConv.c 606)           BlinkenMovieResize(pMovie, height, width, channels, colors - 1);
BlinkenLib/BlinkenConv.c 607)           printf("movie resized to %ux%u-%u/%u\n", width, height, channels,
BlinkenLib/BlinkenConv.c 608)                  colors);

BlinkenConv.c            609)         }

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

BlinkenConv.c            612)     }

BlinkenLib/BlinkenConv.c 613)     // crop movie
BlinkenLib/BlinkenConv.c 614)     else if (strcmp(args[i], "-cr") == 0) {
BlinkenLib/BlinkenConv.c 615)       if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c 616)         const char *topleft, *dimensions;
BlinkenLib/BlinkenConv.c 617)         i++;
BlinkenLib/BlinkenConv.c 618)         topleft = args[i];
BlinkenLib/BlinkenConv.c 619)         i++;
BlinkenLib/BlinkenConv.c 620)         dimensions = args[i];
BlinkenLib/BlinkenConv.c 621)         if (sscanf
BlinkenLib/BlinkenConv.c 622)             (topleft, "%u,%u", &left, &top) != 2)
BlinkenLib/BlinkenConv.c 623)           printf("invalid top-left position \"%s\"\n", topleft);
BlinkenLib/BlinkenConv.c 624)         else if (sscanf
BlinkenLib/BlinkenConv.c 625)             (dimensions, "%ux%u", &width, &height) != 2)
BlinkenLib/BlinkenConv.c 626)           printf("invalid movie dimensions \"%s\"\n", dimensions);
BlinkenLib/BlinkenConv.c 627)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 628)           printf("no movie loaded to crop\n");
BlinkenLib/BlinkenConv.c 629)         else {
BlinkenLib/BlinkenConv.c 630)           BlinkenMovieCrop(pMovie, top, left, height, width);
BlinkenLib/BlinkenConv.c 631)           printf("movie cropped to %u,%u %ux%u\n", left, top, width, height);
BlinkenLib/BlinkenConv.c 632)         }
BlinkenLib/BlinkenConv.c 633)       } else if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c 634)         printf("missing dimensions for \"-cr\"\n");
BlinkenLib/BlinkenConv.c 635)         i++;
BlinkenLib/BlinkenConv.c 636)       } else
BlinkenLib/BlinkenConv.c 637)         printf("missing top-left position for \"-cr\"\n");
BlinkenLib/BlinkenConv.c 638)     }

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

BlinkenConv.c            642)         i++;

BlinkenLib/BlinkenConv.c 643)         if (sscanf(args[i], "%ux%u", &width, &height) != 2)
BlinkenLib/BlinkenConv.c 644)           printf("invalid movie dimensions \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c 645)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 646)           printf("no movie loaded to scale\n");
BlinkenLib/BlinkenConv.c 647)         else {
BlinkenLib/BlinkenConv.c 648)           BlinkenMovieScale(pMovie, height, width);
BlinkenLib/BlinkenConv.c 649)           printf("movie scaled to %ux%u\n", width, height);

BlinkenConv.c            650)         }

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

BlinkenConv.c            653)     }

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

BlinkenConv.c            658)         i++;

BlinkenLib/BlinkenConv.c 659)         str_channels = args[i];
BlinkenLib/BlinkenConv.c 660)         i++;
BlinkenLib/BlinkenConv.c 661)         str_mode = args[i];

BlinkenLib/BlinkenConv.c 662)         if (sscanf(str_channels, "%u", &channels) != 1)
BlinkenLib/BlinkenConv.c 663)           printf("invalid number of channels \"%s\"\n", str_channels);
BlinkenLib/BlinkenConv.c 664)         else {
BlinkenLib/BlinkenConv.c 665)           mode = BlinkenColorizerStr2Mode(str_mode);
BlinkenLib/BlinkenConv.c 666)           if (mode < 0)
BlinkenLib/BlinkenConv.c 667)             printf("invalid colorizing mode \"%s\"\n", str_mode);
BlinkenLib/BlinkenConv.c 668)           else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 669)             printf("no movie loaded to colorize\n");
BlinkenLib/BlinkenConv.c 670)           else {
BlinkenLib/BlinkenConv.c 671)             BlinkenMovieColorize(pMovie, channels, mode);
BlinkenLib/BlinkenConv.c 672)             printf("movie colorized to %u channels using mode %s\n", channels,
BlinkenLib/BlinkenConv.c 673)                    BlinkenColorizerMode2Str(mode));

BlinkenConv.c            674)           }
BlinkenConv.c            675)         }

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

BlinkenLib/BlinkenConv.c 678)         i++;

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

BlinkenConv.c            681)     }

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

BlinkenLib/BlinkenConv.c 686)       else {

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

BlinkenLib/BlinkenConv.c 689)       }
BlinkenLib/BlinkenConv.c 690)     }

BlinkenLib/BlinkenConv.c 691)     // cut movie to time span
BlinkenLib/BlinkenConv.c 692)     else if (strcmp(args[i], "-ct") == 0) {
BlinkenLib/BlinkenConv.c 693)       if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c 694)         const char *str_begin, *str_end;
BlinkenLib/BlinkenConv.c 695)         unsigned int begin, end;
BlinkenLib/BlinkenConv.c 696)         i++;
BlinkenLib/BlinkenConv.c 697)         str_begin = args[i];
BlinkenLib/BlinkenConv.c 698)         i++;
BlinkenLib/BlinkenConv.c 699)         str_end = args[i];
BlinkenLib/BlinkenConv.c 700)         if (sscanf(str_begin, "%u", &begin) != 1)
BlinkenLib/BlinkenConv.c 701)           printf("invalid begin time \"%s\"\n", str_begin);
BlinkenLib/BlinkenConv.c 702)         else if (sscanf(str_end, "%u", &end) != 1)
BlinkenLib/BlinkenConv.c 703)           printf("invalid end time \"%s\"\n", str_end);
BlinkenLib/BlinkenConv.c 704)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 705)           printf("no movie loaded to cut to time span\n");
BlinkenLib/BlinkenConv.c 706)         else {
BlinkenLib/BlinkenConv.c 707)           BlinkenMovieCutTime(pMovie, begin, end);
BlinkenLib/BlinkenConv.c 708)           printf("movie cut to time %u-%u\n", begin, end);
BlinkenLib/BlinkenConv.c 709)         }
BlinkenLib/BlinkenConv.c 710)       }
BlinkenLib/BlinkenConv.c 711)       else if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c 712)         printf("missing end time for \"-ct\"\n");
BlinkenLib/BlinkenConv.c 713)         i++;
BlinkenLib/BlinkenConv.c 714)       } else
BlinkenLib/BlinkenConv.c 715)         printf("missing begin time for \"-ct\"\n");
BlinkenLib/BlinkenConv.c 716)     }

BlinkenLib/BlinkenConv.c 717)     // adapt duration of movie
BlinkenLib/BlinkenConv.c 718)     else if (strcmp(args[i], "-dur") == 0) {
BlinkenLib/BlinkenConv.c 719)       if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c 720)         unsigned int duration;
BlinkenLib/BlinkenConv.c 721)         i++;
BlinkenLib/BlinkenConv.c 722)         if (sscanf(args[i], "%u", &duration) != 1)
BlinkenLib/BlinkenConv.c 723)           printf("invalid duration \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c 724)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 725)           printf("no movie loaded to adapt duration of\n");
BlinkenLib/BlinkenConv.c 726)         else {
BlinkenLib/BlinkenConv.c 727)           BlinkenMovieAdaptDuration(pMovie, duration);
BlinkenLib/BlinkenConv.c 728)           printf("duration adapted to %u ms\n", duration);
BlinkenLib/BlinkenConv.c 729)         }
BlinkenLib/BlinkenConv.c 730)       } else
BlinkenLib/BlinkenConv.c 731)         printf("missing new duration for movie for \"-dur\"\n");
BlinkenLib/BlinkenConv.c 732)     }

BlinkenLib/BlinkenConv.c 733)     // adapt maximum frame duration
BlinkenLib/BlinkenConv.c 734)     else if (strcmp(args[i], "-maxframedur") == 0) {
BlinkenLib/BlinkenConv.c 735)       if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c 736)         unsigned int duration;
BlinkenLib/BlinkenConv.c 737)         i++;
BlinkenLib/BlinkenConv.c 738)         if (sscanf(args[i], "%u", &duration) != 1)
BlinkenLib/BlinkenConv.c 739)           printf("invalid duration \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c 740)         else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 741)           printf("no movie loaded to adapt maximum frame duration of\n");
BlinkenLib/BlinkenConv.c 742)         else {
BlinkenLib/BlinkenConv.c 743)           BlinkenMovieAdaptMaxFrameDuration(pMovie, duration);
BlinkenLib/BlinkenConv.c 744)           printf("maximum frame duration adapted to %u ms\n", duration);
BlinkenLib/BlinkenConv.c 745)         }
BlinkenLib/BlinkenConv.c 746)       } else
BlinkenLib/BlinkenConv.c 747)         printf("missing maximum frame duration for \"-maxframedur\"\n");
BlinkenLib/BlinkenConv.c 748)     }

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

BlinkenLib/BlinkenConv.c 753)         unsigned int first, count, c;
BlinkenLib/BlinkenConv.c 754)         i++;
BlinkenLib/BlinkenConv.c 755)         str_first = args[i];
BlinkenLib/BlinkenConv.c 756)         i++;
BlinkenLib/BlinkenConv.c 757)         str_count = args[i];

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

BlinkenLib/BlinkenConv.c 760)         else {

BlinkenLib/BlinkenConv.c 761)           if (sscanf(str_count, "%u", &count) != 1)
BlinkenLib/BlinkenConv.c 762)             printf("invalid number of frames \"%s\"\n", str_count);
BlinkenLib/BlinkenConv.c 763)           else if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 764)             printf("no movie loaded to delete frames from\n");
BlinkenLib/BlinkenConv.c 765)           else if (first + count >
BlinkenLib/BlinkenConv.c 766)                    (unsigned int)BlinkenMovieGetFrameCnt(pMovie))
BlinkenLib/BlinkenConv.c 767)             printf
BlinkenLib/BlinkenConv.c 768)                 ("invalid frame range (%u-%u) for deletion from %u frames\n",
BlinkenLib/BlinkenConv.c 769)                  first, first + count,
BlinkenLib/BlinkenConv.c 770)                  (unsigned int)BlinkenMovieGetFrameCnt(pMovie));

BlinkenLib/BlinkenConv.c 771)           else {

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

BlinkenLib/BlinkenConv.c 775)           }
BlinkenLib/BlinkenConv.c 776)         }

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

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

BlinkenLib/BlinkenConv.c 779)         i++;

BlinkenLib/BlinkenConv.c 780)       } else

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

BlinkenLib/BlinkenConv.c 782)     }

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

BlinkenLib/BlinkenConv.c 787)         i++;
BlinkenLib/BlinkenConv.c 788)         str_format = args[i];
BlinkenLib/BlinkenConv.c 789)         i++;
BlinkenLib/BlinkenConv.c 790)         str_mode = args[i];
BlinkenLib/BlinkenConv.c 791)         i++;
BlinkenLib/BlinkenConv.c 792)         str_duration = args[i];

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

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

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

BlinkenLib/BlinkenConv.c 799)         i++;

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

BlinkenLib/BlinkenConv.c 802)     }

BlinkenLib/BlinkenConv.c 803)     // generate test movie and append it to current video
BlinkenLib/BlinkenConv.c 804)     else if (strcmp(args[i], "-ta") == 0) {
BlinkenLib/BlinkenConv.c 805)       if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c 806)         const char *str_mode, *str_duration;
BlinkenLib/BlinkenConv.c 807)         i++;
BlinkenLib/BlinkenConv.c 808)         str_mode = args[i];
BlinkenLib/BlinkenConv.c 809)         i++;
BlinkenLib/BlinkenConv.c 810)         str_duration = args[i];
BlinkenLib/BlinkenConv.c 811)         if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 812)           printf("no movie loaded to append to\n");
BlinkenLib/BlinkenConv.c 813)         else
BlinkenLib/BlinkenConv.c 814)           gen_test_movie(&pMovie, NULL /* append */, str_mode, str_duration);
BlinkenLib/BlinkenConv.c 815)       } else if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c 816)         printf("missing duration for \"-ta\"\n");
BlinkenLib/BlinkenConv.c 817)         i += 1;
BlinkenLib/BlinkenConv.c 818)       } else if (i < argCnt)
BlinkenLib/BlinkenConv.c 819)         printf("missing test mode for \"-ta\"\n");
BlinkenLib/BlinkenConv.c 820)     }

BlinkenLib/BlinkenConv.c 821)     // copy rectangular section of other movie
BlinkenLib/BlinkenConv.c 822)     else if (strcmp(args[i], "-C") == 0) {
BlinkenLib/BlinkenConv.c 823)       if (i + 4 < argCnt) {
BlinkenLib/BlinkenConv.c 824)         char *str_file;
BlinkenLib/BlinkenConv.c 825)         const char *str_src_pos, *str_dim, *str_dest_pos;
BlinkenLib/BlinkenConv.c 826)         i++;
BlinkenLib/BlinkenConv.c 827)         str_file = args[i];
BlinkenLib/BlinkenConv.c 828)         i++;
BlinkenLib/BlinkenConv.c 829)         str_src_pos = args[i];
BlinkenLib/BlinkenConv.c 830)         i++;
BlinkenLib/BlinkenConv.c 831)         str_dim = args[i];
BlinkenLib/BlinkenConv.c 832)         i++;
BlinkenLib/BlinkenConv.c 833)         str_dest_pos = args[i];
BlinkenLib/BlinkenConv.c 834)         copy_rect(pMovie, str_file, str_src_pos, str_dim, str_dest_pos);
BlinkenLib/BlinkenConv.c 835)       } else if (i + 3 < argCnt) {
BlinkenLib/BlinkenConv.c 836)         printf("missing destination position for \"-C\"\n");
BlinkenLib/BlinkenConv.c 837)         i += 3;
BlinkenLib/BlinkenConv.c 838)       } else if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c 839)         printf("missing dimensions for \"-C\"\n");
BlinkenLib/BlinkenConv.c 840)         i += 2;
BlinkenLib/BlinkenConv.c 841)       } else if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c 842)         printf("missing source position for \"-C\"\n");
BlinkenLib/BlinkenConv.c 843)         i++;
BlinkenLib/BlinkenConv.c 844)       } else
BlinkenLib/BlinkenConv.c 845)         printf("missing file name of source movie for \"-C\"\n");
BlinkenLib/BlinkenConv.c 846)     }

BlinkenLib/BlinkenConv.c 847)     // scroll first frame of current movie
BlinkenLib/BlinkenConv.c 848)     else if (strcmp(args[i], "-S") == 0) {
BlinkenLib/BlinkenConv.c 849)       if (i + 3 < argCnt) {
BlinkenLib/BlinkenConv.c 850)         const char *str_direction, *str_width_height, *str_duration;
BlinkenLib/BlinkenConv.c 851)         i++;
BlinkenLib/BlinkenConv.c 852)         str_direction = args[i];
BlinkenLib/BlinkenConv.c 853)         i++;
BlinkenLib/BlinkenConv.c 854)         str_width_height = args[i];
BlinkenLib/BlinkenConv.c 855)         i++;
BlinkenLib/BlinkenConv.c 856)         str_duration = args[i];
BlinkenLib/BlinkenConv.c 857)         pMovie = scroll(pMovie, str_direction, str_width_height, str_duration);
BlinkenLib/BlinkenConv.c 858)       } else if (i + 2 < argCnt) {
BlinkenLib/BlinkenConv.c 859)         printf("missing duration for \"-S\"\n");
BlinkenLib/BlinkenConv.c 860)         i += 2;
BlinkenLib/BlinkenConv.c 861)       } else if (i + 1 < argCnt) {
BlinkenLib/BlinkenConv.c 862)         printf("missing width/height for \"-S\"\n");
BlinkenLib/BlinkenConv.c 863)         i++;
BlinkenLib/BlinkenConv.c 864)       } else
BlinkenLib/BlinkenConv.c 865)         printf("missing direction (left, right, up, down) for \"-S\"\n");
BlinkenLib/BlinkenConv.c 866)     }

BlinkenLib/BlinkenConv.c 867)     // rotate movie 90 degrees clockwise
BlinkenLib/BlinkenConv.c 868)     else if (strcmp(args[i], "-Rcw") == 0) {
BlinkenLib/BlinkenConv.c 869)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 870)         printf("no movie loaded to rotate\n");
BlinkenLib/BlinkenConv.c 871)       else {
BlinkenLib/BlinkenConv.c 872)         BlinkenMovieRotateCw(pMovie);
BlinkenLib/BlinkenConv.c 873)         printf("movie rotated 90 degrees clockwise\n");
BlinkenLib/BlinkenConv.c 874)       }
BlinkenLib/BlinkenConv.c 875)     }
BlinkenLib/BlinkenConv.c 876)     // rotate movie 90 degrees counter-clockwise
BlinkenLib/BlinkenConv.c 877)     else if (strcmp(args[i], "-Rccw") == 0) {
BlinkenLib/BlinkenConv.c 878)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 879)         printf("no movie loaded to rotate\n");
BlinkenLib/BlinkenConv.c 880)       else {
BlinkenLib/BlinkenConv.c 881)         BlinkenMovieRotateCcw(pMovie);
BlinkenLib/BlinkenConv.c 882)         printf("movie rotated 90 degrees counter-clockwise\n");
BlinkenLib/BlinkenConv.c 883)       }
BlinkenLib/BlinkenConv.c 884)     }
BlinkenLib/BlinkenConv.c 885)     // rotate movie 180 degrees
BlinkenLib/BlinkenConv.c 886)     else if (strcmp(args[i], "-Rh") == 0) {
BlinkenLib/BlinkenConv.c 887)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 888)         printf("no movie loaded to rotate\n");
BlinkenLib/BlinkenConv.c 889)       else {
BlinkenLib/BlinkenConv.c 890)         BlinkenMovieRotateHalf(pMovie);
BlinkenLib/BlinkenConv.c 891)         printf("movie rotated 180 degrees\n");
BlinkenLib/BlinkenConv.c 892)       }
BlinkenLib/BlinkenConv.c 893)     }
BlinkenLib/BlinkenConv.c 894)     // mirror movie horizontally
BlinkenLib/BlinkenConv.c 895)     else if (strcmp(args[i], "-Mh") == 0) {
BlinkenLib/BlinkenConv.c 896)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 897)         printf("no movie loaded to mirror\n");
BlinkenLib/BlinkenConv.c 898)       else {
BlinkenLib/BlinkenConv.c 899)         BlinkenMovieMirrorHor(pMovie);
BlinkenLib/BlinkenConv.c 900)         printf("movie mirrored horizontally\n");
BlinkenLib/BlinkenConv.c 901)       }
BlinkenLib/BlinkenConv.c 902)     }
BlinkenLib/BlinkenConv.c 903)     // mirror movie vertically
BlinkenLib/BlinkenConv.c 904)     else if (strcmp(args[i], "-Mv") == 0) {
BlinkenLib/BlinkenConv.c 905)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 906)         printf("no movie loaded to mirror\n");
BlinkenLib/BlinkenConv.c 907)       else {
BlinkenLib/BlinkenConv.c 908)         BlinkenMovieMirrorVer(pMovie);
BlinkenLib/BlinkenConv.c 909)         printf("movie mirrored vertically\n");
BlinkenLib/BlinkenConv.c 910)       }
BlinkenLib/BlinkenConv.c 911)     }
BlinkenLib/BlinkenConv.c 912)     // mirror movie diagonally
BlinkenLib/BlinkenConv.c 913)     else if (strcmp(args[i], "-Md") == 0) {
BlinkenLib/BlinkenConv.c 914)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 915)         printf("no movie loaded to mirror\n");
BlinkenLib/BlinkenConv.c 916)       else {
BlinkenLib/BlinkenConv.c 917)         BlinkenMovieMirrorDiag(pMovie);
BlinkenLib/BlinkenConv.c 918)         printf("movie mirrored diagonally (\\)\n");
BlinkenLib/BlinkenConv.c 919)       }
BlinkenLib/BlinkenConv.c 920)     }
BlinkenLib/BlinkenConv.c 921)     // mirror movie diagonally
BlinkenLib/BlinkenConv.c 922)     else if (strcmp(args[i], "-Md2") == 0) {
BlinkenLib/BlinkenConv.c 923)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 924)         printf("no movie loaded to mirror\n");
BlinkenLib/BlinkenConv.c 925)       else {
BlinkenLib/BlinkenConv.c 926)         BlinkenMovieMirrorDiag2(pMovie);
BlinkenLib/BlinkenConv.c 927)         printf("movie mirrored diagonally (/)\n");
BlinkenLib/BlinkenConv.c 928)       }
BlinkenLib/BlinkenConv.c 929)     }

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

BlinkenConv.c            933)         i++;

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

BlinkenConv.c            938)         else

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

BlinkenConv.c            942)     }

BlinkenLib/BlinkenConv.c 943)     // old style input filename
BlinkenLib/BlinkenConv.c 944)     else if (i == 1 && args[i][0] != '-') {
BlinkenLib/BlinkenConv.c 945)       printf("old style input filename \"%s\", better use \"-i %s\"\n",
BlinkenLib/BlinkenConv.c 946)              args[i], args[i]);
BlinkenLib/BlinkenConv.c 947)       if (pMovie != NULL)
BlinkenLib/BlinkenConv.c 948)         BlinkenMovieFree(pMovie);
BlinkenLib/BlinkenConv.c 949)       pMovie = BlinkenMovieLoad(args[i]);
BlinkenLib/BlinkenConv.c 950)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 951)         printf("could not read movie \"%s\"\n", args[i]);

BlinkenConv.c            952)       else

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

BlinkenConv.c            954)     }

BlinkenLib/BlinkenConv.c 955)     // old style output filename
BlinkenLib/BlinkenConv.c 956)     else if (i == 2 && args[i][0] != '-') {
BlinkenLib/BlinkenConv.c 957)       printf("old style output filename \"%s\", better use \"-o %s\"\n",
BlinkenLib/BlinkenConv.c 958)              args[i], args[i]);
BlinkenLib/BlinkenConv.c 959)       if (pMovie == NULL)
BlinkenLib/BlinkenConv.c 960)         printf("no movie loaded to write to \"%s\"\n", args[i]);
BlinkenLib/BlinkenConv.c 961)       else if (BlinkenMovieSave(pMovie, args[i]) < 0)
BlinkenLib/BlinkenConv.c 962)         printf("could not write movie \"%s\"\n", args[i]);

BlinkenConv.c            963)       else

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

BlinkenConv.c            965)     }

BlinkenLib/BlinkenConv.c 966)     // unknown parameter

BlinkenConv.c            967)     else

BlinkenLib/BlinkenConv.c 968)       printf
BlinkenLib/BlinkenConv.c 969)           ("unknown parameter \"%s\", call without parameters to get help\n",
BlinkenLib/BlinkenConv.c 970)            args[i]);
BlinkenLib/BlinkenConv.c 971) 
BlinkenLib/BlinkenConv.c 972)   }     // for( i ...
BlinkenLib/BlinkenConv.c 973) 
BlinkenLib/BlinkenConv.c 974)   // old style print
BlinkenLib/BlinkenConv.c 975)   if (argCnt == 2 && pMovie != NULL) {
BlinkenLib/BlinkenConv.c 976)     str = BlinkenMovieToString(pMovie);
BlinkenLib/BlinkenConv.c 977)     if (str == NULL)
BlinkenLib/BlinkenConv.c 978)       printf("could not print movie\n");
BlinkenLib/BlinkenConv.c 979)     else {
BlinkenLib/BlinkenConv.c 980)       printf("%s", str);
BlinkenLib/BlinkenConv.c 981)       free(str);

BlinkenConv.c            982)     }

BlinkenConv.c            983)   }

BlinkenLib/BlinkenConv.c 984)   // free movie
BlinkenLib/BlinkenConv.c 985)   if (pMovie != NULL)
BlinkenLib/BlinkenConv.c 986)     BlinkenMovieFree(pMovie);

BlinkenConv.c            987)