BlinkenLib/BlinkenConv.c (0cc0744) - BlinkenLib · BlinkenArea

BlinkenConv.c

/* BlinkenLib
   Copyright 2004-2014 Stefan Schuermans <stefan@schuermans.info>
   Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html
   a blinkenarea.org project */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <BlinkenLib/BlinkenLib.h>

/**
 * @brief generate test movie
 * @param[in,out] *pMovie pointer to old/new/changed movie
 * @param[in] str_format format of new video to generate,
 *                       may be NULL for appending to video
 * @param[in] str_mode test movie mode: black, white, dots, lines, trans
 * @param[in] str_duration duration of each frame in ms (as string)
 */
static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,
                           const char *str_mode, const char *str_duration)
{
  unsigned int height, width, channels, colors;
  enum {
    ModeNone, ModeBlack, ModeWhite, ModeDots, ModeLines, ModeTrans
  } mode = ModeNone;
  int fmt_ok, append, duration;

//format
  if (str_format == NULL) {
    if (*ppMovie == NULL) {
      str_format = "<none>";
      fmt_ok = 0;
      append = 0;
    } else {
      height = BlinkenMovieGetHeight(*ppMovie);
      width = BlinkenMovieGetWidth(*ppMovie);
      channels = BlinkenMovieGetChannels(*ppMovie);
      colors = BlinkenMovieGetMaxval(*ppMovie) + 1;
      fmt_ok = 1;
      append = 1;
    }
  } else {
    fmt_ok = sscanf(str_format, "%ux%u-%u/%u",
                    &width, &height, &channels, &colors) == 4;
    append = 0;
  }
  //mode
  if (strcmp(str_mode, "black") == 0)
    mode = ModeBlack;
  if (strcmp(str_mode, "white") == 0)
    mode = ModeWhite;
  if (strcmp(str_mode, "dots") == 0)
    mode = ModeDots;
  if (strcmp(str_mode, "lines") == 0)
    mode = ModeLines;
  if (strcmp(str_mode, "trans") == 0)
    mode = ModeTrans;
  //check
  if (! fmt_ok)
    printf("invalid movie format \"%s\" for \"-t\" or \"-ta\"\n", str_format);
  else if (mode == ModeNone)
    printf("invalid test mode \"%s\" for \"-t\" or \"-ta\"\n", str_mode);
  else if (sscanf(str_duration, "%u", &duration) != 1)
    printf("invalid duration \"%s\" for \"-t\" or \"-ta\"\n", str_duration);
  else {

if (! append) {
      if (*ppMovie != NULL)
        BlinkenMovieFree(*ppMovie);
      *ppMovie = BlinkenMovieNew(height, width, channels, colors - 1);
      if (*ppMovie == NULL)
        printf("could not create movie with format \"%ux%u-%x/%u\""
               " for \"-t\" or \"-ta\"\n",
               width, height, channels, colors);
    }

if (*ppMovie != NULL) {

unsigned int y, x, c, c2, c3, o, b, yy, xx, cc, oo;
      stBlinkenFrame *pFrame;
      height = BlinkenMovieGetHeight(*ppMovie);
      width = BlinkenMovieGetWidth(*ppMovie);
      channels = BlinkenMovieGetChannels(*ppMovie);
      colors = BlinkenMovieGetMaxval(*ppMovie) + 1;
      switch (mode) {

case ModeNone:
        break;

case ModeBlack:
        pFrame =
            BlinkenFrameNew(height, width, channels, colors - 1,
                            duration);
        for (yy = 0; yy < height; yy++)
          for (xx = 0; xx < width; xx++)
            for (cc = 0; cc < channels; cc++)
              BlinkenFrameSetPixel(pFrame, yy, xx, cc, 0);
        BlinkenMovieAppendFrame(*ppMovie, pFrame);
        break;

case ModeWhite:
        pFrame =
            BlinkenFrameNew(height, width, channels, colors - 1,
                            duration);
        for (yy = 0; yy < height; yy++)
          for (xx = 0; xx < width; xx++)
            for (cc = 0; cc < channels; cc++)
              BlinkenFrameSetPixel(pFrame, yy, xx, cc, colors - 1);
        BlinkenMovieAppendFrame(*ppMovie, pFrame);
        break;

case ModeDots:
        for (c = 0; c < channels; c++)
          for (y = 0; y < height; y++)
            for (x = 0; x < width; x++) {
              pFrame =
                  BlinkenFrameNew(height, width, channels, colors - 1,
                                  duration);
              for (yy = 0; yy < height; yy++)
                for (xx = 0; xx < width; xx++)
                  for (cc = 0; cc < channels; cc++)
                    BlinkenFrameSetPixel(pFrame, yy, xx, cc,
                                         yy == y && xx == x
                                         && cc == c ? colors - 1 : 0);
              BlinkenMovieAppendFrame(*ppMovie, pFrame);
            }
        break;

case ModeLines:
        for (c = 0; c < channels; c++) {
          for (x = 0; x < width; x++) {
            pFrame =
                BlinkenFrameNew(height, width, channels, colors - 1,
                                duration);
            for (yy = 0; yy < height; yy++)
              for (xx = 0; xx < width; xx++)
                for (cc = 0; cc < channels; cc++)
                  BlinkenFrameSetPixel(pFrame, yy, xx, cc,
                                       xx == x && cc == c ? colors - 1 : 0);
            BlinkenMovieAppendFrame(*ppMovie, pFrame);
          }
          for (y = 0; y < height; y++) {
            pFrame =
                BlinkenFrameNew(height, width, channels, colors - 1,
                                duration);
            for (yy = 0; yy < height; yy++)
              for (xx = 0; xx < width; xx++)
                for (cc = 0; cc < channels; cc++)
                  BlinkenFrameSetPixel(pFrame, yy, xx, cc,
                                       yy == y && cc == c ? colors - 1 : 0);
            BlinkenMovieAppendFrame(*ppMovie, pFrame);
          }
        }
        break;

case ModeTrans:
        for (c = 0; c < channels; c++)
          for (b = 0; b < 2; b++)
            for (c2 = 0; c2 < channels; c2++)
              for (o = 0; o < colors - 1; o++) {
                pFrame =
                    BlinkenFrameNew(height, width, channels, colors - 1,
                                    duration);
                for (cc = 0; cc < channels; cc++) {
                  c3 = (cc + channels - c) % channels;
                  oo = b ? (c3 < c2 ? 0 : c3 >
                            c2 ? colors - 1 : colors - 1 - o)
                      : (c3 < c2 ? colors - 1 : c3 > c2 ? 0 : o);
                  for (yy = 0; yy < height; yy++)
                    for (xx = 0; xx < width; xx++)
                      BlinkenFrameSetPixel(pFrame, yy, xx, cc, oo);
                }
                BlinkenMovieAppendFrame(*ppMovie, pFrame);
              }
        break;

} // switch( mode )

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

}   // if( *ppMovie == NULL ) ... else

}     // else
}

static void copy_rect(stBlinkenMovie *pMovie, char *str_file,
                      const char *str_src_pos, const char *str_dim,
                      const char *str_dest_pos)
{
  unsigned int sy, sx, h, w, dy, dx;
  stBlinkenMovie *pSrcMovie;

if (sscanf(str_src_pos, "%u,%u", &sx, &sy) != 2)
    printf("invalid source position \"%s\" for \"-C\"\n", str_src_pos);
  else if (sscanf(str_dim, "%ux%u", &w, &h) != 2)
    printf("invalid dimensions \"%s\" for \"-C\"\n", str_dim);
  else if (sscanf(str_dest_pos, "%u,%u", &dx, &dy) != 2)
    printf("invalid destination position \"%s\" for \"-C\"\n", str_dest_pos);
  else {

pSrcMovie = BlinkenMovieLoad(str_file);
    if (pSrcMovie == NULL)
      printf("could not read movie \"%s\"\n", str_file);
    else {

BlinkenMovieCopyRect(pMovie, dy, dx, pSrcMovie, sy, sx, h, w);
      BlinkenMovieFree(pSrcMovie);
      printf("copied %ux%u pixels from movie \"%s\" %u,%u to %u,%u\n",
             w, h, str_file, sx, sy, dx, dy );

}
  }
}

int main(int argCnt, char **args)
{
  stBlinkenMovie *pMovie;
  int i;
  char *str;
  unsigned int height, width, channels, colors, times;
  int mode;

// print info
  printf("BlinkenLib - BlinkenConv\n"
         "version %d.%d.%d\n"
         "config " BLINKENLIB_CONFIG "\n"
         "Copyright 2004-2014 Stefan Schuermans <stefan@schuermans.info>\n"
         "Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html\n"
         "a blinkenarea.org project\n\n",
         BLINKENLIB_VERSION_MAJOR, BLINKENLIB_VERSION_MINOR,
         BLINKENLIB_VERSION_REVISION);

// print syntax
  if (argCnt <= 1) {
#ifdef BLINKENLIB_CFG_MNG
# define MNGEXT ", *.mng"
#else
# define MNGEXT
#endif
    printf("syntax: %s <parameter> [...]\n\n"
           "parameters:\n"
           "  -i <file>\n"
           "     read movie from file (*.blm, *.bmm, *.bml, *.bbm"MNGEXT")\n"
           "  -a <file>\n"
           "     append movie from file (*.blm, *.bmm, *.bml, *.bbm"MNGEXT")\n"
           "  -l <number>\n"
           "     loop video a number of times\n"
           "  -f\n"
           "     output format, frame count and duration of movie\n"
           "  -p\n"
           "     print movie\n"
           "  -r <width>x<height>-<channels>/<colors>\n"
           "     resize movie\n"
           "  -s <width>x<height>\n"
           "     scale movie\n"
           "  -c <channels> [solid|rainbow]\n"
           "     colorize movie\n"
           "  -R\n"
           "     reverse movie\n"
           "  -d <first> <count>\n"
           "     delete frames\n"
           "  -t <width>x<height>-<channels>/<colors> <test_mode> <duration>\n"
           "     generate a test movie\n"
           "  -ta <test_mode> <duration>\n"
           "     generate a test movie and append it to current video\n"
           "  -C <file> <src-x>,<src-y> <width>x<height> <dest-x>,<dest-y>\n"
           "     copy rectangular section of other movie\n"
           "  -Rcw\n"
           "     rotate movie 90 degrees clockwise\n"
           "  -Rccw\n"
           "     rotate movie 90 degrees counter-clockwise\n"
           "  -Rh\n"
           "     rotate movie 180 degrees\n"
           "  -Mh\n"
           "     mirror movie horizontally\n"
           "  -Mv\n"
           "     mirror movie vertically\n"
           "  -Md\n"
           "     mirror movie diagonally (\\)\n"
           "  -Md2\n"
           "     mirror movie diagonally (/)\n"
           "  -o <file>\n"
           "     write movie to file (*.blm, *.bmm, *.bml, *.bbm)\n\n"
           "test_modes: black, white, dots, lines, trans\n\n"
           "old syntax: %s <input-file> [<output-file>]\n\n",
           args[0], args[0]);
    return 0;
  }
  // no movie loaded
  pMovie = NULL;

// process parameters
  for (i = 1; i < argCnt; i++) {

// read movie
    if (strcmp(args[i], "-i") == 0) {
      if (i + 1 < argCnt) {
        i++;
        if (pMovie != NULL)
          BlinkenMovieFree(pMovie);
        pMovie = BlinkenMovieLoad(args[i]);
        if (pMovie == NULL)
          printf("could not read movie \"%s\"\n", args[i]);
        else
          printf("movie \"%s\" read\n", args[i]);
      } else
        printf("missing input filename for \"-i\"\n");
    }
    // append movie
    else if (strcmp(args[i], "-a") == 0) {
      if (i + 1 < argCnt) {
        i++;
        if (pMovie == NULL)
          printf("no movie loaded to append to\n");
        else {
          stBlinkenMovie *pMovie2;
          pMovie2 = BlinkenMovieLoad(args[i]);
          if (pMovie2 == NULL)
            printf("could not read movie \"%s\"\n", args[i]);
          else {
            if (BlinkenMovieConcat(pMovie, pMovie2) < 0) {
              BlinkenMovieFree(pMovie2);
              printf("movie read from \"%s\" could not be appended\n",
                     args[i]);
            } else
              printf("movie \"%s\" read and appended\n", args[i]);
          }
        }
      } else
        printf("missing input filename for \"-a\"\n");
    }
    // loop movie
    else if (strcmp(args[i], "-l") == 0) {
      if (i + 1 < argCnt) {
        i++;
        if (sscanf(args[i], "%u", &times) != 1 || times < 1)
          printf("invalid number of times \"%s\"\n", args[i]);
        else if (pMovie == NULL)
          printf("no movie loaded to loop\n");
        else {
          stBlinkenMovie *pMovie2, *pMovie3;
          int err = 0;
          unsigned int t;
          pMovie2 = BlinkenMovieClone(pMovie);
          if (pMovie2 == NULL)
            err = 1;
          else {
            for (t = 1 /* loop one time means nothing to do */ ; t < times;
                 t++) {
              pMovie3 = BlinkenMovieClone(pMovie2);
              if (pMovie3 == NULL)
                err = 1;
              else {
                if (BlinkenMovieConcat(pMovie, pMovie3) < 0) {
                  BlinkenMovieFree(pMovie3);
                  err = 1;
                }
              }
            }
            BlinkenMovieFree(pMovie2);
          }
          if (err)
            printf("could not loop movie\n");
          else
            printf("movie looped %u times\n", times);
        }
      } else
        printf("missing movie format for \"-r\"\n");
    }
    // output format, frame count and duration of movie
    else if (strcmp(args[i], "-f") == 0) {
      if (pMovie == NULL)
        printf
            ("no movie loaded to output format, frame count and duration of\n");
      else
        printf
            ("format:      %ux%u-%u/%u\nframe count: %u\nduration:    %u ms\n",
             BlinkenMovieGetWidth(pMovie), BlinkenMovieGetHeight(pMovie),
             BlinkenMovieGetChannels(pMovie),
             BlinkenMovieGetMaxval(pMovie) + 1,
             BlinkenMovieGetFrameCnt(pMovie),
             BlinkenMovieGetDuration(pMovie));
    }
    // print movie
    else if (strcmp(args[i], "-p") == 0) {
      if (pMovie == NULL)
        printf("no movie loaded to print\n");
      else {
        str = BlinkenMovieToString(pMovie);
        if (str == NULL)
          printf("could not print movie\n");
        else {
          printf("%s", str);
          free(str);
        }
      }
    }
    // resize movie
    else if (strcmp(args[i], "-r") == 0) {
      if (i + 1 < argCnt) {
        i++;
        if (sscanf
            (args[i], "%ux%u-%u/%u", &width, &height, &channels,
             &colors) != 4)
          printf("invalid movie format \"%s\"\n", args[i]);
        else if (pMovie == NULL)
          printf("no movie loaded to resize\n");
        else {
          BlinkenMovieResize(pMovie, height, width, channels, colors - 1);
          printf("movie resized to %ux%u-%u/%u\n", width, height, channels,
                 colors);
        }
      } else
        printf("missing movie format for \"-r\"\n");
    }
    // scale movie
    else if (strcmp(args[i], "-s") == 0) {
      if (i + 1 < argCnt) {
        i++;
        if (sscanf(args[i], "%ux%u", &width, &height) != 2)
          printf("invalid movie dimensions \"%s\"\n", args[i]);
        else if (pMovie == NULL)
          printf("no movie loaded to scale\n");
        else {
          BlinkenMovieScale(pMovie, height, width);
          printf("movie scaled to %ux%u\n", width, height);
        }
      } else
        printf("missing movie dimensions for \"-s\"\n");
    }
    // colorize movie
    else if (strcmp(args[i], "-c") == 0) {
      if (i + 2 < argCnt) {
        const char *str_channels, *str_mode;
        i++;
        str_channels = args[i];
        i++;
        str_mode = args[i];
        if (sscanf(str_channels, "%u", &channels) != 1)
          printf("invalid number of channels \"%s\"\n", str_channels);
        else {
          mode = BlinkenColorizerStr2Mode(str_mode);
          if (mode < 0)
            printf("invalid colorizing mode \"%s\"\n", str_mode);
          else if (pMovie == NULL)
            printf("no movie loaded to colorize\n");
          else {
            BlinkenMovieColorize(pMovie, channels, mode);
            printf("movie colorized to %u channels using mode %s\n", channels,
                   BlinkenColorizerMode2Str(mode));
          }
        }
      } else if (i + 1 < argCnt) {
        printf("missing colorizing mode for \"-c\"\n");
        i++;
      } else
        printf("missing number of channels for \"-c\"\n");
    }
    // reverse movie
    else if (strcmp(args[i], "-R") == 0) {
      if (pMovie == NULL)
        printf("no movie loaded to reverse\n");
      else {
        BlinkenMovieReverse(pMovie);
        printf("movie reversed\n");
      }
    }
    // delete frames
    else if (strcmp(args[i], "-d") == 0) {
      if (i + 2 < argCnt) {
        const char *str_first, *str_count;
        unsigned int first, count, c;
        i++;
        str_first = args[i];
        i++;
        str_count = args[i];
        if (sscanf(str_first, "%u", &first) != 1)
          printf("invalid number of first frame \"%s\"\n", str_first);
        else {
          if (sscanf(str_count, "%u", &count) != 1)
            printf("invalid number of frames \"%s\"\n", str_count);
          else if (pMovie == NULL)
            printf("no movie loaded to delete frames from\n");
          else if (first + count >
                   (unsigned int)BlinkenMovieGetFrameCnt(pMovie))
            printf
                ("invalid frame range (%u-%u) for deletion from %u frames\n",
                 first, first + count,
                 (unsigned int)BlinkenMovieGetFrameCnt(pMovie));
          else {
            for (c = 0; c < count; c++)
              BlinkenMovieDeleteFrame(pMovie, first);
            printf("deleted frames %u-%u\n", first, first + count);
          }
        }
      } else if (i + 1 < argCnt) {
        printf("missing colorizing mode for \"-c\"\n");
        i++;
      } else
        printf("missing number of channels for \"-c\"\n");
    }
    // generate test movie
    else if (strcmp(args[i], "-t") == 0) {
      if (i + 3 < argCnt) {
        const char *str_format, *str_mode, *str_duration;
        i++;
        str_format = args[i];
        i++;
        str_mode = args[i];
        i++;
        str_duration = args[i];
        gen_test_movie(&pMovie, str_format, str_mode, str_duration);
      } else if (i + 2 < argCnt) {
        printf("missing duration for \"-t\"\n");
        i += 2;
      } else if (i + 1 < argCnt) {
        printf("missing test mode for \"-t\"\n");
        i++;
      } else
        printf("missing format for \"-t\"\n");
    }
    // generate test movie and append it to current video
    else if (strcmp(args[i], "-ta") == 0) {
      if (i + 2 < argCnt) {
        const char *str_mode, *str_duration;
        i++;
        str_mode = args[i];
        i++;
        str_duration = args[i];
        if (pMovie == NULL)
          printf("no movie loaded to append to\n");
        else
          gen_test_movie(&pMovie, NULL /* append */, str_mode, str_duration);
      } else if (i + 1 < argCnt) {
        printf("missing duration for \"-ta\"\n");
        i += 1;
      } else if (i < argCnt)
        printf("missing test mode for \"-ta\"\n");
    }
    // copy rectangular section of other movie
    else if (strcmp(args[i], "-C") == 0) {
      if (i + 4 < argCnt) {
        char *str_file;
        const char *str_src_pos, *str_dim, *str_dest_pos;
        i++;
        str_file = args[i];
        i++;
        str_src_pos = args[i];
        i++;
        str_dim = args[i];
        i++;
        str_dest_pos = args[i];
        copy_rect(pMovie, str_file, str_src_pos, str_dim, str_dest_pos);
      } else if (i + 3 < argCnt) {
        printf("missing destination position for \"-C\"\n");
        i += 3;
      } else if (i + 2 < argCnt) {
        printf("missing dimensions for \"-C\"\n");
        i += 2;
      } else if (i + 1 < argCnt) {
        printf("missing source position for \"-C\"\n");
        i++;
      } else
        printf("missing file name of source movie for \"-C\"\n");
    }
    // rotate movie 90 degrees clockwise
    else if (strcmp(args[i], "-Rcw") == 0) {
      if (pMovie == NULL)
        printf("no movie loaded to rotate\n");
      else {
        BlinkenMovieRotateCw(pMovie);
        printf("movie rotated 90 degrees clockwise\n");
      }
    }
    // rotate movie 90 degrees counter-clockwise
    else if (strcmp(args[i], "-Rccw") == 0) {
      if (pMovie == NULL)
        printf("no movie loaded to rotate\n");
      else {
        BlinkenMovieRotateCcw(pMovie);
        printf("movie rotated 90 degrees counter-clockwise\n");
      }
    }
    // rotate movie 180 degrees
    else if (strcmp(args[i], "-Rh") == 0) {
      if (pMovie == NULL)
        printf("no movie loaded to rotate\n");
      else {
        BlinkenMovieRotateHalf(pMovie);
        printf("movie rotated 180 degrees\n");
      }
    }
    // mirror movie horizontally
    else if (strcmp(args[i], "-Mh") == 0) {
      if (pMovie == NULL)
        printf("no movie loaded to mirror\n");
      else {
        BlinkenMovieMirrorHor(pMovie);
        printf("movie mirrored horizontally\n");
      }
    }
    // mirror movie vertically
    else if (strcmp(args[i], "-Mv") == 0) {
      if (pMovie == NULL)
        printf("no movie loaded to mirror\n");
      else {
        BlinkenMovieMirrorVer(pMovie);
        printf("movie mirrored vertically\n");
      }
    }
    // mirror movie diagonally
    else if (strcmp(args[i], "-Md") == 0) {
      if (pMovie == NULL)
        printf("no movie loaded to mirror\n");
      else {
        BlinkenMovieMirrorDiag(pMovie);
        printf("movie mirrored diagonally (\\)\n");
      }
    }
    // mirror movie diagonally
    else if (strcmp(args[i], "-Md2") == 0) {
      if (pMovie == NULL)
        printf("no movie loaded to mirror\n");
      else {
        BlinkenMovieMirrorDiag2(pMovie);
        printf("movie mirrored diagonally (/)\n");
      }
    }
    // write movie
    else if (strcmp(args[i], "-o") == 0) {
      if (i + 1 < argCnt) {
        i++;
        if (pMovie == NULL)
          printf("no movie loaded to write to \"%s\"\n", args[i]);
        else if (BlinkenMovieSave(pMovie, args[i]) < 0)
          printf("could not write movie \"%s\"\n", args[i]);
        else
          printf("movie \"%s\" written\n", args[i]);
      } else
        printf("missing output filename for \"-o\"\n");
    }
    // old style input filename
    else if (i == 1 && args[i][0] != '-') {
      printf("old style input filename \"%s\", better use \"-i %s\"\n",
             args[i], args[i]);
      if (pMovie != NULL)
        BlinkenMovieFree(pMovie);
      pMovie = BlinkenMovieLoad(args[i]);
      if (pMovie == NULL)
        printf("could not read movie \"%s\"\n", args[i]);
      else
        printf("movie \"%s\" read\n", args[i]);
    }
    // old style output filename
    else if (i == 2 && args[i][0] != '-') {
      printf("old style output filename \"%s\", better use \"-o %s\"\n",
             args[i], args[i]);
      if (pMovie == NULL)
        printf("no movie loaded to write to \"%s\"\n", args[i]);
      else if (BlinkenMovieSave(pMovie, args[i]) < 0)
        printf("could not write movie \"%s\"\n", args[i]);
      else
        printf("movie \"%s\" written\n", args[i]);
    }
    // unknown parameter
    else
      printf
          ("unknown parameter \"%s\", call without parameters to get help\n",
           args[i]);

}     // for( i ...

// old style print
  if (argCnt == 2 && pMovie != NULL) {
    str = BlinkenMovieToString(pMovie);
    if (str == NULL)
      printf("could not print movie\n");
    else {
      printf("%s", str);
      free(str);
    }
  }
  // free movie
  if (pMovie != NULL)
    BlinkenMovieFree(pMovie);

return 0;
}

BlinkenLib

implemented appending test movie