format (860e91b) - BlinkenLib · BlinkenArea

format

Stefan Schuermans commited on 2023-08-18 09:55:23
Showing 21 changed files, with 717 additions and 857 deletions.

include/BlinkenLib/BlinkenColorizer.h 610d7e4..596dd26
include/BlinkenLib/BlinkenFrame.h 62d9613..a981003
include/BlinkenLib/BlinkenLib.h c9b77c6..03f5a7d
include/BlinkenLib/BlinkenMovie.h 780335c..c27c107
include/BlinkenLib/BlinkenProto.h 67c17c1..b0f8dcc
src/BlinkenColorizer.c 4e6ec28..49a18b8
src/BlinkenFrame.c 25a5ab6..e73d674
src/BlinkenGif.c da72354..a39612d
src/BlinkenGif.h ace5203..bf98ffd
src/BlinkenMng.c d26a973..9899b11
src/BlinkenMng.h 2c23475..f9c4630
src/BlinkenMovie.c 3f2d08e..c76e8b7
src/BlinkenProto.c 46c028a..799edbd
src/Tools.c 276f3d7..0c25120
tools/BlinkenConv.c b65dc87..7de9ed6
tools/BlinkenDeviceOutput.c e7d3b4c..5afa925
tools/BlinkenOutput.c 17d8189..50ac3cb
tools/BlinkenOutputWin.c 2b4233d..16aa5bf
tools/BlinkenRecv.c f205837..4afa82b
tools/BlinkenSend.c 215dba4..fcb43f5
tools/Tools2.c 6064c52..8191ff8

@@ -18,8 +18,8 @@ int BlinkenColorizerStr2Mode(const char *str);
 const char *BlinkenColorizerMode2Str(int mode);
 
 // get color for colorizing
-unsigned char BlinkenColorizerGetColor(int channels, int mode, int step,
-                                       int y, int x, int c);
+unsigned char BlinkenColorizerGetColor(int channels, int mode, int step, int y,
+                                       int x, int c);
 
 #ifdef __cplusplus
 } // extern "C"

include/BlinkenLib/BlinkenFrame.h

View file @ 860e91b

@@ -14,8 +14,8 @@ extern "C" {
 
 typedef struct sBlinkenFrame stBlinkenFrame;
 
-stBlinkenFrame *BlinkenFrameNew(int height, int width, int channels,
-                                int maxval, int duration);
+stBlinkenFrame *BlinkenFrameNew(int height, int width, int channels, int maxval,
+                                int duration);
 
 stBlinkenFrame *BlinkenFrameClone(stBlinkenFrame *pSrcFrame);
 
@@ -31,8 +31,7 @@ int BlinkenFrameGetMaxval(stBlinkenFrame *pFrame);
 int BlinkenFrameGetDuration(stBlinkenFrame *pFrame);
 void BlinkenFrameSetDuration(stBlinkenFrame *pFrame, int duration);
 
-unsigned char BlinkenFrameGetPixel(stBlinkenFrame *pFrame, int y, int x,
-                                   int c);
+unsigned char BlinkenFrameGetPixel(stBlinkenFrame *pFrame, int y, int x, int c);
 void BlinkenFrameSetPixel(stBlinkenFrame *pFrame, int y, int x, int c,
                           unsigned char val);
 
@@ -51,8 +50,8 @@ void BlinkenFrameSetColor(stBlinkenFrame *pFrame, int y, int x,
  * \param[in] dc number of channels in area
  * \param[in] pData pointer to buffer for pixel data, size must be dy * dx * dc
  */
-void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame,
-                              int y, int dy, int x, int dx, int c, int dc,
+void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame, int y, int dy,
+                              int x, int dx, int c, int dc,
                               unsigned char *pData);
 
 /**
@@ -66,8 +65,8 @@ void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame,
  * \param[in] dc number of channels in area
  * \param[in] pData pointer to new pixel data, size must be dy * dx * dc
  */
-void BlinkenFrameSetPixelData(stBlinkenFrame *pFrame,
-                              int y, int dy, int x, int dx, int c, int dc,
+void BlinkenFrameSetPixelData(stBlinkenFrame *pFrame, int y, int dy, int x,
+                              int dx, int c, int dc,
                               unsigned char const *pData);
 
 int BlinkenFrameIsEmpty(stBlinkenFrame *pFrame);
@@ -78,14 +77,14 @@ int BlinkenFrameCompare(stBlinkenFrame *pFrame1, stBlinkenFrame *pFrame2);
 
 void BlinkenFrameResize(stBlinkenFrame *pFrame, int height, int width,
                         int channels, int maxval);
-void BlinkenFrameCrop(stBlinkenFrame *pFrame, int top, int left,
-                      int height, int width);
+void BlinkenFrameCrop(stBlinkenFrame *pFrame, int top, int left, int height,
+                      int width);
 void BlinkenFrameScale(stBlinkenFrame *pFrame, int height, int width);
 void BlinkenFrameColorize(stBlinkenFrame *pFrame, int channels, int mode,
                           int step);
 void BlinkenFrameCopyRect(stBlinkenFrame *pDest, int destY, int destX,
-                          stBlinkenFrame *pSrc, int srcY, int srcX,
-                          int height, int width);
+                          stBlinkenFrame *pSrc, int srcY, int srcX, int height,
+                          int width);
 
 void BlinkenFrameRotateCw(stBlinkenFrame *pFrame);
 void BlinkenFrameRotateCcw(stBlinkenFrame *pFrame);

include/BlinkenLib/BlinkenLib.h

View file @ 860e91b

@@ -6,10 +6,10 @@
 #ifndef INC_BlinkenLib_BlinkenLib
 #define INC_BlinkenLib_BlinkenLib
 
-#include <BlinkenLib/config.h>
 #include <BlinkenLib/BlinkenColorizer.h>
 #include <BlinkenLib/BlinkenFrame.h>
 #include <BlinkenLib/BlinkenMovie.h>
 #include <BlinkenLib/BlinkenProto.h>
+#include <BlinkenLib/config.h>
 
 #endif // #ifndef INC_BlinkenLib_BlinkenLib

include/BlinkenLib/BlinkenMovie.h

View file @ 860e91b

@@ -6,8 +6,8 @@
 #ifndef INC_BlinkenLib_BlinkenMovie
 #define INC_BlinkenLib_BlinkenMovie
 
-#include <BlinkenLib/config.h>
 #include <BlinkenLib/BlinkenFrame.h>
+#include <BlinkenLib/config.h>
 
 #ifdef WIN32
 #include <winsock2.h>
@@ -60,8 +60,8 @@ void BlinkenMovieDeleteFrames(stBlinkenMovie *pMovie);
 int BlinkenMovieConcat(stBlinkenMovie *pMovie,
                        stBlinkenMovie *pMovie2 /* appended and freed */);
 void BlinkenMovieReverse(stBlinkenMovie *pMovie);
-void BlinkenMovieCutTime(stBlinkenMovie *pMovie,
-                         int begin /* in ms */, int end /* in ms */);
+void BlinkenMovieCutTime(stBlinkenMovie *pMovie, int begin /* in ms */,
+                         int end /* in ms */);
 void BlinkenMovieAdaptDuration(stBlinkenMovie *pMovie,
                                int duration /* in ms */);
 void BlinkenMovieAdaptMaxFrameDuration(stBlinkenMovie *pMovie,
@@ -69,13 +69,13 @@ void BlinkenMovieAdaptMaxFrameDuration(stBlinkenMovie *pMovie,
 
 void BlinkenMovieResize(stBlinkenMovie *pMovie, int height, int width,
                         int channels, int maxval);
-void BlinkenMovieCrop(stBlinkenMovie *pMovie, int top, int left,
-                      int height, int width);
+void BlinkenMovieCrop(stBlinkenMovie *pMovie, int top, int left, int height,
+                      int width);
 void BlinkenMovieScale(stBlinkenMovie *pMovie, int height, int width);
 void BlinkenMovieColorize(stBlinkenMovie *pMovie, int channels, int mode);
 void BlinkenMovieCopyRect(stBlinkenMovie *pDest, int destY, int destX,
-                          stBlinkenMovie *pSrc, int srcY, int srcX,
-                          int height, int width);
+                          stBlinkenMovie *pSrc, int srcY, int srcX, int height,
+                          int width);
 
 void BlinkenMovieRotateCw(stBlinkenMovie *pMovie);
 void BlinkenMovieRotateCcw(stBlinkenMovie *pMovie);

include/BlinkenLib/BlinkenProto.h

View file @ 860e91b

@@ -10,12 +10,19 @@
 extern "C" {
 #endif
 
-typedef enum eBlinkenProto { BlinkenProtoNone, BlinkenProtoBlp,
-  BlinkenProtoEblp, BlinkenProtoMcuf
+typedef enum eBlinkenProto {
+  BlinkenProtoNone,
+  BlinkenProtoBlp,
+  BlinkenProtoEblp,
+  BlinkenProtoMcuf
 } etBlinkenProto;
 
-typedef enum eBlinkenPacket { BlinkenPacketNone, BlinkenPacketFrame,
-  BlinkenPacketRequest, BlinkenPacketEndRequest, BlinkenPacketStreamEnd
+typedef enum eBlinkenPacket {
+  BlinkenPacketNone,
+  BlinkenPacketFrame,
+  BlinkenPacketRequest,
+  BlinkenPacketEndRequest,
+  BlinkenPacketStreamEnd
 } etBlinkenPacket;
 
 int BlinkenProtoMakePacket(etBlinkenProto proto, etBlinkenPacket packet,
@@ -23,8 +30,7 @@ int BlinkenProtoMakePacket(etBlinkenProto proto, etBlinkenPacket packet,
 // returns length or -1 on error
 
 void BlinkenProtoDetectPacket(const char *pData, int length,
-                              etBlinkenProto * pProto,
-                              etBlinkenPacket * pPacket);
+                              etBlinkenProto *pProto, etBlinkenPacket *pPacket);
 // returns protocol in *pProto if pProto not NULL
 // returns packet type in *pPacket if pPacket not NULL
 

src/BlinkenColorizer.c

View file @ 860e91b

@@ -10,8 +10,7 @@
 #include "Tools.h"
 
 unsigned char BlinkenColorizerSolid(int step, int channels, int y, int x,
-                                    int c)
-{
+                                    int c) {
   int substep, updown, chan;
   step %= channels * 2 * 254;
   substep = step % 254;
@@ -37,8 +36,7 @@ unsigned char BlinkenColorizerSolid(int step, int channels, int y, int x,
 }
 
 unsigned char BlinkenColorizerRainbow(int step, int channels, int y, int x,
-                                      int c)
-{
+                                      int c) {
   return BlinkenColorizerSolid(step + ((x + y) * 64), channels, y, x, c);
 }
 
@@ -56,8 +54,7 @@ static const BlinkenColorizingModeDesc BlinkenColorizingModeDescs[] = {
 
 // convert string to colorizing mode
 // returns colorizing mode (>= 0) or -1 on error
-int BlinkenColorizerStr2Mode(const char *str)
-{
+int BlinkenColorizerStr2Mode(const char *str) {
   unsigned int i;
   for (i = 0; i < arr_cnt(BlinkenColorizingModeDescs); i++)
     if (strcmp(str, BlinkenColorizingModeDescs[i].name) == 0)
@@ -68,17 +65,15 @@ int BlinkenColorizerStr2Mode(const char *str)
 }
 
 // convert colorizing mode to string
-const char *BlinkenColorizerMode2Str(int mode)
-{
+const char *BlinkenColorizerMode2Str(int mode) {
   if (mode < 0 || mode >= (int)arr_cnt(BlinkenColorizingModeDescs))
     return "(unknown)";
   return BlinkenColorizingModeDescs[mode].name;
 }
 
 // get color for colorizing
-unsigned char BlinkenColorizerGetColor(int channels, int mode, int step,
-                                       int y, int x, int c)
-{
+unsigned char BlinkenColorizerGetColor(int channels, int mode, int step, int y,
+                                       int x, int c) {
   if (mode < 0 || mode >= (int)arr_cnt(BlinkenColorizingModeDescs))
     return 255;
   return BlinkenColorizingModeDescs[mode].func(step, channels, y, x, c);

src/BlinkenFrame.c

View file @ 860e91b

@@ -7,13 +7,13 @@
 #include <stdlib.h>
 #include <string.h>
 #ifdef WIN32
-#include <winsock2.h>
 #include <windows.h>
+#include <winsock2.h>
 typedef WORD uint16_t;
 typedef DWORD uint32_t;
 #else
-#include <stdint.h>
 #include <netinet/in.h>
+#include <stdint.h>
 #endif
 
 #include <BlinkenLib/BlinkenColorizer.h>
@@ -32,9 +32,8 @@ struct sBlinkenFrame {
   unsigned char **ppData;
 };
 
-stBlinkenFrame *BlinkenFrameNew(int height, int width, int channels,
-                                int maxval, int duration)
-{
+stBlinkenFrame *BlinkenFrameNew(int height, int width, int channels, int maxval,
+                                int duration) {
   stBlinkenFrame *pFrame;
 
   if (height < BlinkenHeightMin)
@@ -68,8 +67,7 @@ stBlinkenFrame *BlinkenFrameNew(int height, int width, int channels,
   pFrame->maxval = maxval;
   pFrame->duration = duration;
 
-  pFrame->ppData =
-      (unsigned char **)BlinkenMalloc2D(height, width * channels,
+  pFrame->ppData = (unsigned char **)BlinkenMalloc2D(height, width * channels,
                                                      sizeof(unsigned char));
   if (pFrame->ppData == NULL) {
     free(pFrame);
@@ -79,17 +77,16 @@ stBlinkenFrame *BlinkenFrameNew(int height, int width, int channels,
   return pFrame;
 }
 
-stBlinkenFrame *BlinkenFrameClone(stBlinkenFrame *pSrcFrame)
-{
+stBlinkenFrame *BlinkenFrameClone(stBlinkenFrame *pSrcFrame) {
   int y, x, c, i;
   stBlinkenFrame *pFrame;
 
   if (pSrcFrame == NULL)
     return NULL;
 
-  pFrame = BlinkenFrameNew(pSrcFrame->height, pSrcFrame->width,
-                           pSrcFrame->channels, pSrcFrame->maxval,
-                           pSrcFrame->duration);
+  pFrame =
+      BlinkenFrameNew(pSrcFrame->height, pSrcFrame->width, pSrcFrame->channels,
+                      pSrcFrame->maxval, pSrcFrame->duration);
   if (pFrame == NULL)
     return NULL;
 
@@ -101,8 +98,7 @@ stBlinkenFrame *BlinkenFrameClone(stBlinkenFrame *pSrcFrame)
   return pFrame;
 }
 
-void BlinkenFrameFree(stBlinkenFrame *pFrame)
-{
+void BlinkenFrameFree(stBlinkenFrame *pFrame) {
   if (pFrame == NULL)
     return;
 
@@ -110,8 +106,7 @@ void BlinkenFrameFree(stBlinkenFrame *pFrame)
   free(pFrame);
 }
 
-void BlinkenFrameClear(stBlinkenFrame *pFrame)
-{
+void BlinkenFrameClear(stBlinkenFrame *pFrame) {
   int y, x, c, i;
 
   if (pFrame == NULL)
@@ -123,48 +118,42 @@ void BlinkenFrameClear(stBlinkenFrame *pFrame)
         pFrame->ppData[y][i] = 0;
 }
 
-int BlinkenFrameGetHeight(stBlinkenFrame *pFrame)
-{
+int BlinkenFrameGetHeight(stBlinkenFrame *pFrame) {
   if (pFrame == NULL)
     return 0;
 
   return pFrame->height;
 }
 
-int BlinkenFrameGetWidth(stBlinkenFrame *pFrame)
-{
+int BlinkenFrameGetWidth(stBlinkenFrame *pFrame) {
   if (pFrame == NULL)
     return 0;
 
   return pFrame->width;
 }
 
-int BlinkenFrameGetChannels(stBlinkenFrame *pFrame)
-{
+int BlinkenFrameGetChannels(stBlinkenFrame *pFrame) {
   if (pFrame == NULL)
     return 0;
 
   return pFrame->channels;
 }
 
-int BlinkenFrameGetMaxval(stBlinkenFrame *pFrame)
-{
+int BlinkenFrameGetMaxval(stBlinkenFrame *pFrame) {
   if (pFrame == NULL)
     return 0;
 
   return pFrame->maxval;
 }
 
-int BlinkenFrameGetDuration(stBlinkenFrame *pFrame)
-{
+int BlinkenFrameGetDuration(stBlinkenFrame *pFrame) {
   if (pFrame == NULL)
     return 0;
 
   return pFrame->duration;
 }
 
-void BlinkenFrameSetDuration(stBlinkenFrame *pFrame, int duration)
-{
+void BlinkenFrameSetDuration(stBlinkenFrame *pFrame, int duration) {
   if (pFrame == NULL)
     return;
 
@@ -177,22 +166,18 @@ void BlinkenFrameSetDuration(stBlinkenFrame *pFrame, int duration)
 }
 
 unsigned char BlinkenFrameGetPixel(stBlinkenFrame *pFrame, int y, int x,
-                                   int c)
-{
-  if (pFrame == NULL ||
-      y < 0 || y >= pFrame->height ||
-      x < 0 || x >= pFrame->width || c < 0 || c >= pFrame->channels)
+                                   int c) {
+  if (pFrame == NULL || y < 0 || y >= pFrame->height || x < 0 ||
+      x >= pFrame->width || c < 0 || c >= pFrame->channels)
     return 0;
 
   return pFrame->ppData[y][x * pFrame->channels + c];
 }
 
 void BlinkenFrameSetPixel(stBlinkenFrame *pFrame, int y, int x, int c,
-                          unsigned char val)
-{
-  if (pFrame == NULL ||
-      y < 0 || y >= pFrame->height ||
-      x < 0 || x >= pFrame->width || c < 0 || c >= pFrame->channels)
+                          unsigned char val) {
+  if (pFrame == NULL || y < 0 || y >= pFrame->height || x < 0 ||
+      x >= pFrame->width || c < 0 || c >= pFrame->channels)
     return;
 
   if (val > pFrame->maxval)
@@ -200,12 +185,11 @@ void BlinkenFrameSetPixel(stBlinkenFrame *pFrame, int y, int x, int c,
   pFrame->ppData[y][x * pFrame->channels + c] = val;
 }
 
-unsigned long BlinkenFrameGetColor(stBlinkenFrame *pFrame, int y, int x)
-{
+unsigned long BlinkenFrameGetColor(stBlinkenFrame *pFrame, int y, int x) {
   int i;
 
-  if (pFrame == NULL ||
-      y < 0 || y >= pFrame->height || x < 0 || x >= pFrame->width)
+  if (pFrame == NULL || y < 0 || y >= pFrame->height || x < 0 ||
+      x >= pFrame->width)
     return 0;
 
   i = x * pFrame->channels;
@@ -213,41 +197,40 @@ unsigned long BlinkenFrameGetColor(stBlinkenFrame *pFrame, int y, int x)
   if (pFrame->channels == 1)
     return (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
              pFrame->maxval / 2) /
-            pFrame->
-            maxval) << 16 | (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
+            pFrame->maxval)
+               << 16 |
+           (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
              pFrame->maxval / 2) /
-                             pFrame->maxval) << 8 | (((unsigned long)
-                                                      pFrame->ppData[y][i +
-                                                                        0] *
-                                                      255 +
+            pFrame->maxval)
+               << 8 |
+           (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
              pFrame->maxval / 2) /
             pFrame->maxval);
   if (pFrame->channels == 2)
     return (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
              pFrame->maxval / 2) /
-            pFrame->
-            maxval) << 16 | (((unsigned long)pFrame->ppData[y][i + 1] * 255 +
-                              pFrame->maxval / 2) / pFrame->maxval) << 8;
-  return (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
-           pFrame->maxval / 2) /
-          pFrame->maxval) << 16 | (((unsigned long)pFrame->ppData[y][i + 1] *
-                                    255 +
+            pFrame->maxval)
+               << 16 |
+           (((unsigned long)pFrame->ppData[y][i + 1] * 255 +
              pFrame->maxval / 2) /
-                                   pFrame->maxval) << 8 | (((unsigned long)
-                                                            pFrame->ppData[y]
-                                                            [i + 2] * 255 +
-                                                            pFrame->maxval /
-                                                            2) /
+            pFrame->maxval)
+               << 8;
+  return (((unsigned long)pFrame->ppData[y][i + 0] * 255 + pFrame->maxval / 2) /
+          pFrame->maxval)
+             << 16 |
+         (((unsigned long)pFrame->ppData[y][i + 1] * 255 + pFrame->maxval / 2) /
+          pFrame->maxval)
+             << 8 |
+         (((unsigned long)pFrame->ppData[y][i + 2] * 255 + pFrame->maxval / 2) /
           pFrame->maxval);
 }
 
 void BlinkenFrameSetColor(stBlinkenFrame *pFrame, int y, int x,
-                          unsigned long color)
-{
+                          unsigned long color) {
   int i, alpha, alpha_, c;
 
-  if (pFrame == NULL ||
-      y < 0 || y >= pFrame->height || x < 0 || x >= pFrame->width)
+  if (pFrame == NULL || y < 0 || y >= pFrame->height || x < 0 ||
+      x >= pFrame->width)
     return;
 
   i = x * pFrame->channels;
@@ -256,34 +239,33 @@ void BlinkenFrameSetColor(stBlinkenFrame *pFrame, int y, int x,
   alpha_ = 255 - alpha;
   if (pFrame->channels >= 1)
     pFrame->ppData[y][i + 0] =
-        (unsigned
-         char)((((((color >> 16) & 0xFF) * pFrame->maxval +
-                  127) / 255) * alpha + (unsigned long)pFrame->ppData[y][i +
-                                                                         0] *
-                alpha_) / 255);
+        (unsigned char)((((((color >> 16) & 0xFF) * pFrame->maxval + 127) /
+                          255) *
+                             alpha +
+                         (unsigned long)pFrame->ppData[y][i + 0] * alpha_) /
+                        255);
   if (pFrame->channels >= 2)
     pFrame->ppData[y][i + 1] =
-        (unsigned
-         char)((((((color >> 8) & 0xFF) * pFrame->maxval +
-                  127) / 255) * alpha + (unsigned long)pFrame->ppData[y][i +
-                                                                         1] *
-                alpha_) / 255);
+        (unsigned char)((((((color >> 8) & 0xFF) * pFrame->maxval + 127) /
+                          255) *
+                             alpha +
+                         (unsigned long)pFrame->ppData[y][i + 1] * alpha_) /
+                        255);
   if (pFrame->channels >= 3)
     pFrame->ppData[y][i + 2] =
-        (unsigned
-         char)(((((color & 0xFF) * pFrame->maxval + 127) / 255) * alpha +
-                (unsigned long)pFrame->ppData[y][i + 2] * alpha_) / 255);
+        (unsigned char)(((((color & 0xFF) * pFrame->maxval + 127) / 255) *
+                             alpha +
+                         (unsigned long)pFrame->ppData[y][i + 2] * alpha_) /
+                        255);
   for (c = 3; c < pFrame->channels; c++)
-    pFrame->ppData[y][i + c] = (unsigned char)((0 + (unsigned long)
-                                                pFrame->ppData[y][i +
-                                                                  c] *
-                                                alpha_) / 255);
+    pFrame->ppData[y][i + c] =
+        (unsigned char)((0 + (unsigned long)pFrame->ppData[y][i + c] * alpha_) /
+                        255);
 }
 
-void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame,
-                              int y, int dy, int x, int dx, int c, int dc,
-                              unsigned char *pData)
-{
+void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame, int y, int dy,
+                              int x, int dx, int c, int dc,
+                              unsigned char *pData) {
   int height, width, channels;
   unsigned char const **ppFrameData;
   int sy, ey, iy, sx, ex, ix, sc, ec, ic; // start/end/index x/y/channel
@@ -309,10 +291,10 @@ void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame,
   ec = c + dc > channels ? channels - c : dc;
 
   // get pixel data
-  for (iy = sy, fy = y, biy = (sy * dx + sx) * dc + sc;
-       iy < ey; ++iy, ++fy, biy += dx * dc) {
-    for (ix = sx, fix = x * channels + c, bix = biy;
-         ix < ex; ++ix, fix += channels, bix += dc) {
+  for (iy = sy, fy = y, biy = (sy * dx + sx) * dc + sc; iy < ey;
+       ++iy, ++fy, biy += dx * dc) {
+    for (ix = sx, fix = x * channels + c, bix = biy; ix < ex;
+         ++ix, fix += channels, bix += dc) {
       for (ic = sc, fic = fix, bic = bix; ic < ec; ++ic, ++fic, ++bic) {
         pData[bic] = ppFrameData[fy][fic];
       }
@@ -320,10 +302,9 @@ void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame,
   }
 }
 
-void BlinkenFrameSetPixelData(stBlinkenFrame *pFrame,
-                              int y, int dy, int x, int dx, int c, int dc,
-                              unsigned char const *pData)
-{
+void BlinkenFrameSetPixelData(stBlinkenFrame *pFrame, int y, int dy, int x,
+                              int dx, int c, int dc,
+                              unsigned char const *pData) {
   int height, width, channels;
   unsigned char maxval;
   unsigned char **ppFrameData;
@@ -352,10 +333,10 @@ void BlinkenFrameSetPixelData(stBlinkenFrame *pFrame,
   ec = c + dc > channels ? channels - c : dc;
 
   // set pixel data
-  for (iy = sy, fy = y, biy = (sy * dx + sx) * dc + sc;
-       iy < ey; ++iy, ++fy, biy += dx * dc) {
-    for (ix = sx, fix = x * channels + c, bix = biy;
-         ix < ex; ++ix, fix += channels, bix += dc) {
+  for (iy = sy, fy = y, biy = (sy * dx + sx) * dc + sc; iy < ey;
+       ++iy, ++fy, biy += dx * dc) {
+    for (ix = sx, fix = x * channels + c, bix = biy; ix < ex;
+         ++ix, fix += channels, bix += dc) {
       for (ic = sc, fic = fix, bic = bix; ic < ec; ++ic, ++fic, ++bic) {
         value = pData[bic];
         ppFrameData[fy][fic] = value > maxval ? maxval : value;
@@ -413,8 +394,7 @@ int BlinkenFrameCompare(stBlinkenFrame *pFrame1, stBlinkenFrame *pFrame2)
     return 1;
 
   for (y = 0; y < pFrame1->height; y++) {
-    cmp =
-        memcmp(pFrame1->ppData[y], pFrame2->ppData[y],
+    cmp = memcmp(pFrame1->ppData[y], pFrame2->ppData[y],
                  pFrame1->width * pFrame2->channels);
     if (cmp != 0)
       return cmp;
@@ -424,9 +404,8 @@ int BlinkenFrameCompare(stBlinkenFrame *pFrame1, stBlinkenFrame *pFrame2)
 }
 
 static void BlinkenFramePadCrop(stBlinkenFrame *pFrame, int height, int width,
-                                int channels, int maxval,
-                                int emptyY, int emptyX, int skipY, int skipX)
-{
+                                int channels, int maxval, int emptyY,
+                                int emptyX, int skipY, int skipX) {
   unsigned char **ppData;
   int y, x, c, i, j;
   int rangeY, rangeX;
@@ -453,8 +432,8 @@ static void BlinkenFramePadCrop(stBlinkenFrame *pFrame, int height, int width,
     maxval = BlinkenMaxvalMax;
 
   if (height == pFrame->height && width == pFrame->width &&
-      channels == pFrame->channels && maxval == pFrame->maxval &&
-      emptyX == 0 && emptyY == 0 && skipY == 0 && skipX == 0)
+      channels == pFrame->channels && maxval == pFrame->maxval && emptyX == 0 &&
+      emptyY == 0 && skipY == 0 && skipX == 0)
     return;
 
   // allocate new data array
@@ -497,9 +476,10 @@ static void BlinkenFramePadCrop(stBlinkenFrame *pFrame, int height, int width,
       {
         for (c = 0; c < pFrame->channels; c++, i++, j++)
           ppData[emptyY + y][j] =
-              (unsigned
-               char)(((unsigned long)pFrame->ppData[skipY + y][i] * maxval +
-                      pFrame->maxval / 2) / pFrame->maxval);
+              (unsigned char)(((unsigned long)pFrame->ppData[skipY + y][i] *
+                                   maxval +
+                               pFrame->maxval / 2) /
+                              pFrame->maxval);
         for (; c < channels; c++, j++)
           ppData[emptyY + y][j] = ppData[emptyY + y][j - 1];
       } else // remove channels: merge leftover channels with last kept
@@ -508,9 +488,10 @@ static void BlinkenFramePadCrop(stBlinkenFrame *pFrame, int height, int width,
         val = 0;
         for (c = 0; c < channels - 1; c++, i++, j++)
           ppData[emptyY + y][j] =
-              (unsigned
-               char)(((unsigned long)pFrame->ppData[skipY + y][i] * maxval +
-                      pFrame->maxval / 2) / pFrame->maxval);
+              (unsigned char)(((unsigned long)pFrame->ppData[skipY + y][i] *
+                                   maxval +
+                               pFrame->maxval / 2) /
+                              pFrame->maxval);
         for (c = channels - 1; c < pFrame->channels; c++, i++)
           val += (unsigned long)pFrame->ppData[skipY + y][i];
         div = pFrame->maxval * (pFrame->channels - channels + 1);
@@ -529,8 +510,7 @@ static void BlinkenFramePadCrop(stBlinkenFrame *pFrame, int height, int width,
 }
 
 void BlinkenFrameResize(stBlinkenFrame *pFrame, int height, int width,
-                        int channels, int maxval)
-{
+                        int channels, int maxval) {
   int emptyY, emptyX, skipY, skipX;
 
   if (pFrame == NULL)
@@ -574,13 +554,12 @@ void BlinkenFrameResize(stBlinkenFrame *pFrame, int height, int width,
   }
 
   // resize frame with help of calculated parameters
-  BlinkenFramePadCrop(pFrame, height, width, channels, maxval,
-                      emptyY, emptyX, skipY, skipX);
+  BlinkenFramePadCrop(pFrame, height, width, channels, maxval, emptyY, emptyX,
+                      skipY, skipX);
 }
 
-void BlinkenFrameCrop(stBlinkenFrame *pFrame, int top, int left,
-                      int height, int width)
-{
+void BlinkenFrameCrop(stBlinkenFrame *pFrame, int top, int left, int height,
+                      int width) {
   if (pFrame == NULL)
     return;
 
@@ -601,8 +580,8 @@ void BlinkenFrameCrop(stBlinkenFrame *pFrame, int top, int left,
   if (width > pFrame->width - left)
     width = pFrame->width - left;
 
-  if (top == 0 && left == 0 &&
-      height == pFrame->height && width == pFrame->width)
+  if (top == 0 && left == 0 && height == pFrame->height &&
+      width == pFrame->width)
     return;
 
   // crop frame with help of calculated parameters
@@ -610,8 +589,7 @@ void BlinkenFrameCrop(stBlinkenFrame *pFrame, int top, int left,
                       0, 0, top, left);
 }
 
-void BlinkenFrameScale(stBlinkenFrame *pFrame, int height, int width)
-{
+void BlinkenFrameScale(stBlinkenFrame *pFrame, int height, int width) {
   unsigned char **ppData;
   double scaleHor, scaleVer, ox, oy, ox1, oy1, val;
   int chans, c, nx, ny, x, y, oxi, oyi, ox1i, oy1i;
@@ -635,8 +613,7 @@ void BlinkenFrameScale(stBlinkenFrame *pFrame, int height, int width)
   scaleVer = (double)height / (double)pFrame->height;
 
   // allocate new data array
-  ppData =
-      (unsigned char **)BlinkenMalloc2D(height, width * pFrame->channels,
+  ppData = (unsigned char **)BlinkenMalloc2D(height, width * pFrame->channels,
                                              sizeof(unsigned char));
   if (ppData == NULL)
     return;
@@ -666,10 +643,9 @@ void BlinkenFrameScale(stBlinkenFrame *pFrame, int height, int width)
             } else // one line of source pixels
             {
               val =
-                  (double)pFrame->ppData[oyi][oxi * chans + c] * (1 - ox +
-                                                                  oxi)
-                  + (double)pFrame->ppData[oyi][ox1i * chans + c] * (ox1 -
-                                                                     ox1i);
+                  (double)pFrame->ppData[oyi][oxi * chans + c] *
+                      (1 - ox + oxi) +
+                  (double)pFrame->ppData[oyi][ox1i * chans + c] * (ox1 - ox1i);
               for (x = oxi + 1; x < ox1i; x++)
                 val += (double)pFrame->ppData[oyi][x * chans + c];
               val /= ox1 - ox;
@@ -678,42 +654,33 @@ void BlinkenFrameScale(stBlinkenFrame *pFrame, int height, int width)
           {
             if (oxi == ox1i) {
               val =
-                  (double)pFrame->ppData[oyi][oxi * chans + c] * (1 - oy +
-                                                                  oyi)
-                  + (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 -
-                                                                     oy1i);
+                  (double)pFrame->ppData[oyi][oxi * chans + c] *
+                      (1 - oy + oyi) +
+                  (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 - oy1i);
               for (y = oyi + 1; y < oy1i; y++)
                 val += (double)pFrame->ppData[y][oxi * chans + c];
               val /= oy1 - oy;
             } else // rectangle of source pixels
             {
-              val =
-                  (double)pFrame->ppData[oyi][oxi * chans + c] * (1 - oy +
-                                                                  oyi) * (1 -
-                                                                          ox +
-                                                                          oxi)
-                  + (double)pFrame->ppData[oyi][ox1i * chans + c] * (1 - oy +
-                                                                     oyi) *
-                  (ox1 - ox1i)
-                  + (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 -
-                                                                     oy1i) *
-                  (1 - ox + oxi)
-                  + (double)pFrame->ppData[oy1i][ox1i * chans + c] * (oy1 -
-                                                                      oy1i) *
-                  (ox1 - ox1i);
+              val = (double)pFrame->ppData[oyi][oxi * chans + c] *
+                        (1 - oy + oyi) * (1 - ox + oxi) +
+                    (double)pFrame->ppData[oyi][ox1i * chans + c] *
+                        (1 - oy + oyi) * (ox1 - ox1i) +
+                    (double)pFrame->ppData[oy1i][oxi * chans + c] *
+                        (oy1 - oy1i) * (1 - ox + oxi) +
+                    (double)pFrame->ppData[oy1i][ox1i * chans + c] *
+                        (oy1 - oy1i) * (ox1 - ox1i);
               for (y = oyi + 1; y < oy1i; y++) {
                 val +=
-                    (double)pFrame->ppData[y][oxi * chans + c] * (1 - ox +
-                                                                  oxi)
-                    + (double)pFrame->ppData[y][ox1i * chans + c] * (ox1 -
-                                                                     ox1i);
+                    (double)pFrame->ppData[y][oxi * chans + c] *
+                        (1 - ox + oxi) +
+                    (double)pFrame->ppData[y][ox1i * chans + c] * (ox1 - ox1i);
               }
               for (x = oxi + 1; x < ox1i; x++) {
                 val +=
-                    (double)pFrame->ppData[oyi][x * chans + c] * (1 - oy +
-                                                                  oyi)
-                    + (double)pFrame->ppData[oy1i][x * chans + c] * (oy1 -
-                                                                     oy1i);
+                    (double)pFrame->ppData[oyi][x * chans + c] *
+                        (1 - oy + oyi) +
+                    (double)pFrame->ppData[oy1i][x * chans + c] * (oy1 - oy1i);
               }
               for (y = oyi + 1; y < oy1i; y++)
                 for (x = oxi + 1; x < ox1i; x++)
@@ -734,8 +701,7 @@ void BlinkenFrameScale(stBlinkenFrame *pFrame, int height, int width)
 }
 
 void BlinkenFrameColorize(stBlinkenFrame *pFrame, int channels, int mode,
-                          int step)
-{
+                          int step) {
   unsigned char **ppData;
   int y, x, c, i, j;
   unsigned int val;
@@ -749,10 +715,8 @@ void BlinkenFrameColorize(stBlinkenFrame *pFrame, int channels, int mode,
     channels = BlinkenMaxvalMax;
 
   // allocate new data array
-  ppData =
-      (unsigned char **)BlinkenMalloc2D(pFrame->height,
-                                        pFrame->width * channels,
-                                        sizeof(unsigned char));
+  ppData = (unsigned char **)BlinkenMalloc2D(
+      pFrame->height, pFrame->width * channels, sizeof(unsigned char));
   if (ppData == NULL)
     return;
   for (y = 0; y < pFrame->height; y++)
@@ -786,9 +750,8 @@ void BlinkenFrameColorize(stBlinkenFrame *pFrame, int channels, int mode,
 }
 
 void BlinkenFrameCopyRect(stBlinkenFrame *pDest, int destY, int destX,
-                          stBlinkenFrame *pSrc, int srcY, int srcX,
-                          int height, int width)
-{
+                          stBlinkenFrame *pSrc, int srcY, int srcX, int height,
+                          int width) {
   int bFreeSrc = 0;
   int destI, srcI, y, x, c, dy, sy, di, si;
 
@@ -800,8 +763,8 @@ void BlinkenFrameCopyRect(stBlinkenFrame *pDest, int destY, int destX,
     pSrc = BlinkenFrameClone(pSrc);
     if (pSrc == NULL)
       return;
-    BlinkenFrameResize(pSrc, pSrc->height, pSrc->width,
-                       pDest->channels, pDest->maxval);
+    BlinkenFrameResize(pSrc, pSrc->height, pSrc->width, pDest->channels,
+                       pDest->maxval);
     bFreeSrc = 1; // source is now a temporary copy that needs to be freed
   }
 
@@ -852,8 +815,7 @@ void BlinkenFrameCopyRect(stBlinkenFrame *pDest, int destY, int destX,
     BlinkenFrameFree(pSrc);
 }
 
-void BlinkenFrameRotateCw(stBlinkenFrame *pFrame)
-{
+void BlinkenFrameRotateCw(stBlinkenFrame *pFrame) {
   int height, width, channels, y, x, c, i, j;
   unsigned char **ppData;
 
@@ -864,8 +826,7 @@ void BlinkenFrameRotateCw(stBlinkenFrame *pFrame)
   height = pFrame->width;
   width = pFrame->height;
   channels = pFrame->channels;
-  ppData =
-      (unsigned char **)BlinkenMalloc2D(height, width * channels,
+  ppData = (unsigned char **)BlinkenMalloc2D(height, width * channels,
                                              sizeof(unsigned char));
   if (ppData == NULL)
     return;
@@ -886,8 +847,7 @@ void BlinkenFrameRotateCw(stBlinkenFrame *pFrame)
   pFrame->ppData = ppData;
 }
 
-void BlinkenFrameRotateCcw(stBlinkenFrame *pFrame)
-{
+void BlinkenFrameRotateCcw(stBlinkenFrame *pFrame) {
   int height, width, channels, y, x, c, i, j;
   unsigned char **ppData;
 
@@ -898,8 +858,7 @@ void BlinkenFrameRotateCcw(stBlinkenFrame *pFrame)
   height = pFrame->width;
   width = pFrame->height;
   channels = pFrame->channels;
-  ppData =
-      (unsigned char **)BlinkenMalloc2D(height, width * channels,
+  ppData = (unsigned char **)BlinkenMalloc2D(height, width * channels,
                                              sizeof(unsigned char));
   if (ppData == NULL)
     return;
@@ -920,16 +879,15 @@ void BlinkenFrameRotateCcw(stBlinkenFrame *pFrame)
   pFrame->ppData = ppData;
 }
 
-void BlinkenFrameRotateHalf(stBlinkenFrame *pFrame)
-{
+void BlinkenFrameRotateHalf(stBlinkenFrame *pFrame) {
   int y1, y2, x1, x2, c, i1, i2;
 
   if (pFrame == NULL)
     return;
 
   for (y1 = 0, y2 = pFrame->height - 1; y1 < pFrame->height; y1++, y2--) {
-    for (x1 = 0, x2 = pFrame->width - 1,
-         i1 = 0, i2 = (pFrame->width - 1) * pFrame->channels;
+    for (x1 = 0, x2 = pFrame->width - 1, i1 = 0,
+        i2 = (pFrame->width - 1) * pFrame->channels;
          x1 < pFrame->width / 2; x1++, x2--, i2 -= 2 * pFrame->channels) {
       for (c = 0; c < pFrame->channels; c++, i1++, i2++) {
         unsigned char tmp = pFrame->ppData[y1][i1];
@@ -940,16 +898,15 @@ void BlinkenFrameRotateHalf(stBlinkenFrame *pFrame)
   }
 }
 
-void BlinkenFrameMirrorHor(stBlinkenFrame *pFrame)
-{
+void BlinkenFrameMirrorHor(stBlinkenFrame *pFrame) {
   int y, x1, x2, c, i1, i2;
 
   if (pFrame == NULL)
     return;
 
   for (y = 0; y < pFrame->height; y++) {
-    for (x1 = 0, x2 = pFrame->width - 1,
-         i1 = 0, i2 = (pFrame->width - 1) * pFrame->channels;
+    for (x1 = 0, x2 = pFrame->width - 1, i1 = 0,
+        i2 = (pFrame->width - 1) * pFrame->channels;
          x1 < pFrame->width / 2; x1++, x2--, i2 -= 2 * pFrame->channels) {
       for (c = 0; c < pFrame->channels; c++, i1++, i2++) {
         unsigned char tmp = pFrame->ppData[y][i1];
@@ -960,8 +917,7 @@ void BlinkenFrameMirrorHor(stBlinkenFrame *pFrame)
   }
 }
 
-void BlinkenFrameMirrorVer(stBlinkenFrame *pFrame)
-{
+void BlinkenFrameMirrorVer(stBlinkenFrame *pFrame) {
   int y1, y2, x, c, i;
 
   if (pFrame == NULL)
@@ -978,8 +934,7 @@ void BlinkenFrameMirrorVer(stBlinkenFrame *pFrame)
   }
 }
 
-void BlinkenFrameMirrorDiag(stBlinkenFrame *pFrame)
-{
+void BlinkenFrameMirrorDiag(stBlinkenFrame *pFrame) {
   int height, width, channels, y, x, c, i, j;
   unsigned char **ppData;
 
@@ -990,8 +945,7 @@ void BlinkenFrameMirrorDiag(stBlinkenFrame *pFrame)
   height = pFrame->width;
   width = pFrame->height;
   channels = pFrame->channels;
-  ppData =
-      (unsigned char **)BlinkenMalloc2D(height, width * channels,
+  ppData = (unsigned char **)BlinkenMalloc2D(height, width * channels,
                                              sizeof(unsigned char));
   if (ppData == NULL)
     return;
@@ -1012,8 +966,7 @@ void BlinkenFrameMirrorDiag(stBlinkenFrame *pFrame)
   pFrame->ppData = ppData;
 }
 
-void BlinkenFrameMirrorDiag2(stBlinkenFrame *pFrame)
-{
+void BlinkenFrameMirrorDiag2(stBlinkenFrame *pFrame) {
   int height, width, channels, y, x, c, i, j;
   unsigned char **ppData;
 
@@ -1024,8 +977,7 @@ void BlinkenFrameMirrorDiag2(stBlinkenFrame *pFrame)
   height = pFrame->width;
   width = pFrame->height;
   channels = pFrame->channels;
-  ppData =
-      (unsigned char **)BlinkenMalloc2D(height, width * channels,
+  ppData = (unsigned char **)BlinkenMalloc2D(height, width * channels,
                                              sizeof(unsigned char));
   if (ppData == NULL)
     return;
@@ -1046,8 +998,7 @@ void BlinkenFrameMirrorDiag2(stBlinkenFrame *pFrame)
   pFrame->ppData = ppData;
 }
 
-char *BlinkenFrameToString(stBlinkenFrame *pFrame)
-{
+char *BlinkenFrameToString(stBlinkenFrame *pFrame) {
   int size, y, x, c, i;
   char *str, *ptr;
   unsigned long val;
@@ -1097,14 +1048,14 @@ int BlinkenFrameToNetwork(stBlinkenFrame *pFrame, etBlinkenProto proto,
 
   case BlinkenProtoBlp:
     // buffer too short
-    if (maxLength < (int)sizeof(stBlinkenProtoBlpHdr) + pFrame->height * pFrame->width)
+    if (maxLength <
+        (int)sizeof(stBlinkenProtoBlpHdr) + pFrame->height * pFrame->width)
       return -1;
     // build header
     ((stBlinkenProtoBlpHdr *)pData)->magic = htonl(BlinkenProtoBlpMagic);
     ((stBlinkenProtoBlpHdr *)pData)->frameNo = htonl(0);
     ((stBlinkenProtoBlpHdr *)pData)->width = htons((uint16_t)pFrame->width);
-    ((stBlinkenProtoBlpHdr *) pData)->height =
-        htons((uint16_t) pFrame->height);
+    ((stBlinkenProtoBlpHdr *)pData)->height = htons((uint16_t)pFrame->height);
     i = sizeof(stBlinkenProtoBlpHdr); // put data into packet
     for (y = 0; y < pFrame->height; y++) {
       for (x = 0, j = 0; x < pFrame->width; x++, i++) {
@@ -1119,15 +1070,14 @@ int BlinkenFrameToNetwork(stBlinkenFrame *pFrame, etBlinkenProto proto,
 
   case BlinkenProtoEblp:
     // buffer too short
-    if (maxLength < (int)sizeof(stBlinkenProtoEblpHdr) + pFrame->height * pFrame->width)
+    if (maxLength <
+        (int)sizeof(stBlinkenProtoEblpHdr) + pFrame->height * pFrame->width)
       return -1;
     // build header
     ((stBlinkenProtoEblpHdr *)pData)->magic = htonl(BlinkenProtoEblpMagic);
     ((stBlinkenProtoEblpHdr *)pData)->frameNo = htonl(0);
-    ((stBlinkenProtoEblpHdr *) pData)->width =
-        htons((uint16_t) pFrame->width);
-    ((stBlinkenProtoEblpHdr *) pData)->height =
-        htons((uint16_t) pFrame->height);
+    ((stBlinkenProtoEblpHdr *)pData)->width = htons((uint16_t)pFrame->width);
+    ((stBlinkenProtoEblpHdr *)pData)->height = htons((uint16_t)pFrame->height);
     i = sizeof(stBlinkenProtoEblpHdr); // put data into packet
     for (y = 0; y < pFrame->height; y++) {
       for (x = 0, j = 0; x < pFrame->width; x++, i++) {
@@ -1135,7 +1085,8 @@ int BlinkenFrameToNetwork(stBlinkenFrame *pFrame, etBlinkenProto proto,
         for (c = 0; c < pFrame->channels; c++, j++)
           val += pFrame->ppData[y][j];
         val /= pFrame->channels;
-        pData[i] = (pFrame->maxval == 255 ? (unsigned char)val
+        pData[i] = (pFrame->maxval == 255
+                        ? (unsigned char)val
                         : (unsigned char)((val * 255 + pFrame->maxval / 2) /
                                           pFrame->maxval));
       }
@@ -1144,18 +1095,16 @@ int BlinkenFrameToNetwork(stBlinkenFrame *pFrame, etBlinkenProto proto,
 
   case BlinkenProtoMcuf:
     // buffer too short
-    if (maxLength < (int)sizeof(stBlinkenProtoMcufHdr) + pFrame->height * pFrame->width * pFrame->channels)
+    if (maxLength < (int)sizeof(stBlinkenProtoMcufHdr) +
+                        pFrame->height * pFrame->width * pFrame->channels)
       return -1;
     // build header
     ((stBlinkenProtoMcufHdr *)pData)->magic = htonl(BlinkenProtoMcufMagic);
-    ((stBlinkenProtoMcufHdr *) pData)->height =
-        htons((uint16_t) pFrame->height);
-    ((stBlinkenProtoMcufHdr *) pData)->width =
-        htons((uint16_t) pFrame->width);
+    ((stBlinkenProtoMcufHdr *)pData)->height = htons((uint16_t)pFrame->height);
+    ((stBlinkenProtoMcufHdr *)pData)->width = htons((uint16_t)pFrame->width);
     ((stBlinkenProtoMcufHdr *)pData)->channels =
         htons((uint16_t)pFrame->channels);
-    ((stBlinkenProtoMcufHdr *) pData)->maxval =
-        htons((uint16_t) pFrame->maxval);
+    ((stBlinkenProtoMcufHdr *)pData)->maxval = htons((uint16_t)pFrame->maxval);
     i = sizeof(stBlinkenProtoMcufHdr); // put data into packet
     for (y = 0; y < pFrame->height; y++)
       for (x = 0, j = 0; x < pFrame->width; x++)
@@ -1177,8 +1125,7 @@ stBlinkenFrame *BlinkenFrameFromNetwork(const char *pData, int length,
   int height, width, channels, maxval, y, x, c, i, j;
 
   if (length >= (int)sizeof(stBlinkenProtoBlpHdr) &&
-      ((stBlinkenProtoBlpHdr *) pData)->magic == htonl(BlinkenProtoBlpMagic))
-  {
+      ((stBlinkenProtoBlpHdr *)pData)->magic == htonl(BlinkenProtoBlpMagic)) {
     if (pProto != NULL) // return protocol
       *pProto = BlinkenProtoBlp;
     // get header data
@@ -1204,8 +1151,7 @@ stBlinkenFrame *BlinkenFrameFromNetwork(const char *pData, int length,
   }
 
   if (length >= (int)sizeof(stBlinkenProtoEblpHdr) &&
-      ((stBlinkenProtoEblpHdr *) pData)->magic ==
-      htonl(BlinkenProtoEblpMagic)) {
+      ((stBlinkenProtoEblpHdr *)pData)->magic == htonl(BlinkenProtoEblpMagic)) {
     if (pProto != NULL) // return protocol
       *pProto = BlinkenProtoEblp;
     // get header data
@@ -1231,8 +1177,7 @@ stBlinkenFrame *BlinkenFrameFromNetwork(const char *pData, int length,
   }
 
   if (length >= (int)sizeof(stBlinkenProtoMcufHdr) &&
-      ((stBlinkenProtoMcufHdr *) pData)->magic ==
-      htonl(BlinkenProtoMcufMagic)) {
+      ((stBlinkenProtoMcufHdr *)pData)->magic == htonl(BlinkenProtoMcufMagic)) {
     if (pProto != NULL) // return protocol
       *pProto = BlinkenProtoMcuf;
     // get header data

src/BlinkenGif.c

View file @ 860e91b

@@ -6,9 +6,9 @@
 #include <gif_lib.h>
 #include <stdlib.h>
 
-#include <BlinkenLib/config.h>
 #include <BlinkenLib/BlinkenFrame.h>
 #include <BlinkenLib/BlinkenMovie.h>
+#include <BlinkenLib/config.h>
 
 #include "BlinkenConstants.h"
 #include "BlinkenGif.h"
@@ -22,8 +22,7 @@
 // get color from GIF color map
 static void BlinkenGifGetColor(ColorMapObject *pMap, int idx, int transparent,
                                unsigned char *r, unsigned char *g,
-                               unsigned char *b, unsigned char *t)
-{
+                               unsigned char *b, unsigned char *t) {
   if (transparent >= 0 && idx == transparent) {
     *t = 1;
   } else {
@@ -50,8 +49,7 @@ static void BlinkenGifGetColor(ColorMapObject *pMap, int idx, int transparent,
 
 // set pixel to GIF color
 static void BlinkenGifSetPixel(ColorMapObject *pMap, int idx, int transparent,
-                               stBlinkenFrame *pFrame, int y, int x)
-{
+                               stBlinkenFrame *pFrame, int y, int x) {
   unsigned char r, g, b, t;
 
   if (pFrame != NULL) {
@@ -65,17 +63,17 @@ static void BlinkenGifSetPixel(ColorMapObject *pMap, int idx, int transparent,
 }
 
 // load a GIF file as BlinkenMovie
-stBlinkenMovie *BlinkenGifLoad(const char *pFilename)
-{
+stBlinkenMovie *BlinkenGifLoad(const char *pFilename) {
   GifFileType *gif;
-  struct sPass { int ofs, stride; };
+  struct sPass {
+    int ofs, stride;
+  };
   static struct sPass const passes_linear[] = {{0, 1}, {0, 0}};
   static struct sPass const passes_interlaced[] = {
-    { 0, 8 }, { 4, 8 }, { 2, 4 }, { 1, 2 }
-  };
+      {0, 8}, {4, 8}, {2, 4}, {1, 2}};
   struct sPass const *pass;
-  int height, width, frameCnt, frameIdx, i, y, x, y1, x1,
-      bg, disposal, delay, transp, idx;
+  int height, width, frameCnt, frameIdx, i, y, x, y1, x1, bg, disposal, delay,
+      transp, idx;
   ColorMapObject *pGlobalMap, *pMap;
   SavedImage *pImg;
   GifImageDesc *pDesc;
@@ -158,8 +156,8 @@ stBlinkenMovie *BlinkenGifLoad(const char *pFilename)
     }
     for (pass = pDesc->Interlace ? passes_interlaced : passes_linear;
          pass->stride > 0; ++pass) {
-      for (y = pass->ofs, y1 = pDesc->Top + pass->ofs, i = 0;
-           y < pDesc->Height; y += pass->stride, y1 += pass->stride) {
+      for (y = pass->ofs, y1 = pDesc->Top + pass->ofs, i = 0; y < pDesc->Height;
+           y += pass->stride, y1 += pass->stride) {
         for (x = 0, x1 = pDesc->Left; x < pDesc->Width; ++x, ++x1, ++i) {
           idx = pImg->RasterBits[i];
           switch (disposal) {
@@ -206,11 +204,10 @@ stBlinkenMovie *BlinkenGifLoad(const char *pFilename)
   return pMovie;
 }
 
-int BlinkenGifSave(stBlinkenMovie *pMovie, const char *pFilename)
-{
+int BlinkenGifSave(stBlinkenMovie *pMovie, const char *pFilename) {
   GifFileType *gif;
-  int frameCnt, height, width, channels, maxval, channels_new, maxval_new,
-      r, g, b, i, frame, y, x, c, y1, x1, y2, x2, v, ret;
+  int frameCnt, height, width, channels, maxval, channels_new, maxval_new, r, g,
+      b, i, frame, y, x, c, y1, x1, y2, x2, v, ret;
   unsigned int delay;
   stBlinkenMovie *pOutMovie;
   stBlinkenFrame *pFrame, *pLast;
@@ -236,10 +233,18 @@ int BlinkenGifSave(stBlinkenMovie *pMovie, const char *pFilename)
   else
     channels_new = channels;
   switch (channels) {
-    case 1:  maxval_new = 255; break;
-    case 2:  maxval_new = 15;  break;
-    case 3:  maxval_new = 5;   break;
-    default: maxval_new = 255; break;
+  case 1:
+    maxval_new = 255;
+    break;
+  case 2:
+    maxval_new = 15;
+    break;
+  case 3:
+    maxval_new = 5;
+    break;
+  default:
+    maxval_new = 255;
+    break;
   }
   pOutMovie = BlinkenMovieClone(pMovie);
   if (pOutMovie == NULL)
@@ -308,7 +313,8 @@ int BlinkenGifSave(stBlinkenMovie *pMovie, const char *pFilename)
       for (g = 0; g <= maxval; ++g) {
         for (r = 0; r <= maxval; ++r) {
           gif->SColorMap->Colors[i].Red = ((int)r * 255 + maxval / 2) / maxval;
-            gif->SColorMap->Colors[i].Green = ((int)g * 255 + maxval / 2) / maxval;
+          gif->SColorMap->Colors[i].Green =
+              ((int)g * 255 + maxval / 2) / maxval;
           gif->SColorMap->Colors[i].Blue = ((int)b * 255 + maxval / 2) / maxval;
           ++i;
         }
@@ -351,10 +357,14 @@ int BlinkenGifSave(stBlinkenMovie *pMovie, const char *pFilename)
               break;
           }
           if (c < channels) { // change detected at x,y
-            if (y < y1) y1 = y;
-            if (x < x1) x1 = x;
-            if (y > y2) y2 = y;
-            if (x > x2) x2 = x;
+            if (y < y1)
+              y1 = y;
+            if (x < x1)
+              x1 = x;
+            if (y > y2)
+              y2 = y;
+            if (x > x2)
+              x2 = x;
           }
         } // for x
       }   // for y
@@ -382,8 +392,8 @@ int BlinkenGifSave(stBlinkenMovie *pMovie, const char *pFilename)
     pDesc->ColorMap = NULL;
 
     // allocate pixel buffer
-    pImg->RasterBits = calloc(pDesc->Width * pDesc->Height,
-                              sizeof(unsigned char));
+    pImg->RasterBits =
+        calloc(pDesc->Width * pDesc->Height, sizeof(unsigned char));
     if (pImg->RasterBits == NULL) {
       EGifCloseFile(gif GIF5_err);
       BlinkenMovieFree(pOutMovie);

src/BlinkenGif.h

View file @ 860e91b

@@ -6,9 +6,9 @@
 #ifndef INC_BlinkenLib_BlinkenGif
 #define INC_BlinkenLib_BlinkenGif
 
-#include <BlinkenLib/config.h>
 #include <BlinkenLib/BlinkenFrame.h>
 #include <BlinkenLib/BlinkenMovie.h>
+#include <BlinkenLib/config.h>
 
 #ifndef BLINKENLIB_CFG_GIF
 #error This file is to be used for GIF support only.

src/BlinkenMng.c

View file @ 860e91b

@@ -16,9 +16,9 @@
 #define MNG_SUPPORT_WRITE
 #include <libmng.h>
 
-#include <BlinkenLib/config.h>
 #include <BlinkenLib/BlinkenFrame.h>
 #include <BlinkenLib/BlinkenMovie.h>
+#include <BlinkenLib/config.h>
 
 #include "BlinkenConstants.h"
 #include "BlinkenMng.h"
@@ -36,33 +36,28 @@ typedef struct _BlMng_userdata {
   stBlinkenMovie *movie; // movie being created
 } BlMng_userdata;
 
-mng_ptr BlMng_alloc(mng_size_t iSize)
-{
+mng_ptr BlMng_alloc(mng_size_t iSize) {
   void *ptr = malloc(iSize);
   if (ptr != NULL)
     memset(ptr, 0, iSize);
   return (mng_ptr)ptr;
 }
 
-void BlMng_free(mng_ptr pPtr, mng_size_t __attribute__ ((unused)) iSize)
-{
+void BlMng_free(mng_ptr pPtr, mng_size_t __attribute__((unused)) iSize) {
   free(pPtr);
 }
 
-mng_bool BlMng_openstream(mng_handle __attribute__ ((unused)) hMNG)
-{
+mng_bool BlMng_openstream(mng_handle __attribute__((unused)) hMNG) {
   return MNG_TRUE;
 }
 
-mng_bool BlMng_closestream(mng_handle __attribute__ ((unused)) hMNG)
-{
+mng_bool BlMng_closestream(mng_handle __attribute__((unused)) hMNG) {
   return MNG_TRUE;
 }
 
 // read data from the open file
 mng_bool BlMng_readdata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,
-                        mng_uint32 * iRead)
-{
+                        mng_uint32 *iRead) {
   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);
   *iRead = fread(pBuf, 1, iSize, data->hFile);
   return MNG_TRUE;
@@ -70,8 +65,7 @@ mng_bool BlMng_readdata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,
 
 // write data to the open file
 mng_bool BlMng_writedata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,
-                         mng_uint32 * iWritten)
-{
+                         mng_uint32 *iWritten) {
   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);
   *iWritten = fwrite(pBuf, 1, iSize, data->hFile);
   return MNG_TRUE;
@@ -79,8 +73,7 @@ mng_bool BlMng_writedata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,
 
 // MNG library has processed the header information
 mng_bool BlMng_processheader(mng_handle hMNG, mng_uint32 iWidth,
-                             mng_uint32 iHeight)
-{
+                             mng_uint32 iHeight) {
   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);
 
   // free old canvas (in case there is already one)
@@ -113,8 +106,7 @@ mng_bool BlMng_processheader(mng_handle hMNG, mng_uint32 iWidth,
 }
 
 // get access to a line of the canvas
-mng_ptr BlMng_getcanvasline(mng_handle hMNG, mng_uint32 iLinenr)
-{
+mng_ptr BlMng_getcanvasline(mng_handle hMNG, mng_uint32 iLinenr) {
   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);
 
   // return pointer to line
@@ -125,20 +117,18 @@ mng_ptr BlMng_getcanvasline(mng_handle hMNG, mng_uint32 iLinenr)
 }
 
 // the MNG library thinks that (a part of) the canvas should be shown
-mng_bool BlMng_refresh(mng_handle __attribute__ ((unused)) hMNG, mng_uint32
-                       __attribute__ ((unused)) iX, mng_uint32
-                       __attribute__ ((unused)) iY, mng_uint32
-                       __attribute__ ((unused)) iWidth, mng_uint32
-                       __attribute__ ((unused)) iHeight)
-{
+mng_bool BlMng_refresh(mng_handle __attribute__((unused)) hMNG,
+                       mng_uint32 __attribute__((unused)) iX,
+                       mng_uint32 __attribute__((unused)) iY,
+                       mng_uint32 __attribute__((unused)) iWidth,
+                       mng_uint32 __attribute__((unused)) iHeight) {
   // nothing to do here for BlinkenLib as we are only converting and not
   // displaying
   return MNG_TRUE;
 }
 
 // the MNG library want to know how many milliseconds have passed
-mng_uint32 BlMng_gettickcount(mng_handle hMNG)
-{
+mng_uint32 BlMng_gettickcount(mng_handle hMNG) {
   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);
 
   // just return the current number of milliseconds (only converting, do not
@@ -147,8 +137,7 @@ mng_uint32 BlMng_gettickcount(mng_handle hMNG)
 }
 
 // the MNG library wants to be be called again after some milliseconds
-mng_bool BlMng_settimer(mng_handle hMNG, mng_uint32 iMsecs)
-{
+mng_bool BlMng_settimer(mng_handle hMNG, mng_uint32 iMsecs) {
   BlMng_userdata *data = (BlMng_userdata *)mng_get_userdata(hMNG);
 
   // just remember the number of milliseconds
@@ -160,8 +149,7 @@ mng_bool BlMng_settimer(mng_handle hMNG, mng_uint32 iMsecs)
 // save as new frame to current movie
 void BlMng_save_frame(stBlinkenMovie *movie, unsigned int msec,
                       unsigned int width, unsigned int height,
-                      unsigned char *data)
-{
+                      unsigned char *data) {
   stBlinkenFrame *frame;
   unsigned int c, x, y;
 
@@ -191,8 +179,7 @@ void BlMng_save_frame(stBlinkenMovie *movie, unsigned int msec,
 
 // compress pixel data in a frame
 void BlMng_compress_frame(stBlinkenFrame *frame, unsigned char **p_out_ptr,
-                          unsigned int *p_out_len)
-{
+                          unsigned int *p_out_len) {
   unsigned int width = BlinkenFrameGetWidth(frame);
   unsigned int height = BlinkenFrameGetHeight(frame);
   // channels is always 3, maxval is always 255 - this function is only
@@ -233,8 +220,7 @@ void BlMng_compress_frame(stBlinkenFrame *frame, unsigned char **p_out_ptr,
 }
 
 // load a MNG file as BlinkenMovie
-stBlinkenMovie *BlinkenMngLoad(const char *pFilename)
-{
+stBlinkenMovie *BlinkenMngLoad(const char *pFilename) {
   BlMng_userdata *data;
   mng_handle hMNG;
   stBlinkenMovie *movie = NULL;
@@ -256,8 +242,7 @@ stBlinkenMovie *BlinkenMngLoad(const char *pFilename)
     if (data->hFile != NULL) {
 
       // initialize MNG library
-      hMNG =
-          mng_initialize((mng_ptr) data, BlMng_alloc, BlMng_free, MNG_NULL);
+      hMNG = mng_initialize((mng_ptr)data, BlMng_alloc, BlMng_free, MNG_NULL);
       if (hMNG) {
 
         // set MNG callbacks
@@ -369,8 +354,7 @@ stBlinkenMovie *BlinkenMngLoad(const char *pFilename)
   return movie;
 }
 
-int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)
-{
+int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename) {
   BlMng_userdata *data;
   mng_handle hMNG;
   int b_success = 0;
@@ -397,8 +381,7 @@ int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)
       if (data->hFile != NULL) {
 
         // initialize MNG library
-        hMNG =
-            mng_initialize((mng_ptr) data, BlMng_alloc, BlMng_free, MNG_NULL);
+        hMNG = mng_initialize((mng_ptr)data, BlMng_alloc, BlMng_free, MNG_NULL);
         if (hMNG) {
 
           // set MNG callbacks
@@ -417,7 +400,8 @@ int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)
                 unsigned int frame_no;
 
                 // write MG header chunks
-                if (mng_putchunk_mhdr(hMNG, data->width, data->height,  // dimensions
+                if (mng_putchunk_mhdr(
+                        hMNG, data->width, data->height,    // dimensions
                         1000, 0, frame_cnt, total_duration, // ticks
                                                             //
                         //
@@ -430,7 +414,8 @@ int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)
                         // frame
                         // count,
                         // duration
-                                      MNG_SIMPLICITY_VALID | MNG_SIMPLICITY_SIMPLEFEATURES | MNG_SIMPLICITY_COMPLEXFEATURES     // simplicity
+                        MNG_SIMPLICITY_VALID | MNG_SIMPLICITY_SIMPLEFEATURES |
+                            MNG_SIMPLICITY_COMPLEXFEATURES // simplicity
                         ) != 0)
                   break;
 
@@ -443,7 +428,8 @@ int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)
                 // - this is needed to preserve duration of last frame
                 // - this results in a black frame with 1ms duration at the
                 // end of the MNG as side effect
-                if (mng_putchunk_term(hMNG, MNG_TERMACTION_CLEAR, MNG_ITERACTION_CLEAR, // show 
+                if (mng_putchunk_term(hMNG, MNG_TERMACTION_CLEAR,
+                                      MNG_ITERACTION_CLEAR, // show
                                                             //
                                       //
                                       //
@@ -467,15 +453,17 @@ int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)
                   // get current frame
                   stBlinkenFrame *frame =
                       BlinkenMovieGetFrame(data->movie, frame_no);
-                  unsigned int frame_duration =
-                      BlinkenFrameGetDuration(frame);
+                  unsigned int frame_duration = BlinkenFrameGetDuration(frame);
 
                   // write MNG frame header chunks
                   if (mng_putchunk_seek(hMNG, 0, MNG_NULL // no name
                                         ) != 0)
                     break;
 
-                  if (mng_putchunk_fram(hMNG, MNG_FALSE, frame_no == 0 ? MNG_FRAMINGMODE_1 : MNG_FRAMINGMODE_NOCHANGE,  // empty, 
+                  if (mng_putchunk_fram(
+                          hMNG, MNG_FALSE,
+                          frame_no == 0 ? MNG_FRAMINGMODE_1
+                                        : MNG_FRAMINGMODE_NOCHANGE, // empty,
                                                                     //
                           //
                           //
@@ -483,7 +471,9 @@ int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)
                           //
                           // mode
                           0, MNG_NULL, // frame name
-                                        MNG_CHANGEDELAY_DEFAULT, MNG_CHANGETIMOUT_NO, MNG_CHANGECLIPPING_NO, MNG_CHANGESYNCID_NO,       // changing 
+                          MNG_CHANGEDELAY_DEFAULT, MNG_CHANGETIMOUT_NO,
+                          MNG_CHANGECLIPPING_NO,
+                          MNG_CHANGESYNCID_NO, // changing
                                                //
                           //
                           //
@@ -504,7 +494,8 @@ int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)
                           ) != 0)
                     break;
 
-                  if (mng_putchunk_defi(hMNG, 0, MNG_DONOTSHOW_VISIBLE, MNG_ABSTRACT,   // no 
+                  if (mng_putchunk_defi(hMNG, 0, MNG_DONOTSHOW_VISIBLE,
+                                        MNG_ABSTRACT, // no
                                                       //
                                         //
                                         //
@@ -519,7 +510,8 @@ int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)
                                         ) != 0)
                     break;
 
-                  if (mng_putchunk_ihdr(hMNG, data->width, data->height, 8, MNG_COLORTYPE_RGB,  // dimensions 
+                  if (mng_putchunk_ihdr(hMNG, data->width, data->height, 8,
+                                        MNG_COLORTYPE_RGB, // dimensions
                                                            //
                                         //
                                         //
@@ -529,7 +521,9 @@ int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)
                                         // 8
                                         // bit
                                         // RGB
-                                        MNG_COMPRESSION_DEFLATE, MNG_FILTER_ADAPTIVE, MNG_INTERLACE_NONE        // deflate 
+                                        MNG_COMPRESSION_DEFLATE,
+                                        MNG_FILTER_ADAPTIVE,
+                                        MNG_INTERLACE_NONE // deflate
                                                            //
                                                            //
                                                            //
@@ -552,8 +546,7 @@ int BlinkenMngSave(stBlinkenMovie *pMovie, const char *pFilename)
                     BlMng_compress_frame(frame, &ptr, &len);
 
                     iRC =
-                        mng_putchunk_idat(hMNG, (mng_uint32) len,
-                                          (mng_ptr) ptr);
+                        mng_putchunk_idat(hMNG, (mng_uint32)len, (mng_ptr)ptr);
                     free(ptr);
                     if (iRC != 0)
                       break;

src/BlinkenMng.h

View file @ 860e91b

@@ -6,9 +6,9 @@
 #ifndef INC_BlinkenLib_BlinkenMng
 #define INC_BlinkenLib_BlinkenMng
 
-#include <BlinkenLib/config.h>
 #include <BlinkenLib/BlinkenFrame.h>
 #include <BlinkenLib/BlinkenMovie.h>
+#include <BlinkenLib/config.h>
 
 #ifndef BLINKENLIB_CFG_MNG
 #error This file is to be used for MNG support only.

src/BlinkenMovie.c

View file @ 860e91b

@@ -7,21 +7,21 @@
 #include <stdlib.h>
 #include <string.h>
 #ifdef WIN32
-#include <winsock2.h>
 #include <windows.h>
+#include <winsock2.h>
 #else
-#include <unistd.h>
+#include <sys/select.h>
+#include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/select.h>
+#include <unistd.h>
 #endif
 
 #include <BlinkenLib/BlinkenFrame.h>
 #include <BlinkenLib/BlinkenMovie.h>
 
-#include "Tools.h"
 #include "BlinkenConstants.h"
+#include "Tools.h"
 #ifdef BLINKENLIB_CFG_MNG
 #include "BlinkenMng.h"
 #endif // #ifdef BLINKENLIB_CFG_MNG
@@ -42,25 +42,15 @@ struct sBlinkenMovie {
 
 #ifdef WIN32
 
-static void msleep(unsigned int ms)
-{
-  Sleep(ms);
-}
+static void msleep(unsigned int ms) { Sleep(ms); }
 
-static unsigned int get_ms()
-{
-  return GetTickCount();
-}
+static unsigned int get_ms() { return GetTickCount(); }
 
 #else
 
-static void msleep(unsigned int ms)
-{
-  usleep(ms * 1000);
-}
+static void msleep(unsigned int ms) { usleep(ms * 1000); }
 
-static unsigned int get_ms()
-{
+static unsigned int get_ms() {
   struct timeval tv;
   gettimeofday(&tv, NULL);
   return (unsigned int)(tv.tv_usec / 1000 + tv.tv_sec * 1000);
@@ -69,8 +59,7 @@ static unsigned int get_ms()
 #endif
 
 stBlinkenMovie *BlinkenMovieNew(int height, int width, int channels,
-                                int maxval)
-{
+                                int maxval) {
   stBlinkenMovie *pMovie;
 
   if (height < BlinkenHeightMin)
@@ -116,14 +105,12 @@ stBlinkenMovie *BlinkenMovieNew(int height, int width, int channels,
   return pMovie;
 }
 
-stBlinkenMovie *BlinkenMovieClone(stBlinkenMovie *pSrcMovie)
-{
+stBlinkenMovie *BlinkenMovieClone(stBlinkenMovie *pSrcMovie) {
   stBlinkenMovie *pMovie;
   stBlinkenFrame *pFrame;
   int i;
 
-  pMovie =
-      BlinkenMovieNew(pSrcMovie->height, pSrcMovie->width,
+  pMovie = BlinkenMovieNew(pSrcMovie->height, pSrcMovie->width,
                            pSrcMovie->channels, pSrcMovie->maxval);
   if (pMovie == NULL)
     return NULL;
@@ -141,8 +128,7 @@ stBlinkenMovie *BlinkenMovieClone(stBlinkenMovie *pSrcMovie)
   return pMovie;
 }
 
-void BlinkenMovieFree(stBlinkenMovie *pMovie)
-{
+void BlinkenMovieFree(stBlinkenMovie *pMovie) {
   int i;
 
   if (pMovie == NULL)
@@ -161,40 +147,35 @@ void BlinkenMovieFree(stBlinkenMovie *pMovie)
   free(pMovie);
 }
 
-int BlinkenMovieGetHeight(stBlinkenMovie *pMovie)
-{
+int BlinkenMovieGetHeight(stBlinkenMovie *pMovie) {
   if (pMovie == NULL)
     return 0;
 
   return pMovie->height;
 }
 
-int BlinkenMovieGetWidth(stBlinkenMovie *pMovie)
-{
+int BlinkenMovieGetWidth(stBlinkenMovie *pMovie) {
   if (pMovie == NULL)
     return 0;
 
   return pMovie->width;
 }
 
-int BlinkenMovieGetChannels(stBlinkenMovie *pMovie)
-{
+int BlinkenMovieGetChannels(stBlinkenMovie *pMovie) {
   if (pMovie == NULL)
     return 0;
 
   return pMovie->channels;
 }
 
-int BlinkenMovieGetMaxval(stBlinkenMovie *pMovie)
-{
+int BlinkenMovieGetMaxval(stBlinkenMovie *pMovie) {
   if (pMovie == NULL)
     return 0;
 
   return pMovie->maxval;
 }
 
-int BlinkenMovieGetDuration(stBlinkenMovie *pMovie)
-{
+int BlinkenMovieGetDuration(stBlinkenMovie *pMovie) {
   int i, duration;
 
   if (pMovie == NULL)
@@ -206,16 +187,14 @@ int BlinkenMovieGetDuration(stBlinkenMovie *pMovie)
   return duration;
 }
 
-int BlinkenMovieGetInfoCnt(stBlinkenMovie *pMovie)
-{
+int BlinkenMovieGetInfoCnt(stBlinkenMovie *pMovie) {
   if (pMovie == NULL)
     return 0;
 
   return pMovie->infoCnt;
 }
 
-char *BlinkenMovieGetInfoType(stBlinkenMovie *pMovie, int infoNo)
-{
+char *BlinkenMovieGetInfoType(stBlinkenMovie *pMovie, int infoNo) {
   if (pMovie == NULL || pMovie->infoCnt < 1)
     return "";
 
@@ -226,8 +205,7 @@ char *BlinkenMovieGetInfoType(stBlinkenMovie *pMovie, int infoNo)
   return pMovie->pppInfos[infoNo][0];
 }
 
-char *BlinkenMovieGetInfoData(stBlinkenMovie *pMovie, int infoNo)
-{
+char *BlinkenMovieGetInfoData(stBlinkenMovie *pMovie, int infoNo) {
   if (pMovie == NULL || pMovie->infoCnt < 1)
     return "";
 
@@ -239,8 +217,7 @@ char *BlinkenMovieGetInfoData(stBlinkenMovie *pMovie, int infoNo)
 }
 
 void BlinkenMovieSetInfo(stBlinkenMovie *pMovie, int infoNo,
-                         const char *pInfoType, const char *pInfoData)
-{
+                         const char *pInfoType, const char *pInfoData) {
   char *pType, *pData;
 
   if (pMovie == NULL || infoNo < 0 || infoNo >= pMovie->infoCnt)
@@ -262,16 +239,15 @@ void BlinkenMovieSetInfo(stBlinkenMovie *pMovie, int infoNo,
 }
 
 void BlinkenMovieInsertInfo(stBlinkenMovie *pMovie, int infoNo,
-                            const char *pInfoType, const char *pInfoData)
-{
+                            const char *pInfoType, const char *pInfoData) {
   char ***pppNewInfos, *pType, *pData;
   int i;
 
   if (pMovie == NULL || infoNo < 0 || infoNo > pMovie->infoCnt)
     return;
 
-  pppNewInfos = (char ***)BlinkenMalloc2D(pMovie->infoCnt + 1, 2,
-                                          sizeof(char *));
+  pppNewInfos =
+      (char ***)BlinkenMalloc2D(pMovie->infoCnt + 1, 2, sizeof(char *));
   if (pppNewInfos == NULL)
     return;
 
@@ -306,24 +282,22 @@ void BlinkenMovieInsertInfo(stBlinkenMovie *pMovie, int infoNo,
 }
 
 void BlinkenMovieAppendInfo(stBlinkenMovie *pMovie, const char *pInfoType,
-                            const char *pInfoData)
-{
+                            const char *pInfoData) {
   if (pMovie == NULL)
     return;
 
   BlinkenMovieInsertInfo(pMovie, pMovie->infoCnt, pInfoType, pInfoData);
 }
 
-void BlinkenMovieDeleteInfo(stBlinkenMovie *pMovie, int infoNo)
-{
+void BlinkenMovieDeleteInfo(stBlinkenMovie *pMovie, int infoNo) {
   char ***pppNewInfos;
   int i;
 
   if (pMovie == NULL || infoNo < 0 || infoNo >= pMovie->infoCnt)
     return;
 
-  pppNewInfos = (char ***)BlinkenMalloc2D(pMovie->infoCnt - 1, 2,
-                                          sizeof(char *));
+  pppNewInfos =
+      (char ***)BlinkenMalloc2D(pMovie->infoCnt - 1, 2, sizeof(char *));
   if (pppNewInfos == NULL)
     return;
 
@@ -345,8 +319,7 @@ void BlinkenMovieDeleteInfo(stBlinkenMovie *pMovie, int infoNo)
   pMovie->infoCnt--;
 }
 
-void BlinkenMovieDeleteInfos(stBlinkenMovie *pMovie)
-{
+void BlinkenMovieDeleteInfos(stBlinkenMovie *pMovie) {
   char ***pppNewInfos;
   int i;
 
@@ -367,16 +340,14 @@ void BlinkenMovieDeleteInfos(stBlinkenMovie *pMovie)
   pMovie->infoCnt = 0;
 }
 
-int BlinkenMovieGetFrameCnt(stBlinkenMovie *pMovie)
-{
+int BlinkenMovieGetFrameCnt(stBlinkenMovie *pMovie) {
   if (pMovie == NULL)
     return 0;
 
   return pMovie->frameCnt;
 }
 
-stBlinkenFrame *BlinkenMovieGetFrame(stBlinkenMovie *pMovie, int frameNo)
-{
+stBlinkenFrame *BlinkenMovieGetFrame(stBlinkenMovie *pMovie, int frameNo) {
   if (pMovie == NULL || pMovie->frameCnt < 1)
     return NULL;
 
@@ -388,8 +359,7 @@ stBlinkenFrame *BlinkenMovieGetFrame(stBlinkenMovie *pMovie, int frameNo)
 }
 
 void BlinkenMovieSetFrame(stBlinkenMovie *pMovie, int frameNo,
-                          stBlinkenFrame *pFrame)
-{
+                          stBlinkenFrame *pFrame) {
   if (pMovie == NULL || frameNo < 0 || frameNo >= pMovie->frameCnt)
     return;
 
@@ -399,16 +369,14 @@ void BlinkenMovieSetFrame(stBlinkenMovie *pMovie, int frameNo,
 }
 
 int BlinkenMovieInsertFrame(stBlinkenMovie *pMovie, int frameNo,
-                            stBlinkenFrame *pFrame)
-{
+                            stBlinkenFrame *pFrame) {
   stBlinkenFrame **ppNewFrames;
   int i;
 
   if (pMovie == NULL || frameNo < 0 || frameNo > pMovie->frameCnt)
     return -1;
 
-  ppNewFrames =
-      (stBlinkenFrame **) BlinkenMalloc1D(pMovie->frameCnt + 1,
+  ppNewFrames = (stBlinkenFrame **)BlinkenMalloc1D(pMovie->frameCnt + 1,
                                                    sizeof(stBlinkenFrame *));
   if (ppNewFrames == NULL)
     return -1;
@@ -429,16 +397,14 @@ int BlinkenMovieInsertFrame(stBlinkenMovie *pMovie, int frameNo,
   return 0;
 }
 
-int BlinkenMovieAppendFrame(stBlinkenMovie *pMovie, stBlinkenFrame *pFrame)
-{
+int BlinkenMovieAppendFrame(stBlinkenMovie *pMovie, stBlinkenFrame *pFrame) {
   if (pMovie == NULL)
     return -1;
 
   return BlinkenMovieInsertFrame(pMovie, pMovie->frameCnt, pFrame);
 }
 
-void BlinkenMovieDeleteFrame(stBlinkenMovie *pMovie, int frameNo)
-{
+void BlinkenMovieDeleteFrame(stBlinkenMovie *pMovie, int frameNo) {
   stBlinkenFrame **ppNewFrames;
   int i;
 
@@ -463,16 +429,14 @@ void BlinkenMovieDeleteFrame(stBlinkenMovie *pMovie, int frameNo)
   pMovie->frameCnt--;
 }
 
-void BlinkenMovieDeleteFrames(stBlinkenMovie *pMovie)
-{
+void BlinkenMovieDeleteFrames(stBlinkenMovie *pMovie) {
   stBlinkenFrame **ppNewFrames;
   int i;
 
   if (pMovie == NULL)
     return;
 
-  ppNewFrames =
-      (stBlinkenFrame **)BlinkenMalloc1D(0, sizeof(stBlinkenFrame *));
+  ppNewFrames = (stBlinkenFrame **)BlinkenMalloc1D(0, sizeof(stBlinkenFrame *));
   if (ppNewFrames == NULL)
     return;
 
@@ -485,8 +449,7 @@ void BlinkenMovieDeleteFrames(stBlinkenMovie *pMovie)
 }
 
 int BlinkenMovieConcat(stBlinkenMovie *pMovie,
-                       stBlinkenMovie *pMovie2 /* appended and freed */)
-{
+                       stBlinkenMovie *pMovie2 /* appended and freed */) {
   stBlinkenFrame **ppNewFrames, **ppNewFrames2;
   int i;
 
@@ -496,12 +459,12 @@ int BlinkenMovieConcat(stBlinkenMovie *pMovie,
   BlinkenMovieResize(pMovie2, pMovie->height, pMovie->width, pMovie->channels,
                      pMovie->maxval);
 
-  ppNewFrames =
-      (stBlinkenFrame **)BlinkenMalloc1D(pMovie->frameCnt + pMovie2->frameCnt,
-                                         sizeof(stBlinkenFrame *));
+  ppNewFrames = (stBlinkenFrame **)BlinkenMalloc1D(
+      pMovie->frameCnt + pMovie2->frameCnt, sizeof(stBlinkenFrame *));
   if (ppNewFrames == NULL)
     return -1;
-  ppNewFrames2 = (stBlinkenFrame **)BlinkenMalloc1D(0, sizeof(stBlinkenFrame *));
+  ppNewFrames2 =
+      (stBlinkenFrame **)BlinkenMalloc1D(0, sizeof(stBlinkenFrame *));
   if (ppNewFrames2 == NULL) {
     free(ppNewFrames);
     return -1;
@@ -525,8 +488,7 @@ int BlinkenMovieConcat(stBlinkenMovie *pMovie,
   return 0;
 }
 
-void BlinkenMovieReverse(stBlinkenMovie *pMovie)
-{
+void BlinkenMovieReverse(stBlinkenMovie *pMovie) {
   int i, j;
   stBlinkenFrame *pFrame;
 
@@ -537,9 +499,8 @@ void BlinkenMovieReverse(stBlinkenMovie *pMovie)
   }
 }
 
-void BlinkenMovieCutTime(stBlinkenMovie *pMovie,
-                         int begin /* in ms */, int end /* in ms */)
-{
+void BlinkenMovieCutTime(stBlinkenMovie *pMovie, int begin /* in ms */,
+                         int end /* in ms */) {
   int i, duration, curtime, idx_begin, idx_end, duration_begin, duration_end;
   int frameCnt;
   stBlinkenFrame **ppNewFrames;
@@ -605,8 +566,8 @@ void BlinkenMovieCutTime(stBlinkenMovie *pMovie,
   // remove/free unneeded frames
 
   frameCnt = idx_end - idx_begin + 1;
-  ppNewFrames = (stBlinkenFrame **)BlinkenMalloc1D(frameCnt,
-                                                   sizeof(stBlinkenFrame *));
+  ppNewFrames =
+      (stBlinkenFrame **)BlinkenMalloc1D(frameCnt, sizeof(stBlinkenFrame *));
   if (ppNewFrames == NULL)
     return;
 
@@ -629,8 +590,7 @@ void BlinkenMovieCutTime(stBlinkenMovie *pMovie,
 }
 
 void BlinkenMovieAdaptDuration(stBlinkenMovie *pMovie,
-                               int duration /* in ms */)
-{
+                               int duration /* in ms */) {
   int old_duration, old_curtime, curtime;
   int i, old_dur, dur, old_end, end;
 
@@ -651,8 +611,8 @@ void BlinkenMovieAdaptDuration(stBlinkenMovie *pMovie,
     old_dur = BlinkenFrameGetDuration(pMovie->ppFrames[i]);
     old_end = old_curtime + old_dur;
     // compute new end time and new duration
-    end = (int)((double)old_end / (double)old_duration * (double)duration
-                + 0.5);
+    end =
+        (int)((double)old_end / (double)old_duration * (double)duration + 0.5);
     dur = end - curtime;
     if (dur < BlinkenDurationMin)
       dur = BlinkenDurationMin;
@@ -667,8 +627,7 @@ void BlinkenMovieAdaptDuration(stBlinkenMovie *pMovie,
 }
 
 void BlinkenMovieAdaptMaxFrameDuration(stBlinkenMovie *pMovie,
-                                       int maxDuration /* in ms */)
-{
+                                       int maxDuration /* in ms */) {
   int i, j, cmp, dur, lastdur;
   unsigned int extraFrames;
   stBlinkenFrame **ppNewFrames;
@@ -691,9 +650,8 @@ void BlinkenMovieAdaptMaxFrameDuration(stBlinkenMovie *pMovie,
   }
 
   // allocate new frame array
-  ppNewFrames = (stBlinkenFrame **)BlinkenMalloc1D(pMovie->frameCnt
-                                                   + extraFrames,
-                                                   sizeof(stBlinkenFrame *));
+  ppNewFrames = (stBlinkenFrame **)BlinkenMalloc1D(
+      pMovie->frameCnt + extraFrames, sizeof(stBlinkenFrame *));
   if (!ppNewFrames) {
     return;
   }
@@ -750,8 +708,7 @@ void BlinkenMovieAdaptMaxFrameDuration(stBlinkenMovie *pMovie,
 }
 
 void BlinkenMovieResize(stBlinkenMovie *pMovie, int height, int width,
-                        int channels, int maxval)
-{
+                        int channels, int maxval) {
   int i;
 
   if (pMovie == NULL)
@@ -783,9 +740,8 @@ void BlinkenMovieResize(stBlinkenMovie *pMovie, int height, int width,
     BlinkenFrameResize(pMovie->ppFrames[i], height, width, channels, maxval);
 }
 
-void BlinkenMovieCrop(stBlinkenMovie *pMovie, int top, int left,
-                      int height, int width)
-{
+void BlinkenMovieCrop(stBlinkenMovie *pMovie, int top, int left, int height,
+                      int width) {
   int i;
 
   if (pMovie == NULL)
@@ -808,8 +764,8 @@ void BlinkenMovieCrop(stBlinkenMovie *pMovie, int top, int left,
   if (width > pMovie->width - left)
     width = pMovie->width - left;
 
-  if (top == 0 && left == 0 &&
-      height == pMovie->height && width == pMovie->width)
+  if (top == 0 && left == 0 && height == pMovie->height &&
+      width == pMovie->width)
     return;
 
   pMovie->height = height;
@@ -819,8 +775,7 @@ void BlinkenMovieCrop(stBlinkenMovie *pMovie, int top, int left,
     BlinkenFrameCrop(pMovie->ppFrames[i], top, left, height, width);
 }
 
-void BlinkenMovieScale(stBlinkenMovie *pMovie, int height, int width)
-{
+void BlinkenMovieScale(stBlinkenMovie *pMovie, int height, int width) {
   int i;
 
   if (pMovie == NULL)
@@ -842,8 +797,7 @@ void BlinkenMovieScale(stBlinkenMovie *pMovie, int height, int width)
     BlinkenFrameScale(pMovie->ppFrames[i], height, width);
 }
 
-void BlinkenMovieColorize(stBlinkenMovie *pMovie, int channels, int mode)
-{
+void BlinkenMovieColorize(stBlinkenMovie *pMovie, int channels, int mode) {
   int i, step;
 
   if (pMovie == NULL)
@@ -865,9 +819,8 @@ void BlinkenMovieColorize(stBlinkenMovie *pMovie, int channels, int mode)
 }
 
 void BlinkenMovieCopyRect(stBlinkenMovie *pDest, int destY, int destX,
-                          stBlinkenMovie *pSrc, int srcY, int srcX,
-                          int height, int width)
-{
+                          stBlinkenMovie *pSrc, int srcY, int srcX, int height,
+                          int width) {
   int dcnt, scnt, di, si, dest_dur, src_dur, src_time_ofs;
   stBlinkenFrame *pFrame;
 
@@ -891,9 +844,8 @@ void BlinkenMovieCopyRect(stBlinkenMovie *pDest, int destY, int destX,
     // make sure there is a frame in destination movie
     if (di >= dcnt) {
       // append new empty frame that last until end of source frame
-      pFrame = BlinkenFrameNew(pDest->height, pDest->width,
-                               pDest->channels, pDest->maxval,
-                               src_dur - src_time_ofs);
+      pFrame = BlinkenFrameNew(pDest->height, pDest->width, pDest->channels,
+                               pDest->maxval, src_dur - src_time_ofs);
       if (pFrame == NULL)
         return;
       BlinkenFrameClear(pFrame);
@@ -912,16 +864,15 @@ void BlinkenMovieCopyRect(stBlinkenMovie *pDest, int destY, int destX,
       if (BlinkenMovieInsertFrame(pDest, di + 1, pFrame) != 0)
         return;
       dcnt++;
-      BlinkenFrameSetDuration(pDest->ppFrames[di],
-                              src_dur - src_time_ofs);
+      BlinkenFrameSetDuration(pDest->ppFrames[di], src_dur - src_time_ofs);
       BlinkenFrameSetDuration(pDest->ppFrames[di + 1],
                               dest_dur - (src_dur - src_time_ofs));
       dest_dur = src_dur - src_time_ofs;
     }
 
     // copy from source frame to destination frame
-    BlinkenFrameCopyRect(pDest->ppFrames[di], destY, destX,
-                         pSrc->ppFrames[si], srcY, srcX, height, width);
+    BlinkenFrameCopyRect(pDest->ppFrames[di], destY, destX, pSrc->ppFrames[si],
+                         srcY, srcX, height, width);
     src_time_ofs += dest_dur;
     di++;
     dest_dur = di < dcnt ? BlinkenFrameGetDuration(pDest->ppFrames[di]) : 0;
@@ -936,8 +887,7 @@ void BlinkenMovieCopyRect(stBlinkenMovie *pDest, int destY, int destX,
   } // while (si < scnt)
 }
 
-void BlinkenMovieRotateCw(stBlinkenMovie *pMovie)
-{
+void BlinkenMovieRotateCw(stBlinkenMovie *pMovie) {
   int tmp, i;
 
   if (pMovie == NULL)
@@ -951,8 +901,7 @@ void BlinkenMovieRotateCw(stBlinkenMovie *pMovie)
     BlinkenFrameRotateCw(pMovie->ppFrames[i]);
 }
 
-void BlinkenMovieRotateCcw(stBlinkenMovie *pMovie)
-{
+void BlinkenMovieRotateCcw(stBlinkenMovie *pMovie) {
   int tmp, i;
 
   if (pMovie == NULL)
@@ -966,8 +915,7 @@ void BlinkenMovieRotateCcw(stBlinkenMovie *pMovie)
     BlinkenFrameRotateCcw(pMovie->ppFrames[i]);
 }
 
-void BlinkenMovieRotateHalf(stBlinkenMovie *pMovie)
-{
+void BlinkenMovieRotateHalf(stBlinkenMovie *pMovie) {
   int i;
 
   if (pMovie == NULL)
@@ -977,8 +925,7 @@ void BlinkenMovieRotateHalf(stBlinkenMovie *pMovie)
     BlinkenFrameRotateHalf(pMovie->ppFrames[i]);
 }
 
-void BlinkenMovieMirrorHor(stBlinkenMovie *pMovie)
-{
+void BlinkenMovieMirrorHor(stBlinkenMovie *pMovie) {
   int i;
 
   if (pMovie == NULL)
@@ -988,8 +935,7 @@ void BlinkenMovieMirrorHor(stBlinkenMovie *pMovie)
     BlinkenFrameMirrorHor(pMovie->ppFrames[i]);
 }
 
-void BlinkenMovieMirrorVer(stBlinkenMovie *pMovie)
-{
+void BlinkenMovieMirrorVer(stBlinkenMovie *pMovie) {
   int i;
 
   if (pMovie == NULL)
@@ -999,8 +945,7 @@ void BlinkenMovieMirrorVer(stBlinkenMovie *pMovie)
     BlinkenFrameMirrorVer(pMovie->ppFrames[i]);
 }
 
-void BlinkenMovieMirrorDiag(stBlinkenMovie *pMovie)
-{
+void BlinkenMovieMirrorDiag(stBlinkenMovie *pMovie) {
   int tmp, i;
 
   if (pMovie == NULL)
@@ -1014,8 +959,7 @@ void BlinkenMovieMirrorDiag(stBlinkenMovie *pMovie)
     BlinkenFrameMirrorDiag(pMovie->ppFrames[i]);
 }
 
-void BlinkenMovieMirrorDiag2(stBlinkenMovie *pMovie)
-{
+void BlinkenMovieMirrorDiag2(stBlinkenMovie *pMovie) {
   int tmp, i;
 
   if (pMovie == NULL)
@@ -1029,8 +973,7 @@ void BlinkenMovieMirrorDiag2(stBlinkenMovie *pMovie)
     BlinkenFrameMirrorDiag2(pMovie->ppFrames[i]);
 }
 
-char *BlinkenMovieToString(stBlinkenMovie *pMovie)
-{
+char *BlinkenMovieToString(stBlinkenMovie *pMovie) {
   char **strs, *str, *ptr;
   int i, size;
 
@@ -1053,8 +996,7 @@ char *BlinkenMovieToString(stBlinkenMovie *pMovie)
 
   size = 128;
   for (i = 0; i < pMovie->infoCnt; i++)
-    size +=
-        strlen(pMovie->pppInfos[i][0]) + strlen(pMovie->pppInfos[i][1]) + 8;
+    size += strlen(pMovie->pppInfos[i][0]) + strlen(pMovie->pppInfos[i][1]) + 8;
   for (i = 0; i < pMovie->frameCnt; i++)
     size += strlen(strs[i]) + 32;
 
@@ -1087,8 +1029,7 @@ char *BlinkenMovieToString(stBlinkenMovie *pMovie)
   return str;
 }
 
-stBlinkenMovie *BlinkenMovieLoadBlm(const char *pFilename)
-{
+stBlinkenMovie *BlinkenMovieLoadBlm(const char *pFilename) {
   FILE *pFile;
   stBlinkenMovie *pMovie;
   stBlinkenFrame *pFrame;
@@ -1121,11 +1062,11 @@ stBlinkenMovie *BlinkenMovieLoadBlm(const char *pFilename)
   // read frames
   while (!feof(pFile)) {
     // skip rest of previous line (including newline)
-    while ((chr = fgetc(pFile)) != '\n' && chr != EOF) ;
+    while ((chr = fgetc(pFile)) != '\n' && chr != EOF)
+      ;
 
     // info line
-    if (fscanf
-        (pFile, " # %255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType,
+    if (fscanf(pFile, " # %255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType,
                infoData) == 2) {
       BlinkenMovieAppendInfo(pMovie, infoType, infoData);
     }
@@ -1163,8 +1104,7 @@ stBlinkenMovie *BlinkenMovieLoadBlm(const char *pFilename)
   return pMovie;
 }
 
-stBlinkenMovie *BlinkenMovieLoadBmm(const char *pFilename)
-{
+stBlinkenMovie *BlinkenMovieLoadBmm(const char *pFilename) {
   FILE *pFile;
   stBlinkenMovie *pMovie;
   stBlinkenFrame *pFrame;
@@ -1197,11 +1137,11 @@ stBlinkenMovie *BlinkenMovieLoadBmm(const char *pFilename)
   // read frames
   while (!feof(pFile)) {
     // skip rest of previous line (including newline)
-    while ((chr = fgetc(pFile)) != '\n' && chr != EOF) ;
+    while ((chr = fgetc(pFile)) != '\n' && chr != EOF)
+      ;
 
     // info line
-    if (fscanf
-        (pFile, " # %255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType,
+    if (fscanf(pFile, " # %255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType,
                infoData) == 2) {
       BlinkenMovieAppendInfo(pMovie, infoType, infoData);
     }
@@ -1243,8 +1183,7 @@ stBlinkenMovie *BlinkenMovieLoadBmm(const char *pFilename)
   return pMovie;
 }
 
-stBlinkenMovie *BlinkenMovieLoadBml(const char *pFilename)
-{
+stBlinkenMovie *BlinkenMovieLoadBml(const char *pFilename) {
   FILE *pFile;
   stBlinkenMovie *pMovie;
   stBlinkenFrame *pFrame;
@@ -1330,8 +1269,7 @@ stBlinkenMovie *BlinkenMovieLoadBml(const char *pFilename)
       // description tag
       else if (fscanf(pFile, "description>%2047[^<]", buffer) == 1) {
         // check if generic info
-        if (sscanf
-            (buffer, "%255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType,
+        if (sscanf(buffer, "%255[A-Za-z0-9] %*[=:] %1023[^\n]", infoType,
                    infoData) == 2)
           // add info to movie
           BlinkenMovieAppendInfo(pMovie, infoType, infoData);
@@ -1410,8 +1348,7 @@ stBlinkenMovie *BlinkenMovieLoadBml(const char *pFilename)
   return pMovie;
 }
 
-stBlinkenMovie *BlinkenMovieLoadBbm(const char *pFilename)
-{
+stBlinkenMovie *BlinkenMovieLoadBbm(const char *pFilename) {
   FILE *pFile;
   stBlinkenMovie *pMovie;
   stBlinkenFrame *pFrame;
@@ -1437,15 +1374,15 @@ stBlinkenMovie *BlinkenMovieLoadBbm(const char *pFilename)
     fclose(pFile);
     return NULL;
   }
-  headerMagic =
-      (unsigned long)header[0] << 24 | (unsigned long)header[1] << 16 |
-      (unsigned long)header[2] << 8 | (unsigned long)header[3];
+  headerMagic = (unsigned long)header[0] << 24 |
+                (unsigned long)header[1] << 16 | (unsigned long)header[2] << 8 |
+                (unsigned long)header[3];
   headerHeight = (unsigned short)header[4] << 8 | (unsigned short)header[5];
   headerWidth = (unsigned short)header[6] << 8 | (unsigned short)header[7];
   headerChannels = (unsigned short)header[8] << 8 | (unsigned short)header[9];
   headerMaxval = (unsigned short)header[10] << 8 | (unsigned short)header[11];
-  headerFramePtr =
-      (unsigned long)header[20] << 24 | (unsigned long)header[21] << 16 |
+  headerFramePtr = (unsigned long)header[20] << 24 |
+                   (unsigned long)header[21] << 16 |
                    (unsigned long)header[22] << 8 | (unsigned long)header[23];
   // check magic
   if (headerMagic != 0x23542666) {
@@ -1454,8 +1391,7 @@ stBlinkenMovie *BlinkenMovieLoadBbm(const char *pFilename)
   }
   // allocate a new movie
   pMovie =
-      BlinkenMovieNew(headerHeight, headerWidth, headerChannels,
-                      headerMaxval);
+      BlinkenMovieNew(headerHeight, headerWidth, headerChannels, headerMaxval);
   if (pMovie == NULL) {
     fclose(pFile);
     return NULL;
@@ -1468,14 +1404,14 @@ stBlinkenMovie *BlinkenMovieLoadBbm(const char *pFilename)
       return NULL;
     }
     subHeaderMagic =
-        (unsigned long)subHeader[0] << 24 | (unsigned long)subHeader[1] << 16
-        | (unsigned long)subHeader[2] << 8 | (unsigned long)subHeader[3];
+        (unsigned long)subHeader[0] << 24 | (unsigned long)subHeader[1] << 16 |
+        (unsigned long)subHeader[2] << 8 | (unsigned long)subHeader[3];
     subHeaderSize =
         (unsigned short)subHeader[4] << 8 | (unsigned short)subHeader[5];
 
     // header fits into gap to frame start
-    if (subHeaderSize >= 6
-        && ftell(pFile) + subHeaderSize - 6 <= (long)headerFramePtr) {
+    if (subHeaderSize >= 6 &&
+        ftell(pFile) + subHeaderSize - 6 <= (long)headerFramePtr) {
       // info header
       if (subHeaderMagic == 0x696E666F) // 'i' 'n' 'f' 'o'
       {
@@ -1494,8 +1430,8 @@ stBlinkenMovie *BlinkenMovieLoadBbm(const char *pFilename)
           return NULL;
         }
         // parse information
-        if ((pInfoHeaderX =
-             memchr(pInfoHeader, 0, subHeaderSize - 6)) != NULL) {
+        if ((pInfoHeaderX = memchr(pInfoHeader, 0, subHeaderSize - 6)) !=
+            NULL) {
           pInfoHeaderX++;
           len = pInfoHeaderX - pInfoHeader;
           if (memchr(pInfoHeaderX, 0, subHeaderSize - 6 - len) != NULL)
@@ -1520,9 +1456,9 @@ stBlinkenMovie *BlinkenMovieLoadBbm(const char *pFilename)
     fclose(pFile);
     return NULL;
   }
-  frameStartMarkerMagic =
-      (unsigned long)frameStartMarker[0] << 24 | (unsigned long)
-      frameStartMarker[1] << 16 | (unsigned long)frameStartMarker[2] << 8 |
+  frameStartMarkerMagic = (unsigned long)frameStartMarker[0] << 24 |
+                          (unsigned long)frameStartMarker[1] << 16 |
+                          (unsigned long)frameStartMarker[2] << 8 |
                           (unsigned long)frameStartMarker[3];
   if (frameStartMarkerMagic != 0x66726D73) // 'f' 'r' 'm' 's'
   {
@@ -1546,8 +1482,7 @@ stBlinkenMovie *BlinkenMovieLoadBbm(const char *pFilename)
     duration =
         (unsigned short)pFrameData[0] << 8 | (unsigned short)pFrameData[1];
     // build frame and append it to movie
-    pFrame =
-        BlinkenFrameNew(headerHeight, headerWidth, headerChannels,
+    pFrame = BlinkenFrameNew(headerHeight, headerWidth, headerChannels,
                              headerMaxval, duration);
     if (pFrame == NULL)
       break;
@@ -1574,8 +1509,7 @@ stBlinkenMovie *BlinkenMovieLoadBbm(const char *pFilename)
 
 #ifdef BLINKENLIB_CFG_MNG
 
-stBlinkenMovie *BlinkenMovieLoadMng(const char *pFilename)
-{
+stBlinkenMovie *BlinkenMovieLoadMng(const char *pFilename) {
   return BlinkenMngLoad(pFilename);
 }
 
@@ -1583,15 +1517,13 @@ stBlinkenMovie *BlinkenMovieLoadMng(const char *pFilename)
 
 #ifdef BLINKENLIB_CFG_GIF
 
-stBlinkenMovie *BlinkenMovieLoadGif(const char *pFilename)
-{
+stBlinkenMovie *BlinkenMovieLoadGif(const char *pFilename) {
   return BlinkenGifLoad(pFilename);
 }
 
 #endif // #ifdef BLINKENLIB_CFG_GIF
 
-stBlinkenMovie *BlinkenMovieLoad(const char *pFilename)
-{
+stBlinkenMovie *BlinkenMovieLoad(const char *pFilename) {
   int len;
 
   if (pFilename == NULL)
@@ -1617,8 +1549,7 @@ stBlinkenMovie *BlinkenMovieLoad(const char *pFilename)
   return NULL;
 }
 
-int BlinkenMovieSaveBlm(stBlinkenMovie *pMovie, const char *pFilename)
-{
+int BlinkenMovieSaveBlm(stBlinkenMovie *pMovie, const char *pFilename) {
   stBlinkenMovie *pOutMovie;
   FILE *pFile;
   int i, y, x;
@@ -1649,8 +1580,7 @@ int BlinkenMovieSaveBlm(stBlinkenMovie *pMovie, const char *pFilename)
 
   // write frames
   for (i = 0; i < pOutMovie->frameCnt; i++) {
-    fprintf(pFile, "\n@%u\n",
-            BlinkenFrameGetDuration(pOutMovie->ppFrames[i]));
+    fprintf(pFile, "\n@%u\n", BlinkenFrameGetDuration(pOutMovie->ppFrames[i]));
     for (y = 0; y < pOutMovie->height; y++) {
       for (x = 0; x < pOutMovie->width; x++) {
         if (BlinkenFrameGetPixel(pOutMovie->ppFrames[i], y, x, 0) != 0)
@@ -1672,8 +1602,7 @@ int BlinkenMovieSaveBlm(stBlinkenMovie *pMovie, const char *pFilename)
   return 0;
 }
 
-int BlinkenMovieSaveBmm(stBlinkenMovie *pMovie, const char *pFilename)
-{
+int BlinkenMovieSaveBmm(stBlinkenMovie *pMovie, const char *pFilename) {
   stBlinkenMovie *pOutMovie;
   FILE *pFile;
   int i, y, x;
@@ -1704,8 +1633,7 @@ int BlinkenMovieSaveBmm(stBlinkenMovie *pMovie, const char *pFilename)
 
   // write frames
   for (i = 0; i < pOutMovie->frameCnt; i++) {
-    fprintf(pFile, "\n@%u\n",
-            BlinkenFrameGetDuration(pOutMovie->ppFrames[i]));
+    fprintf(pFile, "\n@%u\n", BlinkenFrameGetDuration(pOutMovie->ppFrames[i]));
     for (y = 0; y < pOutMovie->height; y++) {
       fprintf(pFile, "0x%02X",
               BlinkenFrameGetPixel(pOutMovie->ppFrames[i], y, 0, 0));
@@ -1726,8 +1654,7 @@ int BlinkenMovieSaveBmm(stBlinkenMovie *pMovie, const char *pFilename)
   return 0;
 }
 
-int BlinkenMovieSaveBml(stBlinkenMovie *pMovie, const char *pFilename)
-{
+int BlinkenMovieSaveBml(stBlinkenMovie *pMovie, const char *pFilename) {
   stBlinkenMovie *pOutMovie;
   FILE *pFile;
   int bits, val, i, y, x, c;
@@ -1740,7 +1667,8 @@ int BlinkenMovieSaveBml(stBlinkenMovie *pMovie, const char *pFilename)
   if (pOutMovie == NULL)
     return -1;
   val = pOutMovie->maxval; // get number of bits
-  for (bits = 0; val != 0; val >>= 1, bits++) ;
+  for (bits = 0; val != 0; val >>= 1, bits++)
+    ;
   BlinkenMovieResize(pOutMovie, pOutMovie->height, pOutMovie->width,
                      pOutMovie->channels, (1 << bits) - 1);
 
@@ -1767,8 +1695,7 @@ int BlinkenMovieSaveBml(stBlinkenMovie *pMovie, const char *pFilename)
       fprintf(pFile, "\t\t<description>%s</description>\n",
               pOutMovie->pppInfos[i][1]);
     else if (strcmp(pOutMovie->pppInfos[i][0], "creator") == 0)
-      fprintf(pFile, "\t\t<creator>%s</creator>\n",
-              pOutMovie->pppInfos[i][1]);
+      fprintf(pFile, "\t\t<creator>%s</creator>\n", pOutMovie->pppInfos[i][1]);
     else if (strcmp(pOutMovie->pppInfos[i][0], "author") == 0)
       fprintf(pFile, "\t\t<author>%s</author>\n", pOutMovie->pppInfos[i][1]);
     else if (strcmp(pOutMovie->pppInfos[i][0], "email") == 0)
@@ -1809,12 +1736,10 @@ int BlinkenMovieSaveBml(stBlinkenMovie *pMovie, const char *pFilename)
   return 0;
 }
 
-int BlinkenMovieSaveBbm(stBlinkenMovie *pMovie, const char *pFilename)
-{
+int BlinkenMovieSaveBbm(stBlinkenMovie *pMovie, const char *pFilename) {
   unsigned char *pFrameData;
   FILE *pFile;
-  unsigned char header[24], infoHeader[6], framePointer[4],
-      frameStartMarker[4];
+  unsigned char header[24], infoHeader[6], framePointer[4], frameStartMarker[4];
   int duration, len, len0, len1, i, j, y, x, c, val;
   long pos;
 
@@ -1822,9 +1747,7 @@ int BlinkenMovieSaveBbm(stBlinkenMovie *pMovie, const char *pFilename)
     return -1;
 
   // allocate frame data buffer
-  pFrameData =
-      (unsigned char *)malloc(2 +
-                              pMovie->height * pMovie->width *
+  pFrameData = (unsigned char *)malloc(2 + pMovie->height * pMovie->width *
                                                pMovie->channels);
   if (pFrameData == NULL)
     return -1;
@@ -1928,8 +1851,7 @@ int BlinkenMovieSaveBbm(stBlinkenMovie *pMovie, const char *pFilename)
 
 #ifdef BLINKENLIB_CFG_MNG
 
-int BlinkenMovieSaveMng(stBlinkenMovie *pMovie, const char *pFilename)
-{
+int BlinkenMovieSaveMng(stBlinkenMovie *pMovie, const char *pFilename) {
   return BlinkenMngSave(pMovie, pFilename);
 }
 
@@ -1937,15 +1859,13 @@ int BlinkenMovieSaveMng(stBlinkenMovie *pMovie, const char *pFilename)
 
 #ifdef BLINKENLIB_CFG_GIF
 
-int BlinkenMovieSaveGif(stBlinkenMovie *pMovie, const char *pFilename)
-{
+int BlinkenMovieSaveGif(stBlinkenMovie *pMovie, const char *pFilename) {
   return BlinkenGifSave(pMovie, pFilename);
 }
 
 #endif // #ifdef BLINKENLIB_CFG_GIF
 
-int BlinkenMovieSave(stBlinkenMovie *pMovie, const char *pFilename)
-{
+int BlinkenMovieSave(stBlinkenMovie *pMovie, const char *pFilename) {
   int len;
 
   if (pMovie == NULL || pFilename == NULL)
@@ -1981,8 +1901,7 @@ void BlinkenMovieSend(stBlinkenMovie *pMovie, SOCKET udpSocket,
   char buffer[65536]; // 64kB is more than maximum UDP size
 
   for (i = 0; i < pMovie->frameCnt; i++) {
-    len =
-        BlinkenFrameToNetwork(pMovie->ppFrames[i], proto, buffer,
+    len = BlinkenFrameToNetwork(pMovie->ppFrames[i], proto, buffer,
                                 sizeof(buffer));
     duration = BlinkenFrameGetDuration(pMovie->ppFrames[i]);
     if (len > 0) {
@@ -2048,10 +1967,9 @@ stBlinkenMovie *BlinkenMovieReceive(SOCKET udpSocket, int timeout,
           // no movie yet
           if (pMovie == NULL) {
             // allocate a new movie
-            pMovie = BlinkenMovieNew(BlinkenFrameGetHeight(pFrame),
-                                     BlinkenFrameGetWidth(pFrame),
-                                     BlinkenFrameGetChannels(pFrame),
-                                     BlinkenFrameGetMaxval(pFrame));
+            pMovie = BlinkenMovieNew(
+                BlinkenFrameGetHeight(pFrame), BlinkenFrameGetWidth(pFrame),
+                BlinkenFrameGetChannels(pFrame), BlinkenFrameGetMaxval(pFrame));
             if (pMovie == NULL) {
               BlinkenFrameFree(pFrame);
               break;
@@ -2059,8 +1977,8 @@ stBlinkenMovie *BlinkenMovieReceive(SOCKET udpSocket, int timeout,
           }
           // ignore frame if it is equal to last one
           if (pMovie->frameCnt > 0) {
-            if (BlinkenFrameCompare
-                (pFrame, pMovie->ppFrames[pMovie->frameCnt - 1]) == 0) {
+            if (BlinkenFrameCompare(
+                    pFrame, pMovie->ppFrames[pMovie->frameCnt - 1]) == 0) {
               BlinkenFrameFree(pFrame);
               continue;
             }

src/BlinkenProto.c

View file @ 860e91b

@@ -5,13 +5,13 @@
 
 #include <string.h>
 #ifdef WIN32
-#include <winsock2.h>
 #include <windows.h>
+#include <winsock2.h>
 typedef WORD uint16_t;
 typedef DWORD uint32_t;
 #else
-#include <stdint.h>
 #include <netinet/in.h>
+#include <stdint.h>
 #endif
 
 #include <BlinkenLib/BlinkenProto.h>
@@ -131,8 +131,7 @@ int BlinkenProtoMakePacket(etBlinkenProto proto, etBlinkenPacket packet,
 }
 
 void BlinkenProtoDetectPacket(const char *pData, int length,
-                              etBlinkenProto * pProto,
-                              etBlinkenPacket * pPacket)
+                              etBlinkenProto *pProto, etBlinkenPacket *pPacket)
 // returns protocol in *pProto if pProto not NULL
 // returns packet type in *pPacket if pPacket not NULL
 {
@@ -161,28 +160,32 @@ void BlinkenProtoDetectPacket(const char *pData, int length,
     }
     break;
   case BlinkenProtoBlpReqMagic:
-    if (length >= (int)sizeof(magic) + 10 && !memcmp(pData + sizeof(magic), "REFRESH256", 10)) {
+    if (length >= (int)sizeof(magic) + 10 &&
+        !memcmp(pData + sizeof(magic), "REFRESH256", 10)) {
       if (pProto)
         *pProto = BlinkenProtoEblp;
       if (pPacket)
         *pPacket = BlinkenPacketRequest;
       return;
     }
-    if (length >= (int)sizeof(magic) + 8 && !memcmp(pData + sizeof(magic), "CLOSE256", 8)) {
+    if (length >= (int)sizeof(magic) + 8 &&
+        !memcmp(pData + sizeof(magic), "CLOSE256", 8)) {
       if (pProto)
         *pProto = BlinkenProtoEblp;
       if (pPacket)
         *pPacket = BlinkenPacketEndRequest;
       return;
     }
-    if (length >= (int)sizeof(magic) + 7 && !memcmp(pData + sizeof(magic), "REFRESH", 7)) {
+    if (length >= (int)sizeof(magic) + 7 &&
+        !memcmp(pData + sizeof(magic), "REFRESH", 7)) {
       if (pProto)
         *pProto = BlinkenProtoBlp;
       if (pPacket)
         *pPacket = BlinkenPacketRequest;
       return;
     }
-    if (length >= (int)sizeof(magic) + 5 && !memcmp(pData + sizeof(magic), "CLOSE", 5)) {
+    if (length >= (int)sizeof(magic) + 5 &&
+        !memcmp(pData + sizeof(magic), "CLOSE", 5)) {
       if (pProto)
         *pProto = BlinkenProtoBlp;
       if (pPacket)

src/Tools.c

View file @ 860e91b

@@ -7,8 +7,7 @@
 
 #include "Tools.h"
 
-void *BlinkenMalloc1D(int count1, int size)
-{
+void *BlinkenMalloc1D(int count1, int size) {
   if (count1 < 1)
     count1 = 1;
   if (size < 1)
@@ -17,8 +16,7 @@ void *BlinkenMalloc1D(int count1, int size)
   return malloc(count1 * size);
 }
 
-void **BlinkenMalloc2D(int count1, int count2, int size)
-{
+void **BlinkenMalloc2D(int count1, int count2, int size) {
   int sz, i;
   char *p;
   void **ptr;

tools/BlinkenConv.c

View file @ 860e91b

@@ -19,12 +19,17 @@
  * @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)
-{
+                           const char *str_mode, const char *str_duration) {
   unsigned int height, width, channels, colors;
   enum {
-    ModeNone, ModeBlack, ModeWhite, ModeGradient,
-    ModeDots, ModeLines, ModeTrans, ModeRainbow,
+    ModeNone,
+    ModeBlack,
+    ModeWhite,
+    ModeGradient,
+    ModeDots,
+    ModeLines,
+    ModeTrans,
+    ModeRainbow,
   } mode = ModeNone;
   int fmt_ok, append, duration;
 
@@ -43,8 +48,8 @@ static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,
       append = 1;
     }
   } else {
-    fmt_ok = sscanf(str_format, "%ux%u-%u/%u",
-                    &width, &height, &channels, &colors) == 4;
+    fmt_ok = sscanf(str_format, "%ux%u-%u/%u", &width, &height, &channels,
+                    &colors) == 4;
     append = 0;
   }
   // mode
@@ -96,9 +101,7 @@ static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,
         break;
 
       case ModeBlack:
-        pFrame =
-            BlinkenFrameNew(height, width, channels, colors - 1,
-                            duration);
+        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++)
@@ -107,9 +110,7 @@ static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,
         break;
 
       case ModeWhite:
-        pFrame =
-            BlinkenFrameNew(height, width, channels, colors - 1,
-                            duration);
+        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++)
@@ -118,19 +119,29 @@ static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,
         break;
 
       case ModeGradient:
-        pFrame =
-            BlinkenFrameNew(height, width, channels, colors - 1,
-                            duration);
+        pFrame = BlinkenFrameNew(height, width, channels, colors - 1, duration);
         for (yy = 0; yy < height; yy++) {
           fy = (float)yy / (float)(height - 1);
           for (xx = 0; xx < width; xx++) {
             fx = (float)xx / (float)(width - 1);
             for (cc = 0, ccc = 0; cc < channels; cc++) {
               switch (ccc) {
-                case 0:  fc = fx;                      ccc = 1; break;
-                case 1:  fc = fy;                      ccc = 2; break;
-                case 2:  fc = 1.0f - 0.5f * (fx + fy); ccc = 0; break;
-                default: fc = 0.0f;                    ccc = 0; break;
+              case 0:
+                fc = fx;
+                ccc = 1;
+                break;
+              case 1:
+                fc = fy;
+                ccc = 2;
+                break;
+              case 2:
+                fc = 1.0f - 0.5f * (fx + fy);
+                ccc = 0;
+                break;
+              default:
+                fc = 0.0f;
+                ccc = 0;
+                break;
               }
               BlinkenFrameSetPixel(pFrame, yy, xx, cc,
                                    (int)(fc * (float)(colors - 1) + .5f));
@@ -144,15 +155,14 @@ static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,
         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,
+              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);
+                    BlinkenFrameSetPixel(
+                        pFrame, yy, xx, cc,
+                        yy == y && xx == x && cc == c ? colors - 1 : 0);
               BlinkenMovieAppendFrame(*ppMovie, pFrame);
             }
         break;
@@ -161,8 +171,7 @@ static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,
         for (c = 0; c < channels; c++) {
           for (x = 0; x < width; x++) {
             pFrame =
-                BlinkenFrameNew(height, width, channels, colors - 1,
-                                duration);
+                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++)
@@ -172,8 +181,7 @@ static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,
           }
           for (y = 0; y < height; y++) {
             pFrame =
-                BlinkenFrameNew(height, width, channels, colors - 1,
-                                duration);
+                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++)
@@ -189,14 +197,16 @@ static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,
           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,
+                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);
+                  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);
@@ -207,30 +217,64 @@ static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,
 
       case ModeRainbow:
         for (b = 0; b < width * height; b++) {
-          pFrame = BlinkenFrameNew(height, width, channels,
-                                   colors - 1, duration);
+          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++) {
                 y = b + yy + xx + cc * 8;
                 switch (y % 24) {
-                  case  0: oo = 0; break;
-                  case  1: oo = 1; break;
-                  case  2: oo = 2; break;
-                  case  3: oo = 3; break;
-                  case  4: oo = 4; break;
-                  case  5: oo = 4; break;
-                  case  6: oo = 4; break;
-                  case  7: oo = 4; break;
-                  case  8: oo = 4; break;
-                  case  9: oo = 4; break;
-                  case 10: oo = 4; break;
-                  case 11: oo = 4; break;
-                  case 12: oo = 4; break;
-                  case 13: oo = 3; break;
-                  case 14: oo = 2; break;
-                  case 15: oo = 1; break;
-                  default: oo = 0; break;
+                case 0:
+                  oo = 0;
+                  break;
+                case 1:
+                  oo = 1;
+                  break;
+                case 2:
+                  oo = 2;
+                  break;
+                case 3:
+                  oo = 3;
+                  break;
+                case 4:
+                  oo = 4;
+                  break;
+                case 5:
+                  oo = 4;
+                  break;
+                case 6:
+                  oo = 4;
+                  break;
+                case 7:
+                  oo = 4;
+                  break;
+                case 8:
+                  oo = 4;
+                  break;
+                case 9:
+                  oo = 4;
+                  break;
+                case 10:
+                  oo = 4;
+                  break;
+                case 11:
+                  oo = 4;
+                  break;
+                case 12:
+                  oo = 4;
+                  break;
+                case 13:
+                  oo = 3;
+                  break;
+                case 14:
+                  oo = 2;
+                  break;
+                case 15:
+                  oo = 1;
+                  break;
+                default:
+                  oo = 0;
+                  break;
                 }
                 oo = oo * colors / 4;
                 if (oo > colors - 1)
@@ -255,8 +299,7 @@ static void gen_test_movie(stBlinkenMovie **ppMovie, const char *str_format,
 
 static void copy_rect(stBlinkenMovie *pMovie, char *str_file,
                       const char *str_src_pos, const char *str_dim,
-                      const char *str_dest_pos)
-{
+                      const char *str_dest_pos) {
   unsigned int sy, sx, h, w, dy, dx;
   stBlinkenMovie *pSrcMovie;
 
@@ -275,23 +318,24 @@ static void copy_rect(stBlinkenMovie *pMovie, char *str_file,
 
       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 );
-
+      printf("copied %ux%u pixels from movie \"%s\" %u,%u to %u,%u\n", w, h,
+             str_file, sx, sy, dx, dy);
     }
   }
 }
 
-static stBlinkenMovie * scroll(stBlinkenMovie *pMovie,
-                               const char * str_direction,
+static stBlinkenMovie *scroll(stBlinkenMovie *pMovie, const char *str_direction,
                               const char *str_width_height,
-                               const char * str_duration)
-{
+                              const char *str_duration) {
   enum {
-    DirNone, DirLeft, DirRight, DirUp, DirDown,
+    DirNone,
+    DirLeft,
+    DirRight,
+    DirUp,
+    DirDown,
   } dir = DirNone;
-  int width_height, duration, height, width, channels, maxval,
-      new_height, new_width, sy, sx, dy, dx, steps, step;
+  int width_height, duration, height, width, channels, maxval, new_height,
+      new_width, sy, sx, dy, dx, steps, step;
   stBlinkenFrame *pScroll, *pFrame;
 
   // direction
@@ -388,14 +432,13 @@ static stBlinkenMovie * scroll(stBlinkenMovie *pMovie,
   BlinkenFrameFree(pScroll);
 
   printf("scrolled %ux%u-%u/%u frame to %ux%u-%u/%u movie (direction %s)\n",
-         width, height, channels, maxval + 1,
-         new_width, new_height, channels, maxval + 1, str_direction);
+         width, height, channels, maxval + 1, new_width, new_height, channels,
+         maxval + 1, str_direction);
 
   return pMovie;
 }
 
-int main(int argCnt, char **args)
-{
+int main(int argCnt, char **args) {
   stBlinkenMovie *pMovie;
   int i;
   char *str;
@@ -424,12 +467,15 @@ int main(int argCnt, char **args)
 #else
 #define GIFEXT
 #endif
-    printf("syntax: %s <parameter> [...]\n\n"
+    printf(
+        "syntax: %s <parameter> [...]\n\n"
         "parameters:\n"
         "  -i <file>\n"
-           "     read movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT ")\n"
+        "     read movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT
+        ")\n"
         "  -a <file>\n"
-           "     append movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT ")\n"
+        "     append movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT
+        ")\n"
         "  -l <number>\n"
         "     loop video a number of times\n"
         "  -f\n"
@@ -477,7 +523,8 @@ int main(int argCnt, char **args)
         "  -Md2\n"
         "     mirror movie diagonally (/)\n"
         "  -o <file>\n"
-           "     write movie to file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT ")\n\n"
+        "     write movie to file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT
+        ")\n\n"
         "test_modes: black, white, gradient, dots, lines, trans, rainbow\n\n"
         "old syntax: %s <input-file> [<output-file>]\n\n",
         args[0], args[0]);
@@ -517,8 +564,7 @@ int main(int argCnt, char **args)
           else {
             if (BlinkenMovieConcat(pMovie, pMovie2) < 0) {
               BlinkenMovieFree(pMovie2);
-              printf("movie read from \"%s\" could not be appended\n",
-                     args[i]);
+              printf("movie read from \"%s\" could not be appended\n", args[i]);
             } else
               printf("movie \"%s\" read and appended\n", args[i]);
           }
@@ -567,16 +613,14 @@ int main(int argCnt, char **args)
     // 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");
+        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",
+        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));
+            BlinkenMovieGetChannels(pMovie), BlinkenMovieGetMaxval(pMovie) + 1,
+            BlinkenMovieGetFrameCnt(pMovie), BlinkenMovieGetDuration(pMovie));
     }
     // print movie
     else if (strcmp(args[i], "-p") == 0) {
@@ -596,8 +640,7 @@ int main(int argCnt, char **args)
     else if (strcmp(args[i], "-r") == 0) {
       if (i + 1 < argCnt) {
         i++;
-        if (sscanf
-            (args[i], "%ux%u-%u/%u", &width, &height, &channels,
+        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)
@@ -618,11 +661,9 @@ int main(int argCnt, char **args)
         topleft = args[i];
         i++;
         dimensions = args[i];
-        if (sscanf
-            (topleft, "%u,%u", &left, &top) != 2)
+        if (sscanf(topleft, "%u,%u", &left, &top) != 2)
           printf("invalid top-left position \"%s\"\n", topleft);
-        else if (sscanf
-            (dimensions, "%ux%u", &width, &height) != 2)
+        else if (sscanf(dimensions, "%ux%u", &width, &height) != 2)
           printf("invalid movie dimensions \"%s\"\n", dimensions);
         else if (pMovie == NULL)
           printf("no movie loaded to crop\n");
@@ -707,8 +748,7 @@ int main(int argCnt, char **args)
           BlinkenMovieCutTime(pMovie, begin, end);
           printf("movie cut to time %u-%u\n", begin, end);
         }
-      }
-      else if (i + 1 < argCnt) {
+      } else if (i + 1 < argCnt) {
         printf("missing end time for \"-ct\"\n");
         i++;
       } else
@@ -764,8 +804,7 @@ int main(int argCnt, char **args)
             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",
+            printf("invalid frame range (%u-%u) for deletion from %u frames\n",
                    first, first + count,
                    (unsigned int)BlinkenMovieGetFrameCnt(pMovie));
           else {
@@ -942,8 +981,8 @@ int main(int argCnt, char **args)
     }
     // 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]);
+      printf("old style input filename \"%s\", better use \"-i %s\"\n", args[i],
+             args[i]);
       if (pMovie != NULL)
         BlinkenMovieFree(pMovie);
       pMovie = BlinkenMovieLoad(args[i]);
@@ -965,8 +1004,7 @@ int main(int argCnt, char **args)
     }
     // unknown parameter
     else
-      printf
-          ("unknown parameter \"%s\", call without parameters to get help\n",
+      printf("unknown parameter \"%s\", call without parameters to get help\n",
              args[i]);
 
   } // for( i ...

tools/BlinkenDeviceOutput.c

View file @ 860e91b

@@ -7,21 +7,19 @@
 
 #include <errno.h>
 #include <fcntl.h>
-#include <stdlib.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <termios.h>
 #include <time.h>
 #include <unistd.h>
-#include <sys/time.h>
-#include <sys/types.h>
 
 #include <BlinkenLib/BlinkenLib.h>
 
 // get serial settings from text
-static int serial_settings_parse(char *str, int *settings, int *speed)
-{
+static int serial_settings_parse(char *str, int *settings, int *speed) {
   int baud, data, stop;
   char parity;
   int set = 0, sp = 0;
@@ -32,7 +30,8 @@ static int serial_settings_parse(char *str, int *settings, int *speed)
 
     // baud rate
 #define BAUD(rate) else if (baud == rate) sp = B##rate;
-  if (0) {}
+  if (0) {
+  }
   BAUD(300)
   BAUD(600)
   BAUD(1200)
@@ -128,8 +127,7 @@ static int serial_settings_parse(char *str, int *settings, int *speed)
 
 // convert serial settings to text
 static void serial_settings_to_str(int settings, char *buf,
-                                   unsigned int maxlen)
-{
+                                   unsigned int maxlen) {
   int baud, data, stop;
   char parity;
 
@@ -188,8 +186,7 @@ static void serial_settings_to_str(int settings, char *buf,
 }
 
 // set serial settings for fd
-static int serial_settings_set(int fd, int settings, int speed)
-{
+static int serial_settings_set(int fd, int settings, int speed) {
   struct termios tio;
 
   // set port settings
@@ -222,11 +219,9 @@ static int serial_settings_set(int fd, int settings, int speed)
 // dev_fd may be -1 for not doing anything with device
 // returns error code (not for device-errors, 0 for success)
 static int out_movie(stBlinkenMovie *pMovie, int dev_fd,
-                     unsigned int format_change,
-                     unsigned int format_height, unsigned int format_width,
-                     unsigned int format_channels,
-                     unsigned int format_colors, etBlinkenProto proto)
-{
+                     unsigned int format_change, unsigned int format_height,
+                     unsigned int format_width, unsigned int format_channels,
+                     unsigned int format_colors, etBlinkenProto proto) {
   int frame_cnt, frame;
   stBlinkenFrame *pFrame;
   fd_set readFds, errFds;
@@ -255,8 +250,8 @@ static int out_movie(stBlinkenMovie *pMovie, int dev_fd,
 
     // change format
     if (format_change)
-      BlinkenFrameResize(pFrame, format_height, format_width,
-                         format_channels, format_colors - 1);
+      BlinkenFrameResize(pFrame, format_height, format_width, format_channels,
+                         format_colors - 1);
 
     // create output data from frame
     len = BlinkenFrameToNetwork(pFrame, proto, buffer, sizeof(buffer));
@@ -333,14 +328,12 @@ static int out_movie(stBlinkenMovie *pMovie, int dev_fd,
 // open device and output movie
 // returns error code (not for device-errors, 0 for success)
 static int open_and_output(stBlinkenMovie *pMovie, char *device,
-                           int serial_settings_change,
-                           int serial_settings, int serial_speed,
-                           unsigned int format_change,
+                           int serial_settings_change, int serial_settings,
+                           int serial_speed, unsigned int format_change,
                            unsigned int format_height,
                            unsigned int format_width,
                            unsigned int format_channels,
-                           unsigned int format_colors, etBlinkenProto proto)
-{
+                           unsigned int format_colors, etBlinkenProto proto) {
   int dev_fd, err;
   char txt[64];
 
@@ -362,8 +355,7 @@ static int open_and_output(stBlinkenMovie *pMovie, char *device,
     }
   }
   // output movie to device
-  err = out_movie(pMovie, dev_fd,
-                  format_change, format_height, format_width,
+  err = out_movie(pMovie, dev_fd, format_change, format_height, format_width,
                   format_channels, format_colors, proto);
 
   // close device
@@ -374,8 +366,7 @@ static int open_and_output(stBlinkenMovie *pMovie, char *device,
   return err;
 }
 
-int main(int argCnt, char **args)
-{
+int main(int argCnt, char **args) {
   int i, serial_settings, serial_speed;
   char *device;
   etBlinkenProto proto;
@@ -421,7 +412,8 @@ int main(int argCnt, char **args)
            "  -n <number>\n"
            "     set number of times to send movies (defaults to 1)\n"
            "  -i <file>\n"
-           "     read movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT ") and send it\n"
+           "     read movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT
+           ") and send it\n"
            "  -l <number>\n"
            "     loop number of times (defaults to 1, use 0 for forever)\n\n",
            args[0]);
@@ -471,10 +463,10 @@ int main(int argCnt, char **args)
       else if (strcmp(args[i], "-f") == 0) {
         if (i + 1 < argCnt) {
           i++;
-          if (sscanf
-              (args[i], "%ux%u-%u/%u", &width, &height, &channels, &colors) == 4
-              && width > 0 && width < 1000 && height > 0 && height < 1000
-              && channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
+          if (sscanf(args[i], "%ux%u-%u/%u", &width, &height, &channels,
+                     &colors) == 4 &&
+              width > 0 && width < 1000 && height > 0 && height < 1000 &&
+              channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
             format_change = 1;
             format_height = height;
             format_width = width;
@@ -528,9 +520,9 @@ int main(int argCnt, char **args)
               printf("outputting movie \"%s\" (%u/%u)...\n", args[i], ui + 1,
                      send_cnt);
               if (open_and_output(pMovie, device, serial_settings_change,
-                                  serial_settings, serial_speed,
-                                  format_change, format_height, format_width,
-                                  format_channels, format_colors, proto) == 0) {
+                                  serial_settings, serial_speed, format_change,
+                                  format_height, format_width, format_channels,
+                                  format_colors, proto) == 0) {
                 printf("movie \"%s\" output successful\n", args[i]);
               } else {
                 printf("movie \"%s\" output failed\n", args[i]);
@@ -555,8 +547,8 @@ int main(int argCnt, char **args)
       }
       // unknown parameter
       else
-        printf
-            ("unknown parameter \"%s\", call without parameters to get help\n",
+        printf(
+            "unknown parameter \"%s\", call without parameters to get help\n",
             args[i]);
 
     } // for( i ...

tools/BlinkenOutput.c

View file @ 860e91b

@@ -5,25 +5,24 @@
 /* OS X support by Manfred Wuits
    <manfred@werkzeugH.at> */
 
+#include <arpa/inet.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <stdlib.h>
+#include <netinet/in.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <termios.h>
 #include <time.h>
 #include <unistd.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/socket.h>
 
 #include <BlinkenLib/BlinkenLib.h>
 
 // get serial settings from text
-static int serial_settings_parse(char *str, int *settings, int *speed)
-{
+static int serial_settings_parse(char *str, int *settings, int *speed) {
   int baud, data, stop;
   char parity;
   int set = 0, sp = 0;
@@ -34,7 +33,8 @@ static int serial_settings_parse(char *str, int *settings, int *speed)
 
     // baud rate
 #define BAUD(rate) else if (baud == rate) sp = B##rate;
-  if (0) {}
+  if (0) {
+  }
   BAUD(300)
   BAUD(600)
   BAUD(1200)
@@ -130,8 +130,7 @@ static int serial_settings_parse(char *str, int *settings, int *speed)
 
 // convert serial settings to text
 static void serial_settings_to_str(int settings, char *buf,
-                                   unsigned int maxlen)
-{
+                                   unsigned int maxlen) {
   int baud, data, stop;
   char parity;
 
@@ -190,8 +189,7 @@ static void serial_settings_to_str(int settings, char *buf,
 }
 
 // set serial settings for fd
-static int serial_settings_set(int fd, int settings, int speed)
-{
+static int serial_settings_set(int fd, int settings, int speed) {
   struct termios tio;
 
   // set port settings
@@ -226,12 +224,10 @@ static int serial_settings_set(int fd, int settings, int speed)
 static int recv_and_out(SOCKET udpSocket, int dev_fd,
                         int *p_device_output_active,
                         unsigned int min_interval_ms,
-                        unsigned int format_change,
-                        unsigned int format_height, unsigned int format_width,
-                        unsigned int format_channels,
+                        unsigned int format_change, unsigned int format_height,
+                        unsigned int format_width, unsigned int format_channels,
                         unsigned int format_colors, etBlinkenProto proto,
-                        int use_msecs, unsigned int msecs)
-{
+                        int use_msecs, unsigned int msecs) {
   fd_set readFds, errFds;
   stBlinkenFrame *pFrame;
   char buffer[65536]; // 64kB is more than maximum UDP size
@@ -373,17 +369,13 @@ static int recv_and_out(SOCKET udpSocket, int dev_fd,
 
 // open device and output frames
 // returns error code (not for device-errors, 0 for success)
-static int open_and_output(SOCKET udpSocket, char *device,
-                           int *p_device_output_active,
+static int
+open_and_output(SOCKET udpSocket, char *device, int *p_device_output_active,
                 int serial_settings_change, int serial_settings,
-                           int serial_speed,
-                           unsigned int min_interval_ms,
-                           unsigned int format_change,
-                           unsigned int format_height,
-                           unsigned int format_width,
-                           unsigned int format_channels,
-                           unsigned int format_colors, etBlinkenProto proto)
-{
+                int serial_speed, unsigned int min_interval_ms,
+                unsigned int format_change, unsigned int format_height,
+                unsigned int format_width, unsigned int format_channels,
+                unsigned int format_colors, etBlinkenProto proto) {
   int dev_fd, err;
   char txt[64];
 
@@ -406,8 +398,7 @@ static int open_and_output(SOCKET udpSocket, char *device,
     }
   }
   // receive frames and output to device
-  err = recv_and_out(udpSocket, dev_fd, p_device_output_active,
-                     min_interval_ms,
+  err = recv_and_out(udpSocket, dev_fd, p_device_output_active, min_interval_ms,
                      format_change, format_height, format_width,
                      format_channels, format_colors, proto, 0, 0);
 
@@ -419,19 +410,14 @@ static int open_and_output(SOCKET udpSocket, char *device,
 
 // open device and output frames in a loop
 // returns error code (not for device-errors, 0 for success)
-static int open_and_output_loop(SOCKET udpSocket, char *device,
-                                int serial_settings_change,
-                                int serial_settings, int serial_speed,
-                                int reopen_device,
+static int
+open_and_output_loop(SOCKET udpSocket, char *device, int serial_settings_change,
+                     int serial_settings, int serial_speed, int reopen_device,
                      unsigned int reopen_device_ms,
-                                unsigned int min_interval_ms,
-                                unsigned int format_change,
-                                unsigned int format_height,
-                                unsigned int format_width,
-                                unsigned int format_channels,
-                                unsigned int format_colors,
-                                etBlinkenProto proto)
-{
+                     unsigned int min_interval_ms, unsigned int format_change,
+                     unsigned int format_height, unsigned int format_width,
+                     unsigned int format_channels, unsigned int format_colors,
+                     etBlinkenProto proto) {
   int device_output_active, err;
 
   printf("receiving frames and outputting them to \"%s\"...\n", device);
@@ -440,13 +426,10 @@ static int open_and_output_loop(SOCKET udpSocket, char *device,
   for (;;) {
 
     // try to open device and output frames
-    err = open_and_output(udpSocket, device,
-                          &device_output_active,
-                          serial_settings_change, serial_settings,
-                          serial_speed, min_interval_ms,
-                          format_change, format_height,
-                          format_width, format_channels, format_colors,
-                          proto);
+    err = open_and_output(udpSocket, device, &device_output_active,
+                          serial_settings_change, serial_settings, serial_speed,
+                          min_interval_ms, format_change, format_height,
+                          format_width, format_channels, format_colors, proto);
     if (err != 0 || !reopen_device)
       break;
 
@@ -456,8 +439,7 @@ static int open_and_output_loop(SOCKET udpSocket, char *device,
     device_output_active = 0;
 
     // only fetch data from socket for a short time
-    err = recv_and_out(udpSocket, -1, &device_output_active,
-                       min_interval_ms,
+    err = recv_and_out(udpSocket, -1, &device_output_active, min_interval_ms,
                        format_change, format_height, format_width,
                        format_channels, format_colors, proto, 1,
                        reopen_device_ms);
@@ -474,8 +455,7 @@ static int open_and_output_loop(SOCKET udpSocket, char *device,
   return err;
 }
 
-int main(int argCnt, char **args)
-{
+int main(int argCnt, char **args) {
   int i, bound, serial_settings, serial_speed;
   SOCKET udpSocket;
   etBlinkenProto proto;
@@ -501,7 +481,8 @@ int main(int argCnt, char **args)
 
   // print syntax
   if (argCnt <= 1) {
-    printf("syntax: %s <parameter> [...]\n\n"
+    printf(
+        "syntax: %s <parameter> [...]\n\n"
         "parameters:\n"
         "  -l [<ip>:]<port>\n"
         "     local address (defaults to 0.0.0.0:2323)\n"
@@ -517,10 +498,12 @@ int main(int argCnt, char **args)
         "  -s <baud-rate>,<parity>,<data-bits>,<stop-bits>\n"
         "     settings to use for serial devices (defaults to no change)\n"
         "  -o <milliseconds>\n"
-           "     reopen device after short time on error (defaults to not reopen)\n"
+        "     reopen device after short time on error (defaults to not "
+        "reopen)\n"
         "  -i <milliseconds>\n"
         "     minimum interval between two frames on output (defaults to 0)\n"
-           "\n", args[0]);
+        "\n",
+        args[0]);
     return 0;
   }
   // create udp socket
@@ -611,10 +594,10 @@ int main(int argCnt, char **args)
     else if (strcmp(args[i], "-f") == 0) {
       if (i + 1 < argCnt) {
         i++;
-        if (sscanf
-            (args[i], "%ux%u-%u/%u", &width, &height, &channels, &colors) == 4
-            && width > 0 && width < 1000 && height > 0 && height < 1000
-            && channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
+        if (sscanf(args[i], "%ux%u-%u/%u", &width, &height, &channels,
+                   &colors) == 4 &&
+            width > 0 && width < 1000 && height > 0 && height < 1000 &&
+            channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
           format_change = 1;
           format_height = height;
           format_width = width;
@@ -648,8 +631,8 @@ int main(int argCnt, char **args)
     else if (strcmp(args[i], "-o") == 0) {
       if (i + 1 < argCnt) {
         i++;
-        if (sscanf(args[i], "%u", &reopen_device_ms) == 1
-            && reopen_device_ms >= 1)
+        if (sscanf(args[i], "%u", &reopen_device_ms) == 1 &&
+            reopen_device_ms >= 1)
           reopen_device = 1;
         else
           printf("invalid number of milliseconds \"%s\"\n", args[i]);
@@ -669,8 +652,7 @@ int main(int argCnt, char **args)
     }
     // unknown parameter
     else
-      printf
-          ("unknown parameter \"%s\", call without parameters to get help\n",
+      printf("unknown parameter \"%s\", call without parameters to get help\n",
              args[i]);
 
   } // for( i ...
@@ -691,11 +673,10 @@ int main(int argCnt, char **args)
     }
   }
   // open device and output frames in a loop
-  open_and_output_loop(udpSocket, device,
-                       serial_settings_change, serial_settings, serial_speed,
-                       reopen_device, reopen_device_ms, min_interval_ms,
-                       format_change, format_height, format_width,
-                       format_channels, format_colors, proto);
+  open_and_output_loop(
+      udpSocket, device, serial_settings_change, serial_settings, serial_speed,
+      reopen_device, reopen_device_ms, min_interval_ms, format_change,
+      format_height, format_width, format_channels, format_colors, proto);
 
   // close socket
   close(udpSocket);

tools/BlinkenOutputWin.c

View file @ 860e91b

@@ -4,11 +4,11 @@
    a blinkenarea.org project */
 
 #include <fcntl.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <winsock2.h>
 #include <windows.h>
+#include <winsock2.h>
 
 #include <BlinkenLib/BlinkenLib.h>
 
@@ -23,8 +23,7 @@ struct s_serial_settings {
 
 // get serial settings from text
 static int serial_settings_parse(char *str,
-                                 struct s_serial_settings *serial_settings)
-{
+                                 struct s_serial_settings *serial_settings) {
   int baud, data, stop;
   char parity;
 
@@ -117,8 +116,8 @@ static int serial_settings_parse(char *str,
 }
 
 // set serial settings for fd
-static int serial_settings_set(HANDLE hDev, struct s_serial_settings *settings)
-{
+static int serial_settings_set(HANDLE hDev,
+                               struct s_serial_settings *settings) {
   DCB PortDcb;
   COMMTIMEOUTS CommTimeouts;
 
@@ -164,14 +163,12 @@ static int serial_settings_set(HANDLE hDev, struct s_serial_settings *settings)
 // hDev may be INVALID_HANDLE_VALUE for not doing anything with device
 // returns error code (not for device-errors, 0 for success)
 static int recv_and_out(SOCKET udpSocket, HANDLE hDev,
-                        int *p_device_output_active,
-                        unsigned int format_change,
+                        int *p_device_output_active, unsigned int format_change,
                         unsigned int format_height, unsigned int format_width,
                         unsigned int format_channels,
                         unsigned int format_colors, etBlinkenProto proto,
                         int use_msecs, unsigned int msecs,
-                        int is_serial_device)
-{
+                        int is_serial_device) {
   fd_set readFds, errFds;
   stBlinkenFrame *pFrame;
   char buffer[65536]; // 64kB is more than maximum UDP size
@@ -231,8 +228,8 @@ static int recv_and_out(SOCKET udpSocket, HANDLE hDev,
 
         // output data to device
         if (hDev != INVALID_HANDLE_VALUE && len > 0) {
-          if (!WriteFile(hDev, buffer, len, &DevWrLen, NULL)
-              || (int)DevWrLen != len) {
+          if (!WriteFile(hDev, buffer, len, &DevWrLen, NULL) ||
+              (int)DevWrLen != len) {
             if (*p_device_output_active)
               printf("error writing to device: error %lu\n", GetLastError());
             break;
@@ -273,23 +270,19 @@ static int recv_and_out(SOCKET udpSocket, HANDLE hDev,
 
 // open device and output frames
 // returns error code (not for device-errors, 0 for success)
-static int open_and_output(SOCKET udpSocket, char *device,
-                           int *p_device_output_active,
+static int
+open_and_output(SOCKET udpSocket, char *device, int *p_device_output_active,
                 int serial_settings_change,
                 struct s_serial_settings *serial_settings,
-                           unsigned int format_change,
-                           unsigned int format_height,
-                           unsigned int format_width,
-                           unsigned int format_channels,
-                           unsigned int format_colors, etBlinkenProto proto)
-{
+                unsigned int format_change, unsigned int format_height,
+                unsigned int format_width, unsigned int format_channels,
+                unsigned int format_colors, etBlinkenProto proto) {
   HANDLE hDev;
   int err;
 
   // open device
-  hDev =
-      CreateFile(device, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
-                 0, NULL);
+  hDev = CreateFile(device, GENERIC_READ | GENERIC_WRITE, 0, NULL,
+                    OPEN_EXISTING, 0, NULL);
   if (hDev == INVALID_HANDLE_VALUE) {
     if (*p_device_output_active)
       printf("could not open \"%s\": error %lu\n", device, GetLastError());
@@ -305,10 +298,9 @@ static int open_and_output(SOCKET udpSocket, char *device,
     }
   }
   // receive frames and output to device
-  err = recv_and_out(udpSocket, hDev, p_device_output_active,
-                     format_change, format_height, format_width,
-                     format_channels, format_colors, proto, 0, 0,
-                     serial_settings_change);
+  err = recv_and_out(udpSocket, hDev, p_device_output_active, format_change,
+                     format_height, format_width, format_channels,
+                     format_colors, proto, 0, 0, serial_settings_change);
 
   // close device
   CloseHandle(hDev);
@@ -318,18 +310,13 @@ static int open_and_output(SOCKET udpSocket, char *device,
 
 // open device and output frames in a loop
 // returns error code (not for device-errors, 0 for success)
-static int open_and_output_loop(SOCKET udpSocket, char *device,
-                                int serial_settings_change,
+static int
+open_and_output_loop(SOCKET udpSocket, char *device, int serial_settings_change,
                      struct s_serial_settings *serial_settings,
-                                int reopen_device,
-                                unsigned int reopen_device_ms,
-                                unsigned int format_change,
-                                unsigned int format_height,
-                                unsigned int format_width,
-                                unsigned int format_channels,
-                                unsigned int format_colors,
-                                etBlinkenProto proto)
-{
+                     int reopen_device, unsigned int reopen_device_ms,
+                     unsigned int format_change, unsigned int format_height,
+                     unsigned int format_width, unsigned int format_channels,
+                     unsigned int format_colors, etBlinkenProto proto) {
   int device_output_active, err;
 
   printf("receiving frames and outputting them to \"%s\"...\n", device);
@@ -338,8 +325,7 @@ static int open_and_output_loop(SOCKET udpSocket, char *device,
   for (;;) {
 
     // try to open device and output frames
-    err = open_and_output(udpSocket, device,
-                          &device_output_active,
+    err = open_and_output(udpSocket, device, &device_output_active,
                           serial_settings_change, serial_settings,
                           format_change, format_height, format_width,
                           format_channels, format_colors, proto);
@@ -369,8 +354,7 @@ static int open_and_output_loop(SOCKET udpSocket, char *device,
   return err;
 }
 
-int main(int argCnt, char **args)
-{
+int main(int argCnt, char **args) {
   WSADATA WsaData;
   int i, bound;
   SOCKET udpSocket;
@@ -410,8 +394,10 @@ int main(int argCnt, char **args)
            "  -s <baud-rate>,<parity>,<data-bits>,<stop-bits>\n"
            "     settings to use for serial devices (defaults to no change)\n"
            "  -o <milliseconds>\n"
-           "     reopen device after short time on error (defaults to not reopen)\n"
-           "\n", args[0]);
+           "     reopen device after short time on error (defaults to not "
+           "reopen)\n"
+           "\n",
+           args[0]);
     return 0;
   }
 
@@ -511,10 +497,10 @@ int main(int argCnt, char **args)
     else if (strcmp(args[i], "-f") == 0) {
       if (i + 1 < argCnt) {
         i++;
-        if (sscanf
-            (args[i], "%ux%u-%u/%u", &width, &height, &channels, &colors) == 4
-            && width > 0 && width < 1000 && height > 0 && height < 1000
-            && channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
+        if (sscanf(args[i], "%ux%u-%u/%u", &width, &height, &channels,
+                   &colors) == 4 &&
+            width > 0 && width < 1000 && height > 0 && height < 1000 &&
+            channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
           format_change = 1;
           format_height = height;
           format_width = width;
@@ -548,8 +534,8 @@ int main(int argCnt, char **args)
     else if (strcmp(args[i], "-o") == 0) {
       if (i + 1 < argCnt) {
         i++;
-        if (sscanf(args[i], "%u", &reopen_device_ms) == 1
-            && reopen_device_ms >= 1)
+        if (sscanf(args[i], "%u", &reopen_device_ms) == 1 &&
+            reopen_device_ms >= 1)
           reopen_device = 1;
         else
           printf("invalid number of milliseconds \"%s\"\n", args[i]);
@@ -558,8 +544,7 @@ int main(int argCnt, char **args)
     }
     // unknown parameter
     else
-      printf
-          ("unknown parameter \"%s\", call without parameters to get help\n",
+      printf("unknown parameter \"%s\", call without parameters to get help\n",
              args[i]);
 
   } // for( i ...
@@ -580,9 +565,8 @@ int main(int argCnt, char **args)
     }
   }
   // open device and output frames in a loop
-  open_and_output_loop(udpSocket, device,
-                       serial_settings_change, &serial_settings,
-                       reopen_device, reopen_device_ms,
+  open_and_output_loop(udpSocket, device, serial_settings_change,
+                       &serial_settings, reopen_device, reopen_device_ms,
                        format_change, format_height, format_width,
                        format_channels, format_colors, proto);
 

tools/BlinkenRecv.c

View file @ 860e91b

@@ -11,18 +11,17 @@
 #include <ws2tcpip.h>
 #define close closesocket
 #else
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
 #include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
 #endif
 
-#include <BlinkenLib/BlinkenLib.h>
 #include "Tools2.h"
+#include <BlinkenLib/BlinkenLib.h>
 
-int main(int argCnt, char **args)
-{
+int main(int argCnt, char **args) {
   int i, bound, val, timeout, ipv6;
   SOCKET udpSocket, tmpSock;
   struct sockaddr_in addr;
@@ -65,7 +64,8 @@ int main(int argCnt, char **args)
            "  -t <milliseconds>\n"
            "     set timeout (to detect movie end, defaults to 5000)\n"
            "  -o <file>\n"
-           "     receive movie and write it to file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT ")\n\n",
+           "     receive movie and write it to file (*.blm, *.bmm, *.bml, "
+           "*.bbm" MNGEXT GIFEXT ")\n\n",
            args[0]);
     return 0;
   }
@@ -213,8 +213,7 @@ int main(int argCnt, char **args)
     }
     // unknown parameter
     else
-      printf
-          ("unknown parameter \"%s\", call without parameters to get help\n",
+      printf("unknown parameter \"%s\", call without parameters to get help\n",
              args[i]);
 
   } // for( i ...

tools/BlinkenSend.c

View file @ 860e91b

@@ -12,18 +12,17 @@
 #define close closesocket
 #define strcasecmp stricmp
 #else
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
 #include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
 #endif
 
-#include <BlinkenLib/BlinkenLib.h>
 #include "Tools2.h"
+#include <BlinkenLib/BlinkenLib.h>
 
-int main(int argCnt, char **args)
-{
+int main(int argCnt, char **args) {
   int i, connected, ipv6;
   SOCKET udpSocket, tmpSock;
   etBlinkenProto proto;
@@ -68,11 +67,13 @@ int main(int argCnt, char **args)
            "  -p [BLP|EBLP|MCUF]\n"
            "     protocol to use (defaults to MCUF)\n"
            "  -t <milliseconds>\n"
-           "     set maximum idle time between frames (defaults to 3000, use 0 for infinite)\n"
+           "     set maximum idle time between frames (defaults to 3000, use 0 "
+           "for infinite)\n"
            "  -n <number>\n"
            "     set number of times to send movies (defaults to 1)\n"
            "  -i <file>\n"
-           "     read movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT ") and send it\n"
+           "     read movie from file (*.blm, *.bmm, *.bml, *.bbm" MNGEXT GIFEXT
+           ") and send it\n"
            "  -l <number>\n"
            "     loop number of times (defaults to 1, use 0 for forever)\n\n",
            args[0]);
@@ -162,18 +163,15 @@ int main(int argCnt, char **args)
           i++;
           if (!ipv6) {
             if (!txt2addr(args[i], &addr) ||
-                connect(udpSocket, (struct sockaddr *)&addr,
-                        sizeof(addr)) != 0)
-                printf("could not set destination address to \"%s\"\n",
-                       args[i]);
+                connect(udpSocket, (struct sockaddr *)&addr, sizeof(addr)) != 0)
+              printf("could not set destination address to \"%s\"\n", args[i]);
             else
               connected = 1;
           } else {
             if (!txt2addr6(args[i], &addr6) ||
-                connect(udpSocket, (struct sockaddr *)&addr6,
-                        sizeof(addr6)) != 0)
-                printf("could not set destination address to \"%s\"\n",
-                       args[i]);
+                connect(udpSocket, (struct sockaddr *)&addr6, sizeof(addr6)) !=
+                    0)
+              printf("could not set destination address to \"%s\"\n", args[i]);
             else
               connected = 1;
           }
@@ -228,9 +226,10 @@ int main(int argCnt, char **args)
                      "  using default destination address \"127.0.0.1:2323\"\n",
                      args[i]);
               if (!txt2addr("127.0.0.1:2323", &addr) ||
-                  connect(udpSocket, (struct sockaddr *)&addr,
-                          sizeof(addr)) != 0)
-                printf("could not set destination address to \"127.0.0.1:2323\"\n");
+                  connect(udpSocket, (struct sockaddr *)&addr, sizeof(addr)) !=
+                      0)
+                printf("could not set destination address to "
+                       "\"127.0.0.1:2323\"\n");
               else
                 connected = 1;
             } else {
@@ -260,8 +259,7 @@ int main(int argCnt, char **args)
               BlinkenMovieFree(pMovie);
             }
           } else
-            printf("no destination address to sent movie \"%s\" to\n",
-                   args[i]);
+            printf("no destination address to sent movie \"%s\" to\n", args[i]);
         } else
           printf("missing input filename for \"-i\"\n");
       }
@@ -278,8 +276,8 @@ int main(int argCnt, char **args)
       }
       // unknown parameter
       else
-        printf
-            ("unknown parameter \"%s\", call without parameters to get help\n",
+        printf(
+            "unknown parameter \"%s\", call without parameters to get help\n",
             args[i]);
 
     } // for( i ...

tools/Tools2.c

View file @ 860e91b

@@ -10,17 +10,16 @@
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #else
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
 #include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
 #endif
 
 #include "Tools2.h"
 
 #ifdef WIN32
-static int inet_pton(int af, const char *src, void *dst)
-{
+static int inet_pton(int af, const char *src, void *dst) {
   struct sockaddr_storage ss;
   int size = sizeof(ss);
   char src_copy[INET6_ADDRSTRLEN + 1];
@@ -29,7 +28,8 @@ static int inet_pton(int af, const char *src, void *dst)
   strncpy(src_copy, src, sizeof(src_copy));
   src_copy[sizeof(src_copy) - 1] = 0;
 
-  if (WSAStringToAddress(src_copy, af, NULL, (struct sockaddr *)&ss, &size) == 0) {
+  if (WSAStringToAddress(src_copy, af, NULL, (struct sockaddr *)&ss, &size) ==
+      0) {
     switch (af) {
     case AF_INET:
       *(struct in_addr *)dst = ((struct sockaddr_in *)&ss)->sin_addr;
@@ -44,8 +44,7 @@ static int inet_pton(int af, const char *src, void *dst)
 #endif
 
 // convert text to IPv4 address
-int txt2addr(char *text, struct sockaddr_in *addr)
-{
+int txt2addr(char *text, struct sockaddr_in *addr) {
   char txt[48];
   unsigned short port;
 
@@ -70,8 +69,7 @@ int txt2addr(char *text, struct sockaddr_in *addr)
 }
 
 // convert text to IPv6 address
-int txt2addr6(char *text, struct sockaddr_in6 *addr6)
-{
+int txt2addr6(char *text, struct sockaddr_in6 *addr6) {
   char txt[128];
   unsigned short port;
 


...	...	@@ -18,8 +18,8 @@ int BlinkenColorizerStr2Mode(const char *str);
18	18	const char *BlinkenColorizerMode2Str(int mode);
19	19
20	20	// get color for colorizing
21		-unsigned char BlinkenColorizerGetColor(int channels, int mode, int step,
22		- int y, int x, int c);
	21	+unsigned char BlinkenColorizerGetColor(int channels, int mode, int step, int y,
	22	+ int x, int c);
23	23
24	24	#ifdef __cplusplus
25	25	} // extern "C"

...	...	@@ -14,8 +14,8 @@ extern "C" {
14	14
15	15	typedef struct sBlinkenFrame stBlinkenFrame;
16	16
17		-stBlinkenFrame *BlinkenFrameNew(int height, int width, int channels,
18		- int maxval, int duration);
	17	+stBlinkenFrame *BlinkenFrameNew(int height, int width, int channels, int maxval,
	18	+ int duration);
19	19
20	20	stBlinkenFrame BlinkenFrameClone(stBlinkenFrame pSrcFrame);
21	21
...	...	@@ -31,8 +31,7 @@ int BlinkenFrameGetMaxval(stBlinkenFrame *pFrame);
31	31	int BlinkenFrameGetDuration(stBlinkenFrame *pFrame);
32	32	void BlinkenFrameSetDuration(stBlinkenFrame *pFrame, int duration);
33	33
34		-unsigned char BlinkenFrameGetPixel(stBlinkenFrame *pFrame, int y, int x,
35		- int c);
	34	+unsigned char BlinkenFrameGetPixel(stBlinkenFrame *pFrame, int y, int x, int c);
36	35	void BlinkenFrameSetPixel(stBlinkenFrame *pFrame, int y, int x, int c,
37	36	unsigned char val);
38	37
...	...	@@ -51,8 +50,8 @@ void BlinkenFrameSetColor(stBlinkenFrame *pFrame, int y, int x,
51	50	* \param[in] dc number of channels in area
52	51	* \param[in] pData pointer to buffer for pixel data, size must be dy * dx * dc
53	52	*/
54		-void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame,
55		- int y, int dy, int x, int dx, int c, int dc,
	53	+void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame, int y, int dy,
	54	+ int x, int dx, int c, int dc,
56	55	unsigned char *pData);
57	56
58	57	/**
...	...	@@ -66,8 +65,8 @@ void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame,
66	65	* \param[in] dc number of channels in area
67	66	* \param[in] pData pointer to new pixel data, size must be dy * dx * dc
68	67	*/
69		-void BlinkenFrameSetPixelData(stBlinkenFrame *pFrame,
70		- int y, int dy, int x, int dx, int c, int dc,
	68	+void BlinkenFrameSetPixelData(stBlinkenFrame *pFrame, int y, int dy, int x,
	69	+ int dx, int c, int dc,
71	70	unsigned char const *pData);
72	71
73	72	int BlinkenFrameIsEmpty(stBlinkenFrame *pFrame);
...	...	@@ -78,14 +77,14 @@ int BlinkenFrameCompare(stBlinkenFrame pFrame1, stBlinkenFrame pFrame2);
78	77
79	78	void BlinkenFrameResize(stBlinkenFrame *pFrame, int height, int width,
80	79	int channels, int maxval);
81		-void BlinkenFrameCrop(stBlinkenFrame *pFrame, int top, int left,
82		- int height, int width);
	80	+void BlinkenFrameCrop(stBlinkenFrame *pFrame, int top, int left, int height,
	81	+ int width);
83	82	void BlinkenFrameScale(stBlinkenFrame *pFrame, int height, int width);
84	83	void BlinkenFrameColorize(stBlinkenFrame *pFrame, int channels, int mode,
85	84	int step);
86	85	void BlinkenFrameCopyRect(stBlinkenFrame *pDest, int destY, int destX,
87		- stBlinkenFrame *pSrc, int srcY, int srcX,
88		- int height, int width);
	86	+ stBlinkenFrame *pSrc, int srcY, int srcX, int height,
	87	+ int width);
89	88
90	89	void BlinkenFrameRotateCw(stBlinkenFrame *pFrame);
91	90	void BlinkenFrameRotateCcw(stBlinkenFrame *pFrame);

...	...	@@ -6,10 +6,10 @@
6	6	#ifndef INC_BlinkenLib_BlinkenLib
7	7	#define INC_BlinkenLib_BlinkenLib
8	8
9		-#include <BlinkenLib/config.h>
10	9	#include <BlinkenLib/BlinkenColorizer.h>
11	10	#include <BlinkenLib/BlinkenFrame.h>
12	11	#include <BlinkenLib/BlinkenMovie.h>
13	12	#include <BlinkenLib/BlinkenProto.h>
	13	+#include <BlinkenLib/config.h>
14	14
15	15	#endif // #ifndef INC_BlinkenLib_BlinkenLib

...	...	@@ -6,8 +6,8 @@
6	6	#ifndef INC_BlinkenLib_BlinkenMovie
7	7	#define INC_BlinkenLib_BlinkenMovie
8	8
9		-#include <BlinkenLib/config.h>
10	9	#include <BlinkenLib/BlinkenFrame.h>
	10	+#include <BlinkenLib/config.h>
11	11
12	12	#ifdef WIN32
13	13	#include <winsock2.h>
...	...	@@ -60,8 +60,8 @@ void BlinkenMovieDeleteFrames(stBlinkenMovie *pMovie);
60	60	int BlinkenMovieConcat(stBlinkenMovie *pMovie,
61	61	stBlinkenMovie pMovie2 / appended and freed */);
62	62	void BlinkenMovieReverse(stBlinkenMovie *pMovie);
63		-void BlinkenMovieCutTime(stBlinkenMovie *pMovie,
64		- int begin /* in ms /, int end / in ms */);
	63	+void BlinkenMovieCutTime(stBlinkenMovie pMovie, int begin / in ms */,
	64	+ int end /* in ms */);
65	65	void BlinkenMovieAdaptDuration(stBlinkenMovie *pMovie,
66	66	int duration /* in ms */);
67	67	void BlinkenMovieAdaptMaxFrameDuration(stBlinkenMovie *pMovie,
...	...	@@ -69,13 +69,13 @@ void BlinkenMovieAdaptMaxFrameDuration(stBlinkenMovie *pMovie,
69	69
70	70	void BlinkenMovieResize(stBlinkenMovie *pMovie, int height, int width,
71	71	int channels, int maxval);
72		-void BlinkenMovieCrop(stBlinkenMovie *pMovie, int top, int left,
73		- int height, int width);
	72	+void BlinkenMovieCrop(stBlinkenMovie *pMovie, int top, int left, int height,
	73	+ int width);
74	74	void BlinkenMovieScale(stBlinkenMovie *pMovie, int height, int width);
75	75	void BlinkenMovieColorize(stBlinkenMovie *pMovie, int channels, int mode);
76	76	void BlinkenMovieCopyRect(stBlinkenMovie *pDest, int destY, int destX,
77		- stBlinkenMovie *pSrc, int srcY, int srcX,
78		- int height, int width);
	77	+ stBlinkenMovie *pSrc, int srcY, int srcX, int height,
	78	+ int width);
79	79
80	80	void BlinkenMovieRotateCw(stBlinkenMovie *pMovie);
81	81	void BlinkenMovieRotateCcw(stBlinkenMovie *pMovie);

...	...	@@ -10,12 +10,19 @@
10	10	extern "C" {
11	11	#endif
12	12
13		-typedef enum eBlinkenProto { BlinkenProtoNone, BlinkenProtoBlp,
14		- BlinkenProtoEblp, BlinkenProtoMcuf
	13	+typedef enum eBlinkenProto {
	14	+ BlinkenProtoNone,
	15	+ BlinkenProtoBlp,
	16	+ BlinkenProtoEblp,
	17	+ BlinkenProtoMcuf
15	18	} etBlinkenProto;
16	19
17		-typedef enum eBlinkenPacket { BlinkenPacketNone, BlinkenPacketFrame,
18		- BlinkenPacketRequest, BlinkenPacketEndRequest, BlinkenPacketStreamEnd
	20	+typedef enum eBlinkenPacket {
	21	+ BlinkenPacketNone,
	22	+ BlinkenPacketFrame,
	23	+ BlinkenPacketRequest,
	24	+ BlinkenPacketEndRequest,
	25	+ BlinkenPacketStreamEnd
19	26	} etBlinkenPacket;
20	27
21	28	int BlinkenProtoMakePacket(etBlinkenProto proto, etBlinkenPacket packet,
...	...	@@ -23,8 +30,7 @@ int BlinkenProtoMakePacket(etBlinkenProto proto, etBlinkenPacket packet,
23	30	// returns length or -1 on error
24	31
25	32	void BlinkenProtoDetectPacket(const char *pData, int length,
26		- etBlinkenProto * pProto,
27		- etBlinkenPacket * pPacket);
	33	+ etBlinkenProto pProto, etBlinkenPacket pPacket);
28	34	// returns protocol in *pProto if pProto not NULL
29	35	// returns packet type in *pPacket if pPacket not NULL
30	36

...	...	@@ -10,8 +10,7 @@
10	10	#include "Tools.h"
11	11
12	12	unsigned char BlinkenColorizerSolid(int step, int channels, int y, int x,
13		- int c)
14		-{
	13	+ int c) {
15	14	int substep, updown, chan;
16	15	step %= channels * 2 * 254;
17	16	substep = step % 254;
...	...	@@ -37,8 +36,7 @@ unsigned char BlinkenColorizerSolid(int step, int channels, int y, int x,
37	36	}
38	37
39	38	unsigned char BlinkenColorizerRainbow(int step, int channels, int y, int x,
40		- int c)
41		-{
	39	+ int c) {
42	40	return BlinkenColorizerSolid(step + ((x + y) * 64), channels, y, x, c);
43	41	}
44	42
...	...	@@ -56,8 +54,7 @@ static const BlinkenColorizingModeDesc BlinkenColorizingModeDescs[] = {
56	54
57	55	// convert string to colorizing mode
58	56	// returns colorizing mode (>= 0) or -1 on error
59		-int BlinkenColorizerStr2Mode(const char *str)
60		-{
	57	+int BlinkenColorizerStr2Mode(const char *str) {
61	58	unsigned int i;
62	59	for (i = 0; i < arr_cnt(BlinkenColorizingModeDescs); i++)
63	60	if (strcmp(str, BlinkenColorizingModeDescs[i].name) == 0)
...	...	@@ -68,17 +65,15 @@ int BlinkenColorizerStr2Mode(const char *str)
68	65	}
69	66
70	67	// convert colorizing mode to string
71		-const char *BlinkenColorizerMode2Str(int mode)
72		-{
	68	+const char *BlinkenColorizerMode2Str(int mode) {
73	69	if (mode < 0 \|\| mode >= (int)arr_cnt(BlinkenColorizingModeDescs))
74	70	return "(unknown)";
75	71	return BlinkenColorizingModeDescs[mode].name;
76	72	}
77	73
78	74	// get color for colorizing
79		-unsigned char BlinkenColorizerGetColor(int channels, int mode, int step,
80		- int y, int x, int c)
81		-{
	75	+unsigned char BlinkenColorizerGetColor(int channels, int mode, int step, int y,
	76	+ int x, int c) {
82	77	if (mode < 0 \|\| mode >= (int)arr_cnt(BlinkenColorizingModeDescs))
83	78	return 255;
84	79	return BlinkenColorizingModeDescs[mode].func(step, channels, y, x, c);

...	...	@@ -6,9 +6,9 @@
6	6	#include <gif_lib.h>
7	7	#include <stdlib.h>
8	8
9		-#include <BlinkenLib/config.h>
10	9	#include <BlinkenLib/BlinkenFrame.h>
11	10	#include <BlinkenLib/BlinkenMovie.h>
	11	+#include <BlinkenLib/config.h>
12	12
13	13	#include "BlinkenConstants.h"
14	14	#include "BlinkenGif.h"
...	...	@@ -22,8 +22,7 @@
22	22	// get color from GIF color map
23	23	static void BlinkenGifGetColor(ColorMapObject *pMap, int idx, int transparent,
24	24	unsigned char r, unsigned char g,
25		- unsigned char b, unsigned char t)
26		-{
	25	+ unsigned char b, unsigned char t) {
27	26	if (transparent >= 0 && idx == transparent) {
28	27	*t = 1;
29	28	} else {
...	...	@@ -50,8 +49,7 @@ static void BlinkenGifGetColor(ColorMapObject *pMap, int idx, int transparent,
50	49
51	50	// set pixel to GIF color
52	51	static void BlinkenGifSetPixel(ColorMapObject *pMap, int idx, int transparent,
53		- stBlinkenFrame *pFrame, int y, int x)
54		-{
	52	+ stBlinkenFrame *pFrame, int y, int x) {
55	53	unsigned char r, g, b, t;
56	54
57	55	if (pFrame != NULL) {
...	...	@@ -65,17 +63,17 @@ static void BlinkenGifSetPixel(ColorMapObject *pMap, int idx, int transparent,
65	63	}
66	64
67	65	// load a GIF file as BlinkenMovie
68		-stBlinkenMovie BlinkenGifLoad(const char pFilename)
69		-{
	66	+stBlinkenMovie BlinkenGifLoad(const char pFilename) {
70	67	GifFileType *gif;
71		- struct sPass { int ofs, stride; };
	68	+ struct sPass {
	69	+ int ofs, stride;
	70	+ };
72	71	static struct sPass const passes_linear[] = {{0, 1}, {0, 0}};
73	72	static struct sPass const passes_interlaced[] = {
74		- { 0, 8 }, { 4, 8 }, { 2, 4 }, { 1, 2 }
75		- };
	73	+ {0, 8}, {4, 8}, {2, 4}, {1, 2}};
76	74	struct sPass const *pass;
77		- int height, width, frameCnt, frameIdx, i, y, x, y1, x1,
78		- bg, disposal, delay, transp, idx;
	75	+ int height, width, frameCnt, frameIdx, i, y, x, y1, x1, bg, disposal, delay,
	76	+ transp, idx;
79	77	ColorMapObject pGlobalMap, pMap;
80	78	SavedImage *pImg;
81	79	GifImageDesc *pDesc;
...	...	@@ -158,8 +156,8 @@ stBlinkenMovie BlinkenGifLoad(const char pFilename)
158	156	}
159	157	for (pass = pDesc->Interlace ? passes_interlaced : passes_linear;
160	158	pass->stride > 0; ++pass) {
161		- for (y = pass->ofs, y1 = pDesc->Top + pass->ofs, i = 0;
162		- y < pDesc->Height; y += pass->stride, y1 += pass->stride) {
	159	+ for (y = pass->ofs, y1 = pDesc->Top + pass->ofs, i = 0; y < pDesc->Height;
	160	+ y += pass->stride, y1 += pass->stride) {
163	161	for (x = 0, x1 = pDesc->Left; x < pDesc->Width; ++x, ++x1, ++i) {
164	162	idx = pImg->RasterBits[i];
165	163	switch (disposal) {
...	...	@@ -206,11 +204,10 @@ stBlinkenMovie BlinkenGifLoad(const char pFilename)
206	204	return pMovie;
207	205	}
208	206
209		-int BlinkenGifSave(stBlinkenMovie pMovie, const char pFilename)
210		-{
	207	+int BlinkenGifSave(stBlinkenMovie pMovie, const char pFilename) {
211	208	GifFileType *gif;
212		- int frameCnt, height, width, channels, maxval, channels_new, maxval_new,
213		- r, g, b, i, frame, y, x, c, y1, x1, y2, x2, v, ret;
	209	+ int frameCnt, height, width, channels, maxval, channels_new, maxval_new, r, g,
	210	+ b, i, frame, y, x, c, y1, x1, y2, x2, v, ret;
214	211	unsigned int delay;
215	212	stBlinkenMovie *pOutMovie;
216	213	stBlinkenFrame pFrame, pLast;
...	...	@@ -236,10 +233,18 @@ int BlinkenGifSave(stBlinkenMovie pMovie, const char pFilename)
236	233	else
237	234	channels_new = channels;
238	235	switch (channels) {
239		- case 1: maxval_new = 255; break;
240		- case 2: maxval_new = 15; break;
241		- case 3: maxval_new = 5; break;
242		- default: maxval_new = 255; break;
	236	+ case 1:
	237	+ maxval_new = 255;
	238	+ break;
	239	+ case 2:
	240	+ maxval_new = 15;
	241	+ break;
	242	+ case 3:
	243	+ maxval_new = 5;
	244	+ break;
	245	+ default:
	246	+ maxval_new = 255;
	247	+ break;
243	248	}
244	249	pOutMovie = BlinkenMovieClone(pMovie);
245	250	if (pOutMovie == NULL)
...	...	@@ -308,7 +313,8 @@ int BlinkenGifSave(stBlinkenMovie pMovie, const char pFilename)
308	313	for (g = 0; g <= maxval; ++g) {
309	314	for (r = 0; r <= maxval; ++r) {
310	315	gif->SColorMap->Colors[i].Red = ((int)r * 255 + maxval / 2) / maxval;
311		- gif->SColorMap->Colors[i].Green = ((int)g * 255 + maxval / 2) / maxval;
	316	+ gif->SColorMap->Colors[i].Green =
	317	+ ((int)g * 255 + maxval / 2) / maxval;
312	318	gif->SColorMap->Colors[i].Blue = ((int)b * 255 + maxval / 2) / maxval;
313	319	++i;
314	320	}
...	...	@@ -351,10 +357,14 @@ int BlinkenGifSave(stBlinkenMovie pMovie, const char pFilename)
351	357	break;
352	358	}
353	359	if (c < channels) { // change detected at x,y
354		- if (y < y1) y1 = y;
355		- if (x < x1) x1 = x;
356		- if (y > y2) y2 = y;
357		- if (x > x2) x2 = x;
	360	+ if (y < y1)
	361	+ y1 = y;
	362	+ if (x < x1)
	363	+ x1 = x;
	364	+ if (y > y2)
	365	+ y2 = y;
	366	+ if (x > x2)
	367	+ x2 = x;
358	368	}
359	369	} // for x
360	370	} // for y
...	...	@@ -382,8 +392,8 @@ int BlinkenGifSave(stBlinkenMovie pMovie, const char pFilename)
382	392	pDesc->ColorMap = NULL;
383	393
384	394	// allocate pixel buffer
385		- pImg->RasterBits = calloc(pDesc->Width * pDesc->Height,
386		- sizeof(unsigned char));
	395	+ pImg->RasterBits =
	396	+ calloc(pDesc->Width * pDesc->Height, sizeof(unsigned char));
387	397	if (pImg->RasterBits == NULL) {
388	398	EGifCloseFile(gif GIF5_err);
389	399	BlinkenMovieFree(pOutMovie);

...	...	@@ -6,9 +6,9 @@
6	6	#ifndef INC_BlinkenLib_BlinkenGif
7	7	#define INC_BlinkenLib_BlinkenGif
8	8
9		-#include <BlinkenLib/config.h>
10	9	#include <BlinkenLib/BlinkenFrame.h>
11	10	#include <BlinkenLib/BlinkenMovie.h>
	11	+#include <BlinkenLib/config.h>
12	12
13	13	#ifndef BLINKENLIB_CFG_GIF
14	14	#error This file is to be used for GIF support only.

...	...	@@ -16,9 +16,9 @@
16	16	#define MNG_SUPPORT_WRITE
17	17	#include <libmng.h>
18	18
19		-#include <BlinkenLib/config.h>
20	19	#include <BlinkenLib/BlinkenFrame.h>
21	20	#include <BlinkenLib/BlinkenMovie.h>
	21	+#include <BlinkenLib/config.h>
22	22
23	23	#include "BlinkenConstants.h"
24	24	#include "BlinkenMng.h"
...	...	@@ -36,33 +36,28 @@ typedef struct _BlMng_userdata {
36	36	stBlinkenMovie *movie; // movie being created
37	37	} BlMng_userdata;
38	38
39		-mng_ptr BlMng_alloc(mng_size_t iSize)
40		-{
	39	+mng_ptr BlMng_alloc(mng_size_t iSize) {
41	40	void *ptr = malloc(iSize);
42	41	if (ptr != NULL)
43	42	memset(ptr, 0, iSize);
44	43	return (mng_ptr)ptr;
45	44	}
46	45
47		-void BlMng_free(mng_ptr pPtr, mng_size_t __attribute__ ((unused)) iSize)
48		-{
	46	+void BlMng_free(mng_ptr pPtr, mng_size_t __attribute__((unused)) iSize) {
49	47	free(pPtr);
50	48	}
51	49
52		-mng_bool BlMng_openstream(mng_handle __attribute__ ((unused)) hMNG)
53		-{
	50	+mng_bool BlMng_openstream(mng_handle __attribute__((unused)) hMNG) {
54	51	return MNG_TRUE;
55	52	}
56	53
57		-mng_bool BlMng_closestream(mng_handle __attribute__ ((unused)) hMNG)
58		-{
	54	+mng_bool BlMng_closestream(mng_handle __attribute__((unused)) hMNG) {
59	55	return MNG_TRUE;
60	56	}
61	57
62	58	// read data from the open file
63	59	mng_bool BlMng_readdata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,
64		- mng_uint32 * iRead)
65		-{
	60	+ mng_uint32 *iRead) {
66	61	BlMng_userdata data = (BlMng_userdata )mng_get_userdata(hMNG);
67	62	*iRead = fread(pBuf, 1, iSize, data->hFile);
68	63	return MNG_TRUE;
...	...	@@ -70,8 +65,7 @@ mng_bool BlMng_readdata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,
70	65
71	66	// write data to the open file
72	67	mng_bool BlMng_writedata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,
73		- mng_uint32 * iWritten)
74		-{
	68	+ mng_uint32 *iWritten) {
75	69	BlMng_userdata data = (BlMng_userdata )mng_get_userdata(hMNG);
76	70	*iWritten = fwrite(pBuf, 1, iSize, data->hFile);
77	71	return MNG_TRUE;
...	...	@@ -79,8 +73,7 @@ mng_bool BlMng_writedata(mng_handle hMNG, mng_ptr pBuf, mng_uint32 iSize,
79	73
80	74	// MNG library has processed the header information
81	75	mng_bool BlMng_processheader(mng_handle hMNG, mng_uint32 iWidth,
82		- mng_uint32 iHeight)
83		-{
	76	+ mng_uint32 iHeight) {
84	77	BlMng_userdata data = (BlMng_userdata )mng_get_userdata(hMNG);
85	78
86	79	// free old canvas (in case there is already one)
...	...	@@ -113,8 +106,7 @@ mng_bool BlMng_processheader(mng_handle hMNG, mng_uint32 iWidth,
113	106	}
114	107
115	108	// get access to a line of the canvas
116		-mng_ptr BlMng_getcanvasline(mng_handle hMNG, mng_uint32 iLinenr)
117		-{
	109	+mng_ptr BlMng_getcanvasline(mng_handle hMNG, mng_uint32 iLinenr) {
118	110	BlMng_userdata data = (BlMng_userdata )mng_get_userdata(hMNG);
119	111
120	112	// return pointer to line
...	...	@@ -125,20 +117,18 @@ mng_ptr BlMng_getcanvasline(mng_handle hMNG, mng_uint32 iLinenr)
125	117	}
126	118
127	119	// the MNG library thinks that (a part of) the canvas should be shown
128		-mng_bool BlMng_refresh(mng_handle __attribute__ ((unused)) hMNG, mng_uint32
129		- __attribute__ ((unused)) iX, mng_uint32
130		- __attribute__ ((unused)) iY, mng_uint32
131		- __attribute__ ((unused)) iWidth, mng_uint32
132		- __attribute__ ((unused)) iHeight)
133		-{
	120	+mng_bool BlMng_refresh(mng_handle __attribute__((unused)) hMNG,
	121	+ mng_uint32 __attribute__((unused)) iX,
	122	+ mng_uint32 __attribute__((unused)) iY,
	123	+ mng_uint32 __attribute__((unused)) iWidth,
	124	+ mng_uint32 __attribute__((unused)) iHeight) {
134	125	// nothing to do here for BlinkenLib as we are only converting and not
135	126	// displaying
136	127	return MNG_TRUE;
137	128	}
138	129
139	130	// the MNG library want to know how many milliseconds have passed
140		-mng_uint32 BlMng_gettickcount(mng_handle hMNG)
141		-{
	131	+mng_uint32 BlMng_gettickcount(mng_handle hMNG) {
142	132	BlMng_userdata data = (BlMng_userdata )mng_get_userdata(hMNG);
143	133
144	134	// just return the current number of milliseconds (only converting, do not
...	...	@@ -147,8 +137,7 @@ mng_uint32 BlMng_gettickcount(mng_handle hMNG)
147	137	}
148	138
149	139	// the MNG library wants to be be called again after some milliseconds
150		-mng_bool BlMng_settimer(mng_handle hMNG, mng_uint32 iMsecs)
151		-{
	140	+mng_bool BlMng_settimer(mng_handle hMNG, mng_uint32 iMsecs) {
152	141	BlMng_userdata data = (BlMng_userdata )mng_get_userdata(hMNG);
153	142
154	143	// just remember the number of milliseconds
...	...	@@ -160,8 +149,7 @@ mng_bool BlMng_settimer(mng_handle hMNG, mng_uint32 iMsecs)
160	149	// save as new frame to current movie
161	150	void BlMng_save_frame(stBlinkenMovie *movie, unsigned int msec,
162	151	unsigned int width, unsigned int height,
163		- unsigned char *data)
164		-{
	152	+ unsigned char *data) {
165	153	stBlinkenFrame *frame;
166	154	unsigned int c, x, y;
167	155
...	...	@@ -191,8 +179,7 @@ void BlMng_save_frame(stBlinkenMovie *movie, unsigned int msec,
191	179
192	180	// compress pixel data in a frame
193	181	void BlMng_compress_frame(stBlinkenFrame frame, unsigned char *p_out_ptr,
194		- unsigned int *p_out_len)
195		-{
	182	+ unsigned int *p_out_len) {
196	183	unsigned int width = BlinkenFrameGetWidth(frame);
197	184	unsigned int height = BlinkenFrameGetHeight(frame);
198	185	// channels is always 3, maxval is always 255 - this function is only
...	...	@@ -233,8 +220,7 @@ void BlMng_compress_frame(stBlinkenFrame frame, unsigned char *p_out_ptr,
233	220	}
234	221
235	222	// load a MNG file as BlinkenMovie
236		-stBlinkenMovie BlinkenMngLoad(const char pFilename)
237		-{
	223	+stBlinkenMovie BlinkenMngLoad(const char pFilename) {
238	224	BlMng_userdata *data;
239	225	mng_handle hMNG;
240	226	stBlinkenMovie *movie = NULL;
...	...	@@ -256,8 +242,7 @@ stBlinkenMovie BlinkenMngLoad(const char pFilename)
256	242	if (data->hFile != NULL) {
257	243
258	244	// initialize MNG library
259		- hMNG =
260		- mng_initialize((mng_ptr) data, BlMng_alloc, BlMng_free, MNG_NULL);
	245	+ hMNG = mng_initialize((mng_ptr)data, BlMng_alloc, BlMng_free, MNG_NULL);
261	246	if (hMNG) {
262	247
263	248	// set MNG callbacks
...	...	@@ -369,8 +354,7 @@ stBlinkenMovie BlinkenMngLoad(const char pFilename)
369	354	return movie;
370	355	}
371	356
372		-int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename)
373		-{
	357	+int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename) {
374	358	BlMng_userdata *data;
375	359	mng_handle hMNG;
376	360	int b_success = 0;
...	...	@@ -397,8 +381,7 @@ int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename)
397	381	if (data->hFile != NULL) {
398	382
399	383	// initialize MNG library
400		- hMNG =
401		- mng_initialize((mng_ptr) data, BlMng_alloc, BlMng_free, MNG_NULL);
	384	+ hMNG = mng_initialize((mng_ptr)data, BlMng_alloc, BlMng_free, MNG_NULL);
402	385	if (hMNG) {
403	386
404	387	// set MNG callbacks
...	...	@@ -417,7 +400,8 @@ int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename)
417	400	unsigned int frame_no;
418	401
419	402	// write MG header chunks
420		- if (mng_putchunk_mhdr(hMNG, data->width, data->height, // dimensions
	403	+ if (mng_putchunk_mhdr(
	404	+ hMNG, data->width, data->height, // dimensions
421	405	1000, 0, frame_cnt, total_duration, // ticks
422	406	//
423	407	//
...	...	@@ -430,7 +414,8 @@ int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename)
430	414	// frame
431	415	// count,
432	416	// duration
433		- MNG_SIMPLICITY_VALID \| MNG_SIMPLICITY_SIMPLEFEATURES \| MNG_SIMPLICITY_COMPLEXFEATURES // simplicity
	417	+ MNG_SIMPLICITY_VALID \| MNG_SIMPLICITY_SIMPLEFEATURES \|
	418	+ MNG_SIMPLICITY_COMPLEXFEATURES // simplicity
434	419	) != 0)
435	420	break;
436	421
...	...	@@ -443,7 +428,8 @@ int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename)
443	428	// - this is needed to preserve duration of last frame
444	429	// - this results in a black frame with 1ms duration at the
445	430	// end of the MNG as side effect
446		- if (mng_putchunk_term(hMNG, MNG_TERMACTION_CLEAR, MNG_ITERACTION_CLEAR, // show
	431	+ if (mng_putchunk_term(hMNG, MNG_TERMACTION_CLEAR,
	432	+ MNG_ITERACTION_CLEAR, // show
447	433	//
448	434	//
449	435	//
...	...	@@ -467,15 +453,17 @@ int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename)
467	453	// get current frame
468	454	stBlinkenFrame *frame =
469	455	BlinkenMovieGetFrame(data->movie, frame_no);
470		- unsigned int frame_duration =
471		- BlinkenFrameGetDuration(frame);
	456	+ unsigned int frame_duration = BlinkenFrameGetDuration(frame);
472	457
473	458	// write MNG frame header chunks
474	459	if (mng_putchunk_seek(hMNG, 0, MNG_NULL // no name
475	460	) != 0)
476	461	break;
477	462
478		- if (mng_putchunk_fram(hMNG, MNG_FALSE, frame_no == 0 ? MNG_FRAMINGMODE_1 : MNG_FRAMINGMODE_NOCHANGE, // empty,
	463	+ if (mng_putchunk_fram(
	464	+ hMNG, MNG_FALSE,
	465	+ frame_no == 0 ? MNG_FRAMINGMODE_1
	466	+ : MNG_FRAMINGMODE_NOCHANGE, // empty,
479	467	//
480	468	//
481	469	//
...	...	@@ -483,7 +471,9 @@ int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename)
483	471	//
484	472	// mode
485	473	0, MNG_NULL, // frame name
486		- MNG_CHANGEDELAY_DEFAULT, MNG_CHANGETIMOUT_NO, MNG_CHANGECLIPPING_NO, MNG_CHANGESYNCID_NO, // changing
	474	+ MNG_CHANGEDELAY_DEFAULT, MNG_CHANGETIMOUT_NO,
	475	+ MNG_CHANGECLIPPING_NO,
	476	+ MNG_CHANGESYNCID_NO, // changing
487	477	//
488	478	//
489	479	//
...	...	@@ -504,7 +494,8 @@ int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename)
504	494	) != 0)
505	495	break;
506	496
507		- if (mng_putchunk_defi(hMNG, 0, MNG_DONOTSHOW_VISIBLE, MNG_ABSTRACT, // no
	497	+ if (mng_putchunk_defi(hMNG, 0, MNG_DONOTSHOW_VISIBLE,
	498	+ MNG_ABSTRACT, // no
508	499	//
509	500	//
510	501	//
...	...	@@ -519,7 +510,8 @@ int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename)
519	510	) != 0)
520	511	break;
521	512
522		- if (mng_putchunk_ihdr(hMNG, data->width, data->height, 8, MNG_COLORTYPE_RGB, // dimensions
	513	+ if (mng_putchunk_ihdr(hMNG, data->width, data->height, 8,
	514	+ MNG_COLORTYPE_RGB, // dimensions
523	515	//
524	516	//
525	517	//
...	...	@@ -529,7 +521,9 @@ int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename)
529	521	// 8
530	522	// bit
531	523	// RGB
532		- MNG_COMPRESSION_DEFLATE, MNG_FILTER_ADAPTIVE, MNG_INTERLACE_NONE // deflate
	524	+ MNG_COMPRESSION_DEFLATE,
	525	+ MNG_FILTER_ADAPTIVE,
	526	+ MNG_INTERLACE_NONE // deflate
533	527	//
534	528	//
535	529	//
...	...	@@ -552,8 +546,7 @@ int BlinkenMngSave(stBlinkenMovie pMovie, const char pFilename)
552	546	BlMng_compress_frame(frame, &ptr, &len);
553	547
554	548	iRC =
555		- mng_putchunk_idat(hMNG, (mng_uint32) len,
556		- (mng_ptr) ptr);
	549	+ mng_putchunk_idat(hMNG, (mng_uint32)len, (mng_ptr)ptr);
557	550	free(ptr);
558	551	if (iRC != 0)
559	552	break;

...	...	@@ -6,9 +6,9 @@
6	6	#ifndef INC_BlinkenLib_BlinkenMng
7	7	#define INC_BlinkenLib_BlinkenMng
8	8
9		-#include <BlinkenLib/config.h>
10	9	#include <BlinkenLib/BlinkenFrame.h>
11	10	#include <BlinkenLib/BlinkenMovie.h>
	11	+#include <BlinkenLib/config.h>
12	12
13	13	#ifndef BLINKENLIB_CFG_MNG
14	14	#error This file is to be used for MNG support only.

...	...	@@ -5,13 +5,13 @@
5	5
6	6	#include <string.h>
7	7	#ifdef WIN32
8		-#include <winsock2.h>
9	8	#include <windows.h>
	9	+#include <winsock2.h>
10	10	typedef WORD uint16_t;
11	11	typedef DWORD uint32_t;
12	12	#else
13		-#include <stdint.h>
14	13	#include <netinet/in.h>
	14	+#include <stdint.h>
15	15	#endif
16	16
17	17	#include <BlinkenLib/BlinkenProto.h>
...	...	@@ -131,8 +131,7 @@ int BlinkenProtoMakePacket(etBlinkenProto proto, etBlinkenPacket packet,
131	131	}
132	132
133	133	void BlinkenProtoDetectPacket(const char *pData, int length,
134		- etBlinkenProto * pProto,
135		- etBlinkenPacket * pPacket)
	134	+ etBlinkenProto pProto, etBlinkenPacket pPacket)
136	135	// returns protocol in *pProto if pProto not NULL
137	136	// returns packet type in *pPacket if pPacket not NULL
138	137	{
...	...	@@ -161,28 +160,32 @@ void BlinkenProtoDetectPacket(const char *pData, int length,
161	160	}
162	161	break;
163	162	case BlinkenProtoBlpReqMagic:
164		- if (length >= (int)sizeof(magic) + 10 && !memcmp(pData + sizeof(magic), "REFRESH256", 10)) {
	163	+ if (length >= (int)sizeof(magic) + 10 &&
	164	+ !memcmp(pData + sizeof(magic), "REFRESH256", 10)) {
165	165	if (pProto)
166	166	*pProto = BlinkenProtoEblp;
167	167	if (pPacket)
168	168	*pPacket = BlinkenPacketRequest;
169	169	return;
170	170	}
171		- if (length >= (int)sizeof(magic) + 8 && !memcmp(pData + sizeof(magic), "CLOSE256", 8)) {
	171	+ if (length >= (int)sizeof(magic) + 8 &&
	172	+ !memcmp(pData + sizeof(magic), "CLOSE256", 8)) {
172	173	if (pProto)
173	174	*pProto = BlinkenProtoEblp;
174	175	if (pPacket)
175	176	*pPacket = BlinkenPacketEndRequest;
176	177	return;
177	178	}
178		- if (length >= (int)sizeof(magic) + 7 && !memcmp(pData + sizeof(magic), "REFRESH", 7)) {
	179	+ if (length >= (int)sizeof(magic) + 7 &&
	180	+ !memcmp(pData + sizeof(magic), "REFRESH", 7)) {
179	181	if (pProto)
180	182	*pProto = BlinkenProtoBlp;
181	183	if (pPacket)
182	184	*pPacket = BlinkenPacketRequest;
183	185	return;
184	186	}
185		- if (length >= (int)sizeof(magic) + 5 && !memcmp(pData + sizeof(magic), "CLOSE", 5)) {
	187	+ if (length >= (int)sizeof(magic) + 5 &&
	188	+ !memcmp(pData + sizeof(magic), "CLOSE", 5)) {
186	189	if (pProto)
187	190	*pProto = BlinkenProtoBlp;
188	191	if (pPacket)

...	...	@@ -7,8 +7,7 @@
7	7
8	8	#include "Tools.h"
9	9
10		-void *BlinkenMalloc1D(int count1, int size)
11		-{
	10	+void *BlinkenMalloc1D(int count1, int size) {
12	11	if (count1 < 1)
13	12	count1 = 1;
14	13	if (size < 1)
...	...	@@ -17,8 +16,7 @@ void *BlinkenMalloc1D(int count1, int size)
17	16	return malloc(count1 * size);
18	17	}
19	18
20		-void **BlinkenMalloc2D(int count1, int count2, int size)
21		-{
	19	+void **BlinkenMalloc2D(int count1, int count2, int size) {
22	20	int sz, i;
23	21	char *p;
24	22	void **ptr;

...	...	@@ -19,12 +19,17 @@
19	19	* @param[in] str_duration duration of each frame in ms (as string)
20	20	*/
21	21	static void gen_test_movie(stBlinkenMovie *ppMovie, const char str_format,
22		- const char str_mode, const char str_duration)
23		-{
	22	+ const char str_mode, const char str_duration) {
24	23	unsigned int height, width, channels, colors;
25	24	enum {
26		- ModeNone, ModeBlack, ModeWhite, ModeGradient,
27		- ModeDots, ModeLines, ModeTrans, ModeRainbow,
	25	+ ModeNone,
	26	+ ModeBlack,
	27	+ ModeWhite,
	28	+ ModeGradient,
	29	+ ModeDots,
	30	+ ModeLines,
	31	+ ModeTrans,
	32	+ ModeRainbow,
28	33	} mode = ModeNone;
29	34	int fmt_ok, append, duration;
30	35
...	...	@@ -43,8 +48,8 @@ static void gen_test_movie(stBlinkenMovie *ppMovie, const char str_format,
43	48	append = 1;
44	49	}
45	50	} else {
46		- fmt_ok = sscanf(str_format, "%ux%u-%u/%u",
47		- &width, &height, &channels, &colors) == 4;
	51	+ fmt_ok = sscanf(str_format, "%ux%u-%u/%u", &width, &height, &channels,
	52	+ &colors) == 4;
48	53	append = 0;
49	54	}
50	55	// mode
...	...	@@ -96,9 +101,7 @@ static void gen_test_movie(stBlinkenMovie *ppMovie, const char str_format,
96	101	break;
97	102
98	103	case ModeBlack:
99		- pFrame =
100		- BlinkenFrameNew(height, width, channels, colors - 1,
101		- duration);
	104	+ pFrame = BlinkenFrameNew(height, width, channels, colors - 1, duration);
102	105	for (yy = 0; yy < height; yy++)
103	106	for (xx = 0; xx < width; xx++)
104	107	for (cc = 0; cc < channels; cc++)
...	...	@@ -107,9 +110,7 @@ static void gen_test_movie(stBlinkenMovie *ppMovie, const char str_format,
107	110	break;
108	111
109	112	case ModeWhite:
110		- pFrame =
111		- BlinkenFrameNew(height, width, channels, colors - 1,
112		- duration);
	113	+ pFrame = BlinkenFrameNew(height, width, channels, colors - 1, duration);
113	114	for (yy = 0; yy < height; yy++)
114	115	for (xx = 0; xx < width; xx++)
115	116	for (cc = 0; cc < channels; cc++)
...	...	@@ -118,19 +119,29 @@ static void gen_test_movie(stBlinkenMovie *ppMovie, const char str_format,
118	119	break;
119	120
120	121	case ModeGradient:
121		- pFrame =
122		- BlinkenFrameNew(height, width, channels, colors - 1,
123		- duration);
	122	+ pFrame = BlinkenFrameNew(height, width, channels, colors - 1, duration);
124	123	for (yy = 0; yy < height; yy++) {
125	124	fy = (float)yy / (float)(height - 1);
126	125	for (xx = 0; xx < width; xx++) {
127	126	fx = (float)xx / (float)(width - 1);
128	127	for (cc = 0, ccc = 0; cc < channels; cc++) {
129	128	switch (ccc) {
130		- case 0: fc = fx; ccc = 1; break;
131		- case 1: fc = fy; ccc = 2; break;
132		- case 2: fc = 1.0f - 0.5f * (fx + fy); ccc = 0; break;
133		- default: fc = 0.0f; ccc = 0; break;
	129	+ case 0:
	130	+ fc = fx;
	131	+ ccc = 1;
	132	+ break;
	133	+ case 1:
	134	+ fc = fy;
	135	+ ccc = 2;
	136	+ break;
	137	+ case 2:
	138	+ fc = 1.0f - 0.5f * (fx + fy);
	139	+ ccc = 0;
	140	+ break;
	141	+ default:
	142	+ fc = 0.0f;
	143	+ ccc = 0;
	144	+ break;
134	145	}
135	146	BlinkenFrameSetPixel(pFrame, yy, xx, cc,
136	147	(int)(fc * (float)(colors - 1) + .5f));
...	...	@@ -144,15 +155,14 @@ static void gen_test_movie(stBlinkenMovie *ppMovie, const char str_format,
144	155	for (c = 0; c < channels; c++)
145	156	for (y = 0; y < height; y++)
146	157	for (x = 0; x < width; x++) {
147		- pFrame =
148		- BlinkenFrameNew(height, width, channels, colors - 1,
	158	+ pFrame = BlinkenFrameNew(height, width, channels, colors - 1,
149	159	duration);
150	160	for (yy = 0; yy < height; yy++)
151	161	for (xx = 0; xx < width; xx++)
152	162	for (cc = 0; cc < channels; cc++)
153		- BlinkenFrameSetPixel(pFrame, yy, xx, cc,
154		- yy == y && xx == x
155		- && cc == c ? colors - 1 : 0);
	163	+ BlinkenFrameSetPixel(
	164	+ pFrame, yy, xx, cc,
	165	+ yy == y && xx == x && cc == c ? colors - 1 : 0);
156	166	BlinkenMovieAppendFrame(*ppMovie, pFrame);
157	167	}
158	168	break;
...	...	@@ -161,8 +171,7 @@ static void gen_test_movie(stBlinkenMovie *ppMovie, const char str_format,
161	171	for (c = 0; c < channels; c++) {
162	172	for (x = 0; x < width; x++) {
163	173	pFrame =
164		- BlinkenFrameNew(height, width, channels, colors - 1,
165		- duration);
	174	+ BlinkenFrameNew(height, width, channels, colors - 1, duration);
166	175	for (yy = 0; yy < height; yy++)
167	176	for (xx = 0; xx < width; xx++)
168	177	for (cc = 0; cc < channels; cc++)
...	...	@@ -172,8 +181,7 @@ static void gen_test_movie(stBlinkenMovie *ppMovie, const char str_format,
172	181	}
173	182	for (y = 0; y < height; y++) {
174	183	pFrame =
175		- BlinkenFrameNew(height, width, channels, colors - 1,
176		- duration);
	184	+ BlinkenFrameNew(height, width, channels, colors - 1, duration);
177	185	for (yy = 0; yy < height; yy++)
178	186	for (xx = 0; xx < width; xx++)
179	187	for (cc = 0; cc < channels; cc++)
...	...	@@ -189,14 +197,16 @@ static void gen_test_movie(stBlinkenMovie *ppMovie, const char str_format,
189	197	for (b = 0; b < 2; b++)
190	198	for (c2 = 0; c2 < channels; c2++)
191	199	for (o = 0; o < colors - 1; o++) {
192		- pFrame =
193		- BlinkenFrameNew(height, width, channels, colors - 1,
	200	+ pFrame = BlinkenFrameNew(height, width, channels, colors - 1,
194	201	duration);
195	202	for (cc = 0; cc < channels; cc++) {
196	203	c3 = (cc + channels - c) % channels;
197		- oo = b ? (c3 < c2 ? 0 : c3 >
198		- c2 ? colors - 1 : colors - 1 - o)
199		- : (c3 < c2 ? colors - 1 : c3 > c2 ? 0 : o);
	204	+ oo = b ? (c3 < c2 ? 0
	205	+ : c3 > c2 ? colors - 1
	206	+ : colors - 1 - o)
	207	+ : (c3 < c2 ? colors - 1
	208	+ : c3 > c2 ? 0
	209	+ : o);
200	210	for (yy = 0; yy < height; yy++)
201	211	for (xx = 0; xx < width; xx++)
202	212	BlinkenFrameSetPixel(pFrame, yy, xx, cc, oo);
...	...	@@ -207,30 +217,64 @@ static void gen_test_movie(stBlinkenMovie *ppMovie, const char str_format,
207	217
208	218	case ModeRainbow:
209	219	for (b = 0; b < width * height; b++) {
210		- pFrame = BlinkenFrameNew(height, width, channels,
211		- colors - 1, duration);
	220	+ pFrame =
	221	+ BlinkenFrameNew(height, width, channels, colors - 1, duration);
212	222	for (yy = 0; yy < height; yy++) {
213	223	for (xx = 0; xx < width; xx++) {
214	224	for (cc = 0; cc < channels; cc++) {
215	225	y = b + yy + xx + cc * 8;
216	226	switch (y % 24) {
217		- case 0: oo = 0; break;
218		- case 1: oo = 1; break;
219		- case 2: oo = 2; break;
220		- case 3: oo = 3; break;
221		- case 4: oo = 4; break;
222		- case 5: oo = 4; break;
223		- case 6: oo = 4; break;
224		- case 7: oo = 4; break;
225		- case 8: oo = 4; break;
226		- case 9: oo = 4; break;
227		- case 10: oo = 4; break;
228		- case 11: oo = 4; break;
229		- case 12: oo = 4; break;
230		- case 13: oo = 3; break;
231		- case 14: oo = 2; break;
232		- case 15: oo = 1; break;
233		- default: oo = 0; break;
	227	+ case 0:
	228	+ oo = 0;
	229	+ break;
	230	+ case 1:
	231	+ oo = 1;
	232	+ break;
	233	+ case 2:
	234	+ oo = 2;
	235	+ break;
	236	+ case 3:
	237	+ oo = 3;
	238	+ break;
	239	+ case 4:
	240	+ oo = 4;
	241	+ break;
	242	+ case 5:
	243	+ oo = 4;
	244	+ break;
	245	+ case 6:
	246	+ oo = 4;
	247	+ break;
	248	+ case 7:
	249	+ oo = 4;
	250	+ break;
	251	+ case 8:
	252	+ oo = 4;
	253	+ break;
	254	+ case 9:
	255	+ oo = 4;
	256	+ break;
	257	+ case 10:
	258	+ oo = 4;
	259	+ break;
	260	+ case 11:
	261	+ oo = 4;
	262	+ break;
	263	+ case 12:
	264	+ oo = 4;
	265	+ break;
	266	+ case 13:
	267	+ oo = 3;
	268	+ break;
	269	+ case 14:
	270	+ oo = 2;
	271	+ break;
	272	+ case 15:
	273	+ oo = 1;
	274	+ break;
	275	+ default:
	276	+ oo = 0;
	277	+ break;
234	278	}
235	279	oo = oo * colors / 4;
236	280	if (oo > colors - 1)
...	...	@@ -255,8 +299,7 @@ static void gen_test_movie(stBlinkenMovie *ppMovie, const char str_format,
255	299
256	300	static void copy_rect(stBlinkenMovie pMovie, char str_file,
257	301	const char str_src_pos, const char str_dim,
258		- const char *str_dest_pos)
259		-{
	302	+ const char *str_dest_pos) {
260	303	unsigned int sy, sx, h, w, dy, dx;
261	304	stBlinkenMovie *pSrcMovie;
262	305
...	...	@@ -275,23 +318,24 @@ static void copy_rect(stBlinkenMovie pMovie, char str_file,
275	318
276	319	BlinkenMovieCopyRect(pMovie, dy, dx, pSrcMovie, sy, sx, h, w);
277	320	BlinkenMovieFree(pSrcMovie);
278		- printf("copied %ux%u pixels from movie \"%s\" %u,%u to %u,%u\n",
279		- w, h, str_file, sx, sy, dx, dy );
280		-
	321	+ printf("copied %ux%u pixels from movie \"%s\" %u,%u to %u,%u\n", w, h,
	322	+ str_file, sx, sy, dx, dy);
281	323	}
282	324	}
283	325	}
284	326
285		-static stBlinkenMovie * scroll(stBlinkenMovie *pMovie,
286		- const char * str_direction,
	327	+static stBlinkenMovie scroll(stBlinkenMovie pMovie, const char *str_direction,
287	328	const char *str_width_height,
288		- const char * str_duration)
289		-{
	329	+ const char *str_duration) {
290	330	enum {
291		- DirNone, DirLeft, DirRight, DirUp, DirDown,
	331	+ DirNone,
	332	+ DirLeft,
	333	+ DirRight,
	334	+ DirUp,
	335	+ DirDown,
292	336	} dir = DirNone;
293		- int width_height, duration, height, width, channels, maxval,
294		- new_height, new_width, sy, sx, dy, dx, steps, step;
	337	+ int width_height, duration, height, width, channels, maxval, new_height,
	338	+ new_width, sy, sx, dy, dx, steps, step;
295	339	stBlinkenFrame pScroll, pFrame;
296	340
297	341	// direction
...	...	@@ -388,14 +432,13 @@ static stBlinkenMovie * scroll(stBlinkenMovie *pMovie,
388	432	BlinkenFrameFree(pScroll);
389	433
390	434	printf("scrolled %ux%u-%u/%u frame to %ux%u-%u/%u movie (direction %s)\n",
391		- width, height, channels, maxval + 1,
392		- new_width, new_height, channels, maxval + 1, str_direction);
	435	+ width, height, channels, maxval + 1, new_width, new_height, channels,
	436	+ maxval + 1, str_direction);
393	437
394	438	return pMovie;
395	439	}
396	440
397		-int main(int argCnt, char **args)
398		-{
	441	+int main(int argCnt, char **args) {
399	442	stBlinkenMovie *pMovie;
400	443	int i;
401	444	char *str;
...	...	@@ -424,12 +467,15 @@ int main(int argCnt, char **args)
424	467	#else
425	468	#define GIFEXT
426	469	#endif
427		- printf("syntax: %s <parameter> [...]\n\n"
	470	+ printf(
	471	+ "syntax: %s <parameter> [...]\n\n"
428	472	"parameters:\n"
429	473	" -i <file>\n"
430		- " read movie from file (.blm, .bmm, .bml, .bbm" MNGEXT GIFEXT ")\n"
	474	+ " read movie from file (.blm, .bmm, .bml, .bbm" MNGEXT GIFEXT
	475	+ ")\n"
431	476	" -a <file>\n"
432		- " append movie from file (.blm, .bmm, .bml, .bbm" MNGEXT GIFEXT ")\n"
	477	+ " append movie from file (.blm, .bmm, .bml, .bbm" MNGEXT GIFEXT
	478	+ ")\n"
433	479	" -l <number>\n"
434	480	" loop video a number of times\n"
435	481	" -f\n"
...	...	@@ -477,7 +523,8 @@ int main(int argCnt, char **args)
477	523	" -Md2\n"
478	524	" mirror movie diagonally (/)\n"
479	525	" -o <file>\n"
480		- " write movie to file (.blm, .bmm, .bml, .bbm" MNGEXT GIFEXT ")\n\n"
	526	+ " write movie to file (.blm, .bmm, .bml, .bbm" MNGEXT GIFEXT
	527	+ ")\n\n"
481	528	"test_modes: black, white, gradient, dots, lines, trans, rainbow\n\n"
482	529	"old syntax: %s <input-file> [<output-file>]\n\n",
483	530	args[0], args[0]);
...	...	@@ -517,8 +564,7 @@ int main(int argCnt, char **args)
517	564	else {
518	565	if (BlinkenMovieConcat(pMovie, pMovie2) < 0) {
519	566	BlinkenMovieFree(pMovie2);
520		- printf("movie read from \"%s\" could not be appended\n",
521		- args[i]);
	567	+ printf("movie read from \"%s\" could not be appended\n", args[i]);
522	568	} else
523	569	printf("movie \"%s\" read and appended\n", args[i]);
524	570	}
...	...	@@ -567,16 +613,14 @@ int main(int argCnt, char **args)
567	613	// output format, frame count and duration of movie
568	614	else if (strcmp(args[i], "-f") == 0) {
569	615	if (pMovie == NULL)
570		- printf
571		- ("no movie loaded to output format, frame count and duration of\n");
	616	+ printf(
	617	+ "no movie loaded to output format, frame count and duration of\n");
572	618	else
573		- printf
574		- ("format: %ux%u-%u/%u\nframe count: %u\nduration: %u ms\n",
	619	+ printf(
	620	+ "format: %ux%u-%u/%u\nframe count: %u\nduration: %u ms\n",
575	621	BlinkenMovieGetWidth(pMovie), BlinkenMovieGetHeight(pMovie),
576		- BlinkenMovieGetChannels(pMovie),
577		- BlinkenMovieGetMaxval(pMovie) + 1,
578		- BlinkenMovieGetFrameCnt(pMovie),
579		- BlinkenMovieGetDuration(pMovie));
	622	+ BlinkenMovieGetChannels(pMovie), BlinkenMovieGetMaxval(pMovie) + 1,
	623	+ BlinkenMovieGetFrameCnt(pMovie), BlinkenMovieGetDuration(pMovie));
580	624	}
581	625	// print movie
582	626	else if (strcmp(args[i], "-p") == 0) {
...	...	@@ -596,8 +640,7 @@ int main(int argCnt, char **args)
596	640	else if (strcmp(args[i], "-r") == 0) {
597	641	if (i + 1 < argCnt) {
598	642	i++;
599		- if (sscanf
600		- (args[i], "%ux%u-%u/%u", &width, &height, &channels,
	643	+ if (sscanf(args[i], "%ux%u-%u/%u", &width, &height, &channels,
601	644	&colors) != 4)
602	645	printf("invalid movie format \"%s\"\n", args[i]);
603	646	else if (pMovie == NULL)
...	...	@@ -618,11 +661,9 @@ int main(int argCnt, char **args)
618	661	topleft = args[i];
619	662	i++;
620	663	dimensions = args[i];
621		- if (sscanf
622		- (topleft, "%u,%u", &left, &top) != 2)
	664	+ if (sscanf(topleft, "%u,%u", &left, &top) != 2)
623	665	printf("invalid top-left position \"%s\"\n", topleft);
624		- else if (sscanf
625		- (dimensions, "%ux%u", &width, &height) != 2)
	666	+ else if (sscanf(dimensions, "%ux%u", &width, &height) != 2)
626	667	printf("invalid movie dimensions \"%s\"\n", dimensions);
627	668	else if (pMovie == NULL)
628	669	printf("no movie loaded to crop\n");
...	...	@@ -707,8 +748,7 @@ int main(int argCnt, char **args)
707	748	BlinkenMovieCutTime(pMovie, begin, end);
708	749	printf("movie cut to time %u-%u\n", begin, end);
709	750	}
710		- }
711		- else if (i + 1 < argCnt) {
	751	+ } else if (i + 1 < argCnt) {
712	752	printf("missing end time for \"-ct\"\n");
713	753	i++;
714	754	} else
...	...	@@ -764,8 +804,7 @@ int main(int argCnt, char **args)
764	804	printf("no movie loaded to delete frames from\n");
765	805	else if (first + count >
766	806	(unsigned int)BlinkenMovieGetFrameCnt(pMovie))
767		- printf
768		- ("invalid frame range (%u-%u) for deletion from %u frames\n",
	807	+ printf("invalid frame range (%u-%u) for deletion from %u frames\n",
769	808	first, first + count,
770	809	(unsigned int)BlinkenMovieGetFrameCnt(pMovie));
771	810	else {
...	...	@@ -942,8 +981,8 @@ int main(int argCnt, char **args)
942	981	}
943	982	// old style input filename
944	983	else if (i == 1 && args[i][0] != '-') {
945		- printf("old style input filename \"%s\", better use \"-i %s\"\n",
946		- args[i], args[i]);
	984	+ printf("old style input filename \"%s\", better use \"-i %s\"\n", args[i],
	985	+ args[i]);
947	986	if (pMovie != NULL)
948	987	BlinkenMovieFree(pMovie);
949	988	pMovie = BlinkenMovieLoad(args[i]);
...	...	@@ -965,8 +1004,7 @@ int main(int argCnt, char **args)
965	1004	}
966	1005	// unknown parameter
967	1006	else
968		- printf
969		- ("unknown parameter \"%s\", call without parameters to get help\n",
	1007	+ printf("unknown parameter \"%s\", call without parameters to get help\n",
970	1008	args[i]);
971	1009
972	1010	} // for( i ...

...	...	@@ -7,21 +7,19 @@
7	7
8	8	#include <errno.h>
9	9	#include <fcntl.h>
10		-#include <stdlib.h>
11	10	#include <stdio.h>
12	11	#include <stdlib.h>
13	12	#include <string.h>
	13	+#include <sys/time.h>
	14	+#include <sys/types.h>
14	15	#include <termios.h>
15	16	#include <time.h>
16	17	#include <unistd.h>
17		-#include <sys/time.h>
18		-#include <sys/types.h>
19	18
20	19	#include <BlinkenLib/BlinkenLib.h>
21	20
22	21	// get serial settings from text
23		-static int serial_settings_parse(char str, int settings, int *speed)
24		-{
	22	+static int serial_settings_parse(char str, int settings, int *speed) {
25	23	int baud, data, stop;
26	24	char parity;
27	25	int set = 0, sp = 0;
...	...	@@ -32,7 +30,8 @@ static int serial_settings_parse(char str, int settings, int *speed)
32	30
33	31	// baud rate
34	32	#define BAUD(rate) else if (baud == rate) sp = B##rate;
35		- if (0) {}
	33	+ if (0) {
	34	+ }
36	35	BAUD(300)
37	36	BAUD(600)
38	37	BAUD(1200)
...	...	@@ -128,8 +127,7 @@ static int serial_settings_parse(char str, int settings, int *speed)
128	127
129	128	// convert serial settings to text
130	129	static void serial_settings_to_str(int settings, char *buf,
131		- unsigned int maxlen)
132		-{
	130	+ unsigned int maxlen) {
133	131	int baud, data, stop;
134	132	char parity;
135	133
...	...	@@ -188,8 +186,7 @@ static void serial_settings_to_str(int settings, char *buf,
188	186	}
189	187
190	188	// set serial settings for fd
191		-static int serial_settings_set(int fd, int settings, int speed)
192		-{
	189	+static int serial_settings_set(int fd, int settings, int speed) {
193	190	struct termios tio;
194	191
195	192	// set port settings
...	...	@@ -222,11 +219,9 @@ static int serial_settings_set(int fd, int settings, int speed)
222	219	// dev_fd may be -1 for not doing anything with device
223	220	// returns error code (not for device-errors, 0 for success)
224	221	static int out_movie(stBlinkenMovie *pMovie, int dev_fd,
225		- unsigned int format_change,
226		- unsigned int format_height, unsigned int format_width,
227		- unsigned int format_channels,
228		- unsigned int format_colors, etBlinkenProto proto)
229		-{
	222	+ unsigned int format_change, unsigned int format_height,
	223	+ unsigned int format_width, unsigned int format_channels,
	224	+ unsigned int format_colors, etBlinkenProto proto) {
230	225	int frame_cnt, frame;
231	226	stBlinkenFrame *pFrame;
232	227	fd_set readFds, errFds;
...	...	@@ -255,8 +250,8 @@ static int out_movie(stBlinkenMovie *pMovie, int dev_fd,
255	250
256	251	// change format
257	252	if (format_change)
258		- BlinkenFrameResize(pFrame, format_height, format_width,
259		- format_channels, format_colors - 1);
	253	+ BlinkenFrameResize(pFrame, format_height, format_width, format_channels,
	254	+ format_colors - 1);
260	255
261	256	// create output data from frame
262	257	len = BlinkenFrameToNetwork(pFrame, proto, buffer, sizeof(buffer));
...	...	@@ -333,14 +328,12 @@ static int out_movie(stBlinkenMovie *pMovie, int dev_fd,
333	328	// open device and output movie
334	329	// returns error code (not for device-errors, 0 for success)
335	330	static int open_and_output(stBlinkenMovie pMovie, char device,
336		- int serial_settings_change,
337		- int serial_settings, int serial_speed,
338		- unsigned int format_change,
	331	+ int serial_settings_change, int serial_settings,
	332	+ int serial_speed, unsigned int format_change,
339	333	unsigned int format_height,
340	334	unsigned int format_width,
341	335	unsigned int format_channels,
342		- unsigned int format_colors, etBlinkenProto proto)
343		-{
	336	+ unsigned int format_colors, etBlinkenProto proto) {
344	337	int dev_fd, err;
345	338	char txt[64];
346	339
...	...	@@ -362,8 +355,7 @@ static int open_and_output(stBlinkenMovie pMovie, char device,
362	355	}
363	356	}
364	357	// output movie to device
365		- err = out_movie(pMovie, dev_fd,
366		- format_change, format_height, format_width,
	358	+ err = out_movie(pMovie, dev_fd, format_change, format_height, format_width,
367	359	format_channels, format_colors, proto);
368	360
369	361	// close device
...	...	@@ -374,8 +366,7 @@ static int open_and_output(stBlinkenMovie pMovie, char device,
374	366	return err;
375	367	}
376	368
377		-int main(int argCnt, char **args)
378		-{
	369	+int main(int argCnt, char **args) {
379	370	int i, serial_settings, serial_speed;
380	371	char *device;
381	372	etBlinkenProto proto;
...	...	@@ -421,7 +412,8 @@ int main(int argCnt, char **args)
421	412	" -n <number>\n"
422	413	" set number of times to send movies (defaults to 1)\n"
423	414	" -i <file>\n"
424		- " read movie from file (.blm, .bmm, .bml, .bbm" MNGEXT GIFEXT ") and send it\n"
	415	+ " read movie from file (.blm, .bmm, .bml, .bbm" MNGEXT GIFEXT
	416	+ ") and send it\n"
425	417	" -l <number>\n"
426	418	" loop number of times (defaults to 1, use 0 for forever)\n\n",
427	419	args[0]);
...	...	@@ -471,10 +463,10 @@ int main(int argCnt, char **args)
471	463	else if (strcmp(args[i], "-f") == 0) {
472	464	if (i + 1 < argCnt) {
473	465	i++;
474		- if (sscanf
475		- (args[i], "%ux%u-%u/%u", &width, &height, &channels, &colors) == 4
476		- && width > 0 && width < 1000 && height > 0 && height < 1000
477		- && channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
	466	+ if (sscanf(args[i], "%ux%u-%u/%u", &width, &height, &channels,
	467	+ &colors) == 4 &&
	468	+ width > 0 && width < 1000 && height > 0 && height < 1000 &&
	469	+ channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
478	470	format_change = 1;
479	471	format_height = height;
480	472	format_width = width;
...	...	@@ -528,9 +520,9 @@ int main(int argCnt, char **args)
528	520	printf("outputting movie \"%s\" (%u/%u)...\n", args[i], ui + 1,
529	521	send_cnt);
530	522	if (open_and_output(pMovie, device, serial_settings_change,
531		- serial_settings, serial_speed,
532		- format_change, format_height, format_width,
533		- format_channels, format_colors, proto) == 0) {
	523	+ serial_settings, serial_speed, format_change,
	524	+ format_height, format_width, format_channels,
	525	+ format_colors, proto) == 0) {
534	526	printf("movie \"%s\" output successful\n", args[i]);
535	527	} else {
536	528	printf("movie \"%s\" output failed\n", args[i]);
...	...	@@ -555,8 +547,8 @@ int main(int argCnt, char **args)
555	547	}
556	548	// unknown parameter
557	549	else
558		- printf
559		- ("unknown parameter \"%s\", call without parameters to get help\n",
	550	+ printf(
	551	+ "unknown parameter \"%s\", call without parameters to get help\n",
560	552	args[i]);
561	553
562	554	} // for( i ...

...	...	@@ -5,25 +5,24 @@
5	5	/* OS X support by Manfred Wuits
6	6	<manfred@werkzeugH.at> */
7	7
	8	+#include <arpa/inet.h>
8	9	#include <errno.h>
9	10	#include <fcntl.h>
10		-#include <stdlib.h>
	11	+#include <netinet/in.h>
11	12	#include <stdio.h>
	13	+#include <stdlib.h>
12	14	#include <string.h>
	15	+#include <sys/socket.h>
	16	+#include <sys/time.h>
	17	+#include <sys/types.h>
13	18	#include <termios.h>
14	19	#include <time.h>
15	20	#include <unistd.h>
16		-#include <arpa/inet.h>
17		-#include <netinet/in.h>
18		-#include <sys/types.h>
19		-#include <sys/time.h>
20		-#include <sys/socket.h>
21	21
22	22	#include <BlinkenLib/BlinkenLib.h>
23	23
24	24	// get serial settings from text
25		-static int serial_settings_parse(char str, int settings, int *speed)
26		-{
	25	+static int serial_settings_parse(char str, int settings, int *speed) {
27	26	int baud, data, stop;
28	27	char parity;
29	28	int set = 0, sp = 0;
...	...	@@ -34,7 +33,8 @@ static int serial_settings_parse(char str, int settings, int *speed)
34	33
35	34	// baud rate
36	35	#define BAUD(rate) else if (baud == rate) sp = B##rate;
37		- if (0) {}
	36	+ if (0) {
	37	+ }
38	38	BAUD(300)
39	39	BAUD(600)
40	40	BAUD(1200)
...	...	@@ -130,8 +130,7 @@ static int serial_settings_parse(char str, int settings, int *speed)
130	130
131	131	// convert serial settings to text
132	132	static void serial_settings_to_str(int settings, char *buf,
133		- unsigned int maxlen)
134		-{
	133	+ unsigned int maxlen) {
135	134	int baud, data, stop;
136	135	char parity;
137	136
...	...	@@ -190,8 +189,7 @@ static void serial_settings_to_str(int settings, char *buf,
190	189	}
191	190
192	191	// set serial settings for fd
193		-static int serial_settings_set(int fd, int settings, int speed)
194		-{
	192	+static int serial_settings_set(int fd, int settings, int speed) {
195	193	struct termios tio;
196	194
197	195	// set port settings
...	...	@@ -226,12 +224,10 @@ static int serial_settings_set(int fd, int settings, int speed)
226	224	static int recv_and_out(SOCKET udpSocket, int dev_fd,
227	225	int *p_device_output_active,
228	226	unsigned int min_interval_ms,
229		- unsigned int format_change,
230		- unsigned int format_height, unsigned int format_width,
231		- unsigned int format_channels,
	227	+ unsigned int format_change, unsigned int format_height,
	228	+ unsigned int format_width, unsigned int format_channels,
232	229	unsigned int format_colors, etBlinkenProto proto,
233		- int use_msecs, unsigned int msecs)
234		-{
	230	+ int use_msecs, unsigned int msecs) {
235	231	fd_set readFds, errFds;
236	232	stBlinkenFrame *pFrame;
237	233	char buffer[65536]; // 64kB is more than maximum UDP size
...	...	@@ -373,17 +369,13 @@ static int recv_and_out(SOCKET udpSocket, int dev_fd,
373	369
374	370	// open device and output frames
375	371	// returns error code (not for device-errors, 0 for success)
376		-static int open_and_output(SOCKET udpSocket, char *device,
377		- int *p_device_output_active,
	372	+static int
	373	+open_and_output(SOCKET udpSocket, char device, int p_device_output_active,
378	374	int serial_settings_change, int serial_settings,
379		- int serial_speed,
380		- unsigned int min_interval_ms,
381		- unsigned int format_change,
382		- unsigned int format_height,
383		- unsigned int format_width,
384		- unsigned int format_channels,
385		- unsigned int format_colors, etBlinkenProto proto)
386		-{
	375	+ int serial_speed, unsigned int min_interval_ms,
	376	+ unsigned int format_change, unsigned int format_height,
	377	+ unsigned int format_width, unsigned int format_channels,
	378	+ unsigned int format_colors, etBlinkenProto proto) {
387	379	int dev_fd, err;
388	380	char txt[64];
389	381
...	...	@@ -406,8 +398,7 @@ static int open_and_output(SOCKET udpSocket, char *device,
406	398	}
407	399	}
408	400	// receive frames and output to device
409		- err = recv_and_out(udpSocket, dev_fd, p_device_output_active,
410		- min_interval_ms,
	401	+ err = recv_and_out(udpSocket, dev_fd, p_device_output_active, min_interval_ms,
411	402	format_change, format_height, format_width,
412	403	format_channels, format_colors, proto, 0, 0);
413	404
...	...	@@ -419,19 +410,14 @@ static int open_and_output(SOCKET udpSocket, char *device,
419	410
420	411	// open device and output frames in a loop
421	412	// returns error code (not for device-errors, 0 for success)
422		-static int open_and_output_loop(SOCKET udpSocket, char *device,
423		- int serial_settings_change,
424		- int serial_settings, int serial_speed,
425		- int reopen_device,
	413	+static int
	414	+open_and_output_loop(SOCKET udpSocket, char *device, int serial_settings_change,
	415	+ int serial_settings, int serial_speed, int reopen_device,
426	416	unsigned int reopen_device_ms,
427		- unsigned int min_interval_ms,
428		- unsigned int format_change,
429		- unsigned int format_height,
430		- unsigned int format_width,
431		- unsigned int format_channels,
432		- unsigned int format_colors,
433		- etBlinkenProto proto)
434		-{
	417	+ unsigned int min_interval_ms, unsigned int format_change,
	418	+ unsigned int format_height, unsigned int format_width,
	419	+ unsigned int format_channels, unsigned int format_colors,
	420	+ etBlinkenProto proto) {
435	421	int device_output_active, err;
436	422
437	423	printf("receiving frames and outputting them to \"%s\"...\n", device);
...	...	@@ -440,13 +426,10 @@ static int open_and_output_loop(SOCKET udpSocket, char *device,
440	426	for (;;) {
441	427
442	428	// try to open device and output frames
443		- err = open_and_output(udpSocket, device,
444		- &device_output_active,
445		- serial_settings_change, serial_settings,
446		- serial_speed, min_interval_ms,
447		- format_change, format_height,
448		- format_width, format_channels, format_colors,
449		- proto);
	429	+ err = open_and_output(udpSocket, device, &device_output_active,
	430	+ serial_settings_change, serial_settings, serial_speed,
	431	+ min_interval_ms, format_change, format_height,
	432	+ format_width, format_channels, format_colors, proto);
450	433	if (err != 0 \|\| !reopen_device)
451	434	break;
452	435
...	...	@@ -456,8 +439,7 @@ static int open_and_output_loop(SOCKET udpSocket, char *device,
456	439	device_output_active = 0;
457	440
458	441	// only fetch data from socket for a short time
459		- err = recv_and_out(udpSocket, -1, &device_output_active,
460		- min_interval_ms,
	442	+ err = recv_and_out(udpSocket, -1, &device_output_active, min_interval_ms,
461	443	format_change, format_height, format_width,
462	444	format_channels, format_colors, proto, 1,
463	445	reopen_device_ms);
...	...	@@ -474,8 +455,7 @@ static int open_and_output_loop(SOCKET udpSocket, char *device,
474	455	return err;
475	456	}
476	457
477		-int main(int argCnt, char **args)
478		-{
	458	+int main(int argCnt, char **args) {
479	459	int i, bound, serial_settings, serial_speed;
480	460	SOCKET udpSocket;
481	461	etBlinkenProto proto;
...	...	@@ -501,7 +481,8 @@ int main(int argCnt, char **args)
501	481
502	482	// print syntax
503	483	if (argCnt <= 1) {
504		- printf("syntax: %s <parameter> [...]\n\n"
	484	+ printf(
	485	+ "syntax: %s <parameter> [...]\n\n"
505	486	"parameters:\n"
506	487	" -l [<ip>:]<port>\n"
507	488	" local address (defaults to 0.0.0.0:2323)\n"
...	...	@@ -517,10 +498,12 @@ int main(int argCnt, char **args)
517	498	" -s <baud-rate>,<parity>,<data-bits>,<stop-bits>\n"
518	499	" settings to use for serial devices (defaults to no change)\n"
519	500	" -o <milliseconds>\n"
520		- " reopen device after short time on error (defaults to not reopen)\n"
	501	+ " reopen device after short time on error (defaults to not "
	502	+ "reopen)\n"
521	503	" -i <milliseconds>\n"
522	504	" minimum interval between two frames on output (defaults to 0)\n"
523		- "\n", args[0]);
	505	+ "\n",
	506	+ args[0]);
524	507	return 0;
525	508	}
526	509	// create udp socket
...	...	@@ -611,10 +594,10 @@ int main(int argCnt, char **args)
611	594	else if (strcmp(args[i], "-f") == 0) {
612	595	if (i + 1 < argCnt) {
613	596	i++;
614		- if (sscanf
615		- (args[i], "%ux%u-%u/%u", &width, &height, &channels, &colors) == 4
616		- && width > 0 && width < 1000 && height > 0 && height < 1000
617		- && channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
	597	+ if (sscanf(args[i], "%ux%u-%u/%u", &width, &height, &channels,
	598	+ &colors) == 4 &&
	599	+ width > 0 && width < 1000 && height > 0 && height < 1000 &&
	600	+ channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
618	601	format_change = 1;
619	602	format_height = height;
620	603	format_width = width;
...	...	@@ -648,8 +631,8 @@ int main(int argCnt, char **args)
648	631	else if (strcmp(args[i], "-o") == 0) {
649	632	if (i + 1 < argCnt) {
650	633	i++;
651		- if (sscanf(args[i], "%u", &reopen_device_ms) == 1
652		- && reopen_device_ms >= 1)
	634	+ if (sscanf(args[i], "%u", &reopen_device_ms) == 1 &&
	635	+ reopen_device_ms >= 1)
653	636	reopen_device = 1;
654	637	else
655	638	printf("invalid number of milliseconds \"%s\"\n", args[i]);
...	...	@@ -669,8 +652,7 @@ int main(int argCnt, char **args)
669	652	}
670	653	// unknown parameter
671	654	else
672		- printf
673		- ("unknown parameter \"%s\", call without parameters to get help\n",
	655	+ printf("unknown parameter \"%s\", call without parameters to get help\n",
674	656	args[i]);
675	657
676	658	} // for( i ...
...	...	@@ -691,11 +673,10 @@ int main(int argCnt, char **args)
691	673	}
692	674	}
693	675	// open device and output frames in a loop
694		- open_and_output_loop(udpSocket, device,
695		- serial_settings_change, serial_settings, serial_speed,
696		- reopen_device, reopen_device_ms, min_interval_ms,
697		- format_change, format_height, format_width,
698		- format_channels, format_colors, proto);
	676	+ open_and_output_loop(
	677	+ udpSocket, device, serial_settings_change, serial_settings, serial_speed,
	678	+ reopen_device, reopen_device_ms, min_interval_ms, format_change,
	679	+ format_height, format_width, format_channels, format_colors, proto);
699	680
700	681	// close socket
701	682	close(udpSocket);

...	...	@@ -4,11 +4,11 @@
4	4	a blinkenarea.org project */
5	5
6	6	#include <fcntl.h>
7		-#include <stdlib.h>
8	7	#include <stdio.h>
	8	+#include <stdlib.h>
9	9	#include <string.h>
10		-#include <winsock2.h>
11	10	#include <windows.h>
	11	+#include <winsock2.h>
12	12
13	13	#include <BlinkenLib/BlinkenLib.h>
14	14
...	...	@@ -23,8 +23,7 @@ struct s_serial_settings {
23	23
24	24	// get serial settings from text
25	25	static int serial_settings_parse(char *str,
26		- struct s_serial_settings *serial_settings)
27		-{
	26	+ struct s_serial_settings *serial_settings) {
28	27	int baud, data, stop;
29	28	char parity;
30	29
...	...	@@ -117,8 +116,8 @@ static int serial_settings_parse(char *str,
117	116	}
118	117
119	118	// set serial settings for fd
120		-static int serial_settings_set(HANDLE hDev, struct s_serial_settings *settings)
121		-{
	119	+static int serial_settings_set(HANDLE hDev,
	120	+ struct s_serial_settings *settings) {
122	121	DCB PortDcb;
123	122	COMMTIMEOUTS CommTimeouts;
124	123
...	...	@@ -164,14 +163,12 @@ static int serial_settings_set(HANDLE hDev, struct s_serial_settings *settings)
164	163	// hDev may be INVALID_HANDLE_VALUE for not doing anything with device
165	164	// returns error code (not for device-errors, 0 for success)
166	165	static int recv_and_out(SOCKET udpSocket, HANDLE hDev,
167		- int *p_device_output_active,
168		- unsigned int format_change,
	166	+ int *p_device_output_active, unsigned int format_change,
169	167	unsigned int format_height, unsigned int format_width,
170	168	unsigned int format_channels,
171	169	unsigned int format_colors, etBlinkenProto proto,
172	170	int use_msecs, unsigned int msecs,
173		- int is_serial_device)
174		-{
	171	+ int is_serial_device) {
175	172	fd_set readFds, errFds;
176	173	stBlinkenFrame *pFrame;
177	174	char buffer[65536]; // 64kB is more than maximum UDP size
...	...	@@ -231,8 +228,8 @@ static int recv_and_out(SOCKET udpSocket, HANDLE hDev,
231	228
232	229	// output data to device
233	230	if (hDev != INVALID_HANDLE_VALUE && len > 0) {
234		- if (!WriteFile(hDev, buffer, len, &DevWrLen, NULL)
235		- \|\| (int)DevWrLen != len) {
	231	+ if (!WriteFile(hDev, buffer, len, &DevWrLen, NULL) \|\|
	232	+ (int)DevWrLen != len) {
236	233	if (*p_device_output_active)
237	234	printf("error writing to device: error %lu\n", GetLastError());
238	235	break;
...	...	@@ -273,23 +270,19 @@ static int recv_and_out(SOCKET udpSocket, HANDLE hDev,
273	270
274	271	// open device and output frames
275	272	// returns error code (not for device-errors, 0 for success)
276		-static int open_and_output(SOCKET udpSocket, char *device,
277		- int *p_device_output_active,
	273	+static int
	274	+open_and_output(SOCKET udpSocket, char device, int p_device_output_active,
278	275	int serial_settings_change,
279	276	struct s_serial_settings *serial_settings,
280		- unsigned int format_change,
281		- unsigned int format_height,
282		- unsigned int format_width,
283		- unsigned int format_channels,
284		- unsigned int format_colors, etBlinkenProto proto)
285		-{
	277	+ unsigned int format_change, unsigned int format_height,
	278	+ unsigned int format_width, unsigned int format_channels,
	279	+ unsigned int format_colors, etBlinkenProto proto) {
286	280	HANDLE hDev;
287	281	int err;
288	282
289	283	// open device
290		- hDev =
291		- CreateFile(device, GENERIC_READ \| GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
292		- 0, NULL);
	284	+ hDev = CreateFile(device, GENERIC_READ \| GENERIC_WRITE, 0, NULL,
	285	+ OPEN_EXISTING, 0, NULL);
293	286	if (hDev == INVALID_HANDLE_VALUE) {
294	287	if (*p_device_output_active)
295	288	printf("could not open \"%s\": error %lu\n", device, GetLastError());
...	...	@@ -305,10 +298,9 @@ static int open_and_output(SOCKET udpSocket, char *device,
305	298	}
306	299	}
307	300	// receive frames and output to device
308		- err = recv_and_out(udpSocket, hDev, p_device_output_active,
309		- format_change, format_height, format_width,
310		- format_channels, format_colors, proto, 0, 0,
311		- serial_settings_change);
	301	+ err = recv_and_out(udpSocket, hDev, p_device_output_active, format_change,
	302	+ format_height, format_width, format_channels,
	303	+ format_colors, proto, 0, 0, serial_settings_change);
312	304
313	305	// close device
314	306	CloseHandle(hDev);
...	...	@@ -318,18 +310,13 @@ static int open_and_output(SOCKET udpSocket, char *device,
318	310
319	311	// open device and output frames in a loop
320	312	// returns error code (not for device-errors, 0 for success)
321		-static int open_and_output_loop(SOCKET udpSocket, char *device,
322		- int serial_settings_change,
	313	+static int
	314	+open_and_output_loop(SOCKET udpSocket, char *device, int serial_settings_change,
323	315	struct s_serial_settings *serial_settings,
324		- int reopen_device,
325		- unsigned int reopen_device_ms,
326		- unsigned int format_change,
327		- unsigned int format_height,
328		- unsigned int format_width,
329		- unsigned int format_channels,
330		- unsigned int format_colors,
331		- etBlinkenProto proto)
332		-{
	316	+ int reopen_device, unsigned int reopen_device_ms,
	317	+ unsigned int format_change, unsigned int format_height,
	318	+ unsigned int format_width, unsigned int format_channels,
	319	+ unsigned int format_colors, etBlinkenProto proto) {
333	320	int device_output_active, err;
334	321
335	322	printf("receiving frames and outputting them to \"%s\"...\n", device);
...	...	@@ -338,8 +325,7 @@ static int open_and_output_loop(SOCKET udpSocket, char *device,
338	325	for (;;) {
339	326
340	327	// try to open device and output frames
341		- err = open_and_output(udpSocket, device,
342		- &device_output_active,
	328	+ err = open_and_output(udpSocket, device, &device_output_active,
343	329	serial_settings_change, serial_settings,
344	330	format_change, format_height, format_width,
345	331	format_channels, format_colors, proto);
...	...	@@ -369,8 +354,7 @@ static int open_and_output_loop(SOCKET udpSocket, char *device,
369	354	return err;
370	355	}
371	356
372		-int main(int argCnt, char **args)
373		-{
	357	+int main(int argCnt, char **args) {
374	358	WSADATA WsaData;
375	359	int i, bound;
376	360	SOCKET udpSocket;
...	...	@@ -410,8 +394,10 @@ int main(int argCnt, char **args)
410	394	" -s <baud-rate>,<parity>,<data-bits>,<stop-bits>\n"
411	395	" settings to use for serial devices (defaults to no change)\n"
412	396	" -o <milliseconds>\n"
413		- " reopen device after short time on error (defaults to not reopen)\n"
414		- "\n", args[0]);
	397	+ " reopen device after short time on error (defaults to not "
	398	+ "reopen)\n"
	399	+ "\n",
	400	+ args[0]);
415	401	return 0;
416	402	}
417	403
...	...	@@ -511,10 +497,10 @@ int main(int argCnt, char **args)
511	497	else if (strcmp(args[i], "-f") == 0) {
512	498	if (i + 1 < argCnt) {
513	499	i++;
514		- if (sscanf
515		- (args[i], "%ux%u-%u/%u", &width, &height, &channels, &colors) == 4
516		- && width > 0 && width < 1000 && height > 0 && height < 1000
517		- && channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
	500	+ if (sscanf(args[i], "%ux%u-%u/%u", &width, &height, &channels,
	501	+ &colors) == 4 &&
	502	+ width > 0 && width < 1000 && height > 0 && height < 1000 &&
	503	+ channels > 0 && channels < 20 && colors > 1 && colors <= 256) {
518	504	format_change = 1;
519	505	format_height = height;
520	506	format_width = width;
...	...	@@ -548,8 +534,8 @@ int main(int argCnt, char **args)
548	534	else if (strcmp(args[i], "-o") == 0) {
549	535	if (i + 1 < argCnt) {
550	536	i++;
551		- if (sscanf(args[i], "%u", &reopen_device_ms) == 1
552		- && reopen_device_ms >= 1)
	537	+ if (sscanf(args[i], "%u", &reopen_device_ms) == 1 &&
	538	+ reopen_device_ms >= 1)
553	539	reopen_device = 1;
554	540	else
555	541	printf("invalid number of milliseconds \"%s\"\n", args[i]);
...	...	@@ -558,8 +544,7 @@ int main(int argCnt, char **args)
558	544	}
559	545	// unknown parameter
560	546	else
561		- printf
562		- ("unknown parameter \"%s\", call without parameters to get help\n",
	547	+ printf("unknown parameter \"%s\", call without parameters to get help\n",
563	548	args[i]);
564	549
565	550	} // for( i ...
...	...	@@ -580,9 +565,8 @@ int main(int argCnt, char **args)
580	565	}
581	566	}
582	567	// open device and output frames in a loop
583		- open_and_output_loop(udpSocket, device,
584		- serial_settings_change, &serial_settings,
585		- reopen_device, reopen_device_ms,
	568	+ open_and_output_loop(udpSocket, device, serial_settings_change,
	569	+ &serial_settings, reopen_device, reopen_device_ms,
586	570	format_change, format_height, format_width,
587	571	format_channels, format_colors, proto);
588	572

...	...	@@ -11,18 +11,17 @@
11	11	#include <ws2tcpip.h>
12	12	#define close closesocket
13	13	#else
14		-#include <unistd.h>
15		-#include <sys/types.h>
16		-#include <sys/socket.h>
17		-#include <netinet/in.h>
18	14	#include <arpa/inet.h>
	15	+#include <netinet/in.h>
	16	+#include <sys/socket.h>
	17	+#include <sys/types.h>
	18	+#include <unistd.h>
19	19	#endif
20	20
21		-#include <BlinkenLib/BlinkenLib.h>
22	21	#include "Tools2.h"
	22	+#include <BlinkenLib/BlinkenLib.h>
23	23
24		-int main(int argCnt, char **args)
25		-{
	24	+int main(int argCnt, char **args) {
26	25	int i, bound, val, timeout, ipv6;
27	26	SOCKET udpSocket, tmpSock;
28	27	struct sockaddr_in addr;
...	...	@@ -65,7 +64,8 @@ int main(int argCnt, char **args)
65	64	" -t <milliseconds>\n"
66	65	" set timeout (to detect movie end, defaults to 5000)\n"
67	66	" -o <file>\n"
68		- " receive movie and write it to file (.blm, .bmm, .bml, .bbm" MNGEXT GIFEXT ")\n\n",
	67	+ " receive movie and write it to file (.blm, .bmm, *.bml, "
	68	+ "*.bbm" MNGEXT GIFEXT ")\n\n",
69	69	args[0]);
70	70	return 0;
71	71	}
...	...	@@ -213,8 +213,7 @@ int main(int argCnt, char **args)
213	213	}
214	214	// unknown parameter
215	215	else
216		- printf
217		- ("unknown parameter \"%s\", call without parameters to get help\n",
	216	+ printf("unknown parameter \"%s\", call without parameters to get help\n",
218	217	args[i]);
219	218
220	219	} // for( i ...

...	...	@@ -12,18 +12,17 @@
12	12	#define close closesocket
13	13	#define strcasecmp stricmp
14	14	#else
15		-#include <unistd.h>
16		-#include <sys/types.h>
17		-#include <sys/socket.h>
18		-#include <netinet/in.h>
19	15	#include <arpa/inet.h>
	16	+#include <netinet/in.h>
	17	+#include <sys/socket.h>
	18	+#include <sys/types.h>
	19	+#include <unistd.h>
20	20	#endif
21	21
22		-#include <BlinkenLib/BlinkenLib.h>
23	22	#include "Tools2.h"
	23	+#include <BlinkenLib/BlinkenLib.h>
24	24
25		-int main(int argCnt, char **args)
26		-{
	25	+int main(int argCnt, char **args) {
27	26	int i, connected, ipv6;
28	27	SOCKET udpSocket, tmpSock;
29	28	etBlinkenProto proto;
...	...	@@ -68,11 +67,13 @@ int main(int argCnt, char **args)
68	67	" -p [BLP\|EBLP\|MCUF]\n"
69	68	" protocol to use (defaults to MCUF)\n"
70	69	" -t <milliseconds>\n"
71		- " set maximum idle time between frames (defaults to 3000, use 0 for infinite)\n"
	70	+ " set maximum idle time between frames (defaults to 3000, use 0 "
	71	+ "for infinite)\n"
72	72	" -n <number>\n"
73	73	" set number of times to send movies (defaults to 1)\n"
74	74	" -i <file>\n"
75		- " read movie from file (.blm, .bmm, .bml, .bbm" MNGEXT GIFEXT ") and send it\n"
	75	+ " read movie from file (.blm, .bmm, .bml, .bbm" MNGEXT GIFEXT
	76	+ ") and send it\n"
76	77	" -l <number>\n"
77	78	" loop number of times (defaults to 1, use 0 for forever)\n\n",
78	79	args[0]);
...	...	@@ -162,18 +163,15 @@ int main(int argCnt, char **args)
162	163	i++;
163	164	if (!ipv6) {
164	165	if (!txt2addr(args[i], &addr) \|\|
165		- connect(udpSocket, (struct sockaddr *)&addr,
166		- sizeof(addr)) != 0)
167		- printf("could not set destination address to \"%s\"\n",
168		- args[i]);
	166	+ connect(udpSocket, (struct sockaddr *)&addr, sizeof(addr)) != 0)
	167	+ printf("could not set destination address to \"%s\"\n", args[i]);
169	168	else
170	169	connected = 1;
171	170	} else {
172	171	if (!txt2addr6(args[i], &addr6) \|\|
173		- connect(udpSocket, (struct sockaddr *)&addr6,
174		- sizeof(addr6)) != 0)
175		- printf("could not set destination address to \"%s\"\n",
176		- args[i]);
	172	+ connect(udpSocket, (struct sockaddr *)&addr6, sizeof(addr6)) !=
	173	+ 0)
	174	+ printf("could not set destination address to \"%s\"\n", args[i]);
177	175	else
178	176	connected = 1;
179	177	}
...	...	@@ -228,9 +226,10 @@ int main(int argCnt, char **args)
228	226	" using default destination address \"127.0.0.1:2323\"\n",
229	227	args[i]);
230	228	if (!txt2addr("127.0.0.1:2323", &addr) \|\|
231		- connect(udpSocket, (struct sockaddr *)&addr,
232		- sizeof(addr)) != 0)
233		- printf("could not set destination address to \"127.0.0.1:2323\"\n");
	229	+ connect(udpSocket, (struct sockaddr *)&addr, sizeof(addr)) !=
	230	+ 0)
	231	+ printf("could not set destination address to "
	232	+ "\"127.0.0.1:2323\"\n");
234	233	else
235	234	connected = 1;
236	235	} else {
...	...	@@ -260,8 +259,7 @@ int main(int argCnt, char **args)
260	259	BlinkenMovieFree(pMovie);
261	260	}
262	261	} else
263		- printf("no destination address to sent movie \"%s\" to\n",
264		- args[i]);
	262	+ printf("no destination address to sent movie \"%s\" to\n", args[i]);
265	263	} else
266	264	printf("missing input filename for \"-i\"\n");
267	265	}
...	...	@@ -278,8 +276,8 @@ int main(int argCnt, char **args)
278	276	}
279	277	// unknown parameter
280	278	else
281		- printf
282		- ("unknown parameter \"%s\", call without parameters to get help\n",
	279	+ printf(
	280	+ "unknown parameter \"%s\", call without parameters to get help\n",
283	281	args[i]);
284	282
285	283	} // for( i ...

...	...	@@ -10,17 +10,16 @@
10	10	#include <winsock2.h>
11	11	#include <ws2tcpip.h>
12	12	#else
13		-#include <sys/types.h>
14		-#include <sys/socket.h>
15		-#include <netinet/in.h>
16	13	#include <arpa/inet.h>
	14	+#include <netinet/in.h>
	15	+#include <sys/socket.h>
	16	+#include <sys/types.h>
17	17	#endif
18	18
19	19	#include "Tools2.h"
20	20
21	21	#ifdef WIN32
22		-static int inet_pton(int af, const char src, void dst)
23		-{
	22	+static int inet_pton(int af, const char src, void dst) {
24	23	struct sockaddr_storage ss;
25	24	int size = sizeof(ss);
26	25	char src_copy[INET6_ADDRSTRLEN + 1];
...	...	@@ -29,7 +28,8 @@ static int inet_pton(int af, const char src, void dst)
29	28	strncpy(src_copy, src, sizeof(src_copy));
30	29	src_copy[sizeof(src_copy) - 1] = 0;
31	30
32		- if (WSAStringToAddress(src_copy, af, NULL, (struct sockaddr *)&ss, &size) == 0) {
	31	+ if (WSAStringToAddress(src_copy, af, NULL, (struct sockaddr *)&ss, &size) ==
	32	+ 0) {
33	33	switch (af) {
34	34	case AF_INET:
35	35	(struct in_addr )dst = ((struct sockaddr_in *)&ss)->sin_addr;
...	...	@@ -44,8 +44,7 @@ static int inet_pton(int af, const char src, void dst)
44	44	#endif
45	45
46	46	// convert text to IPv4 address
47		-int txt2addr(char text, struct sockaddr_in addr)
48		-{
	47	+int txt2addr(char text, struct sockaddr_in addr) {
49	48	char txt[48];
50	49	unsigned short port;
51	50
...	...	@@ -70,8 +69,7 @@ int txt2addr(char text, struct sockaddr_in addr)
70	69	}
71	70
72	71	// convert text to IPv6 address
73		-int txt2addr6(char text, struct sockaddr_in6 addr6)
74		-{
	72	+int txt2addr6(char text, struct sockaddr_in6 addr6) {
75	73	char txt[128];
76	74	unsigned short port;
77	75
78	76