BlinkenLib

BlinkenLib/BlinkenFrame.c    1) /* BlinkenLib

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

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

BlinkenFrame.c               5) 
BlinkenFrame.c               6) #include <stdio.h>
BlinkenFrame.c               7) #include <stdlib.h>
BlinkenFrame.c               8) #include <string.h>

BlinkenFrame.c               9) #ifdef WIN32
BlinkenFrame.c              10) #include <winsock2.h>
BlinkenFrame.c              11) #include <windows.h>
BlinkenFrame.c              12) typedef WORD uint16_t;
BlinkenFrame.c              13) typedef DWORD uint32_t;
BlinkenFrame.c              14) #else

BlinkenFrame.c              15) #include <stdint.h>
BlinkenFrame.c              16) #include <netinet/in.h>

BlinkenFrame.c              17) #endif

BlinkenFrame.c              18) 

BlinkenLib/BlinkenFrame.c   19) #include <BlinkenLib/BlinkenColorizer.h>
BlinkenLib/BlinkenFrame.c   20) #include <BlinkenLib/BlinkenFrame.h>

BlinkenFrame.c              21) 

src/BlinkenFrame.c          22) #include "BlinkenConstants.h"
src/BlinkenFrame.c          23) #include "BlinkenProtoIntern.h"
src/BlinkenFrame.c          24) #include "Tools.h"

BlinkenLib/BlinkenFrame.c   25) 

BlinkenLib/BlinkenFrame.c   26) struct sBlinkenFrame {

BlinkenFrame.c              27)   int height;
BlinkenFrame.c              28)   int width;
BlinkenFrame.c              29)   int channels;
BlinkenFrame.c              30)   int maxval;
BlinkenFrame.c              31)   int duration;

BlinkenLib/BlinkenFrame.c   32)   unsigned char **ppData;

BlinkenFrame.c              33) };
BlinkenFrame.c              34) 

BlinkenLib/BlinkenFrame.c   35) stBlinkenFrame *BlinkenFrameNew(int height, int width, int channels,
BlinkenLib/BlinkenFrame.c   36)                                 int maxval, int duration)

BlinkenFrame.c              37) {

BlinkenLib/BlinkenFrame.c   38)   stBlinkenFrame *pFrame;
BlinkenLib/BlinkenFrame.c   39) 
BlinkenLib/BlinkenFrame.c   40)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c   41)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c   42)   if (height > BlinkenHeightMax)
BlinkenLib/BlinkenFrame.c   43)     height = BlinkenHeightMax;
BlinkenLib/BlinkenFrame.c   44)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c   45)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c   46)   if (width > BlinkenWidthMax)
BlinkenLib/BlinkenFrame.c   47)     width = BlinkenWidthMax;
BlinkenLib/BlinkenFrame.c   48)   if (channels < BlinkenChannelsMin)
BlinkenLib/BlinkenFrame.c   49)     channels = BlinkenChannelsMin;
BlinkenLib/BlinkenFrame.c   50)   if (channels > BlinkenChannelsMax)
BlinkenLib/BlinkenFrame.c   51)     channels = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c   52)   if (maxval < BlinkenMaxvalMin)
BlinkenLib/BlinkenFrame.c   53)     maxval = BlinkenMaxvalMin;
BlinkenLib/BlinkenFrame.c   54)   if (maxval > BlinkenMaxvalMax)
BlinkenLib/BlinkenFrame.c   55)     maxval = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c   56)   if (duration < BlinkenDurationMin)
BlinkenLib/BlinkenFrame.c   57)     duration = BlinkenDurationMin;
BlinkenLib/BlinkenFrame.c   58)   if (duration > BlinkenDurationMax)
BlinkenLib/BlinkenFrame.c   59)     duration = BlinkenDurationMax;
BlinkenLib/BlinkenFrame.c   60) 
BlinkenLib/BlinkenFrame.c   61)   pFrame = (stBlinkenFrame *) malloc(sizeof(stBlinkenFrame));
BlinkenLib/BlinkenFrame.c   62)   if (pFrame == NULL)

BlinkenFrame.c              63)     return NULL;
BlinkenFrame.c              64) 
BlinkenFrame.c              65)   pFrame->height = height;
BlinkenFrame.c              66)   pFrame->width = width;
BlinkenFrame.c              67)   pFrame->channels = channels;
BlinkenFrame.c              68)   pFrame->maxval = maxval;
BlinkenFrame.c              69)   pFrame->duration = duration;
BlinkenFrame.c              70) 

BlinkenLib/BlinkenFrame.c   71)   pFrame->ppData =

BlinkenLib/BlinkenFrame.c   72)       (unsigned char **)BlinkenMalloc2D(height, width * channels,
BlinkenLib/BlinkenFrame.c   73)                                         sizeof(unsigned char));

BlinkenLib/BlinkenFrame.c   74)   if (pFrame->ppData == NULL) {
BlinkenLib/BlinkenFrame.c   75)     free(pFrame);

BlinkenFrame.c              76)     return NULL;
BlinkenFrame.c              77)   }
BlinkenFrame.c              78) 
BlinkenFrame.c              79)   return pFrame;
BlinkenFrame.c              80) }
BlinkenFrame.c              81) 

BlinkenLib/BlinkenFrame.c   82) stBlinkenFrame *BlinkenFrameClone(stBlinkenFrame *pSrcFrame)

BlinkenFrame.c              83) {

BlinkenFrame.c              84)   int y, x, c, i;

BlinkenLib/BlinkenFrame.c   85)   stBlinkenFrame *pFrame;

BlinkenFrame.c              86) 

BlinkenLib/BlinkenFrame.c   87)   if (pSrcFrame == NULL)

BlinkenFrame.c              88)     return NULL;
BlinkenFrame.c              89) 

BlinkenLib/BlinkenFrame.c   90)   pFrame = BlinkenFrameNew(pSrcFrame->height, pSrcFrame->width,
BlinkenLib/BlinkenFrame.c   91)                            pSrcFrame->channels, pSrcFrame->maxval,
BlinkenLib/BlinkenFrame.c   92)                            pSrcFrame->duration);
BlinkenLib/BlinkenFrame.c   93)   if (pFrame == NULL)

BlinkenFrame.c              94)     return NULL;
BlinkenFrame.c              95) 

BlinkenLib/BlinkenFrame.c   96)   for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c   97)     for (x = 0, i = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c   98)       for (c = 0; c < pFrame->channels; c++, i++)

BlinkenFrame.c              99)         pFrame->ppData[y][i] = pSrcFrame->ppData[y][i];

BlinkenFrame.c             100) 
BlinkenFrame.c             101)   return pFrame;
BlinkenFrame.c             102) }
BlinkenFrame.c             103) 

BlinkenLib/BlinkenFrame.c  104) void BlinkenFrameFree(stBlinkenFrame *pFrame)

BlinkenFrame.c             105) {

BlinkenLib/BlinkenFrame.c  106)   if (pFrame == NULL)

BlinkenFrame.c             107)     return;
BlinkenFrame.c             108) 

BlinkenLib/BlinkenFrame.c  109)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c  110)   free(pFrame);

BlinkenFrame.c             111) }
BlinkenFrame.c             112) 

BlinkenLib/BlinkenFrame.c  113) void BlinkenFrameClear(stBlinkenFrame *pFrame)

BlinkenFrame.c             114) {

BlinkenFrame.c             115)   int y, x, c, i;

BlinkenFrame.c             116) 

BlinkenLib/BlinkenFrame.c  117)   if (pFrame == NULL)

BlinkenFrame.c             118)     return;
BlinkenFrame.c             119) 

BlinkenLib/BlinkenFrame.c  120)   for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c  121)     for (x = 0, i = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c  122)       for (c = 0; c < pFrame->channels; c++, i++)

BlinkenFrame.c             123)         pFrame->ppData[y][i] = 0;

BlinkenFrame.c             124) }
BlinkenFrame.c             125) 

BlinkenLib/BlinkenFrame.c  126) int BlinkenFrameGetHeight(stBlinkenFrame *pFrame)

BlinkenFrame.c             127) {

BlinkenLib/BlinkenFrame.c  128)   if (pFrame == NULL)

BlinkenFrame.c             129)     return 0;
BlinkenFrame.c             130) 
BlinkenFrame.c             131)   return pFrame->height;
BlinkenFrame.c             132) }
BlinkenFrame.c             133) 

BlinkenLib/BlinkenFrame.c  134) int BlinkenFrameGetWidth(stBlinkenFrame *pFrame)

BlinkenFrame.c             135) {

BlinkenLib/BlinkenFrame.c  136)   if (pFrame == NULL)

BlinkenFrame.c             137)     return 0;
BlinkenFrame.c             138) 
BlinkenFrame.c             139)   return pFrame->width;
BlinkenFrame.c             140) }
BlinkenFrame.c             141) 

BlinkenLib/BlinkenFrame.c  142) int BlinkenFrameGetChannels(stBlinkenFrame *pFrame)

BlinkenFrame.c             143) {

BlinkenLib/BlinkenFrame.c  144)   if (pFrame == NULL)

BlinkenFrame.c             145)     return 0;
BlinkenFrame.c             146) 
BlinkenFrame.c             147)   return pFrame->channels;
BlinkenFrame.c             148) }
BlinkenFrame.c             149) 

BlinkenLib/BlinkenFrame.c  150) int BlinkenFrameGetMaxval(stBlinkenFrame *pFrame)

BlinkenFrame.c             151) {

BlinkenLib/BlinkenFrame.c  152)   if (pFrame == NULL)

BlinkenFrame.c             153)     return 0;
BlinkenFrame.c             154) 
BlinkenFrame.c             155)   return pFrame->maxval;
BlinkenFrame.c             156) }
BlinkenFrame.c             157) 

BlinkenLib/BlinkenFrame.c  158) int BlinkenFrameGetDuration(stBlinkenFrame *pFrame)

BlinkenFrame.c             159) {

BlinkenLib/BlinkenFrame.c  160)   if (pFrame == NULL)

BlinkenFrame.c             161)     return 0;
BlinkenFrame.c             162) 
BlinkenFrame.c             163)   return pFrame->duration;
BlinkenFrame.c             164) }
BlinkenFrame.c             165) 

BlinkenLib/BlinkenFrame.c  166) void BlinkenFrameSetDuration(stBlinkenFrame *pFrame, int duration)

BlinkenFrame.c             167) {

BlinkenLib/BlinkenFrame.c  168)   if (pFrame == NULL)

BlinkenFrame.c             169)     return;
BlinkenFrame.c             170) 

BlinkenLib/BlinkenFrame.c  171)   if (duration < BlinkenDurationMin)
BlinkenLib/BlinkenFrame.c  172)     duration = BlinkenDurationMin;
BlinkenLib/BlinkenFrame.c  173)   if (duration > BlinkenDurationMax)
BlinkenLib/BlinkenFrame.c  174)     duration = BlinkenDurationMax;

BlinkenFrame.c             175) 
BlinkenFrame.c             176)   pFrame->duration = duration;
BlinkenFrame.c             177) }
BlinkenFrame.c             178) 

BlinkenLib/BlinkenFrame.c  179) unsigned char BlinkenFrameGetPixel(stBlinkenFrame *pFrame, int y, int x,

BlinkenLib/BlinkenFrame.c  180)                                    int c)

BlinkenFrame.c             181) {

BlinkenLib/BlinkenFrame.c  182)   if (pFrame == NULL ||

BlinkenFrame.c             183)       y < 0 || y >= pFrame->height ||

BlinkenLib/BlinkenFrame.c  184)       x < 0 || x >= pFrame->width || c < 0 || c >= pFrame->channels)
BlinkenLib/BlinkenFrame.c  185)     return 0;

BlinkenFrame.c             186) 

BlinkenFrame.c             187)   return pFrame->ppData[y][x * pFrame->channels + c];

BlinkenFrame.c             188) }
BlinkenFrame.c             189) 

BlinkenLib/BlinkenFrame.c  190) void BlinkenFrameSetPixel(stBlinkenFrame *pFrame, int y, int x, int c,

BlinkenLib/BlinkenFrame.c  191)                           unsigned char val)

BlinkenFrame.c             192) {

BlinkenLib/BlinkenFrame.c  193)   if (pFrame == NULL ||

BlinkenFrame.c             194)       y < 0 || y >= pFrame->height ||

BlinkenLib/BlinkenFrame.c  195)       x < 0 || x >= pFrame->width || c < 0 || c >= pFrame->channels)
BlinkenLib/BlinkenFrame.c  196)     return;

BlinkenFrame.c             197) 

BlinkenLib/BlinkenFrame.c  198)   if (val > pFrame->maxval)

BlinkenFrame.c             199)     val = pFrame->maxval;

BlinkenFrame.c             200)   pFrame->ppData[y][x * pFrame->channels + c] = val;

BlinkenFrame.c             201) }
BlinkenFrame.c             202) 

BlinkenLib/BlinkenFrame.c  203) unsigned long BlinkenFrameGetColor(stBlinkenFrame *pFrame, int y, int x)

BlinkenFrame.c             204) {

BlinkenFrame.c             205)   int i;
BlinkenFrame.c             206) 

BlinkenLib/BlinkenFrame.c  207)   if (pFrame == NULL ||
BlinkenLib/BlinkenFrame.c  208)       y < 0 || y >= pFrame->height || x < 0 || x >= pFrame->width)
BlinkenLib/BlinkenFrame.c  209)     return 0;

BlinkenFrame.c             210) 

BlinkenFrame.c             211)   i = x * pFrame->channels;

BlinkenFrame.c             212) 

BlinkenLib/BlinkenFrame.c  213)   if (pFrame->channels == 1)
BlinkenLib/BlinkenFrame.c  214)     return (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
BlinkenLib/BlinkenFrame.c  215)              pFrame->maxval / 2) /
BlinkenLib/BlinkenFrame.c  216)             pFrame->
BlinkenLib/BlinkenFrame.c  217)             maxval) << 16 | (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
BlinkenLib/BlinkenFrame.c  218)                               pFrame->maxval / 2) /
BlinkenLib/BlinkenFrame.c  219)                              pFrame->maxval) << 8 | (((unsigned long)
BlinkenLib/BlinkenFrame.c  220)                                                       pFrame->ppData[y][i +
BlinkenLib/BlinkenFrame.c  221)                                                                         0] *
BlinkenLib/BlinkenFrame.c  222)                                                       255 +
BlinkenLib/BlinkenFrame.c  223)                                                       pFrame->maxval / 2) /
BlinkenLib/BlinkenFrame.c  224)                                                      pFrame->maxval);
BlinkenLib/BlinkenFrame.c  225)   if (pFrame->channels == 2)
BlinkenLib/BlinkenFrame.c  226)     return (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
BlinkenLib/BlinkenFrame.c  227)              pFrame->maxval / 2) /
BlinkenLib/BlinkenFrame.c  228)             pFrame->
BlinkenLib/BlinkenFrame.c  229)             maxval) << 16 | (((unsigned long)pFrame->ppData[y][i + 1] * 255 +
BlinkenLib/BlinkenFrame.c  230)                               pFrame->maxval / 2) / pFrame->maxval) << 8;
BlinkenLib/BlinkenFrame.c  231)   return (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
BlinkenLib/BlinkenFrame.c  232)            pFrame->maxval / 2) /
BlinkenLib/BlinkenFrame.c  233)           pFrame->maxval) << 16 | (((unsigned long)pFrame->ppData[y][i + 1] *
BlinkenLib/BlinkenFrame.c  234)                                     255 +
BlinkenLib/BlinkenFrame.c  235)                                     pFrame->maxval / 2) /
BlinkenLib/BlinkenFrame.c  236)                                    pFrame->maxval) << 8 | (((unsigned long)
BlinkenLib/BlinkenFrame.c  237)                                                             pFrame->ppData[y]
BlinkenLib/BlinkenFrame.c  238)                                                             [i + 2] * 255 +
BlinkenLib/BlinkenFrame.c  239)                                                             pFrame->maxval /
BlinkenLib/BlinkenFrame.c  240)                                                             2) /
BlinkenLib/BlinkenFrame.c  241)                                                            pFrame->maxval);

BlinkenFrame.c             242) }
BlinkenFrame.c             243) 

BlinkenLib/BlinkenFrame.c  244) void BlinkenFrameSetColor(stBlinkenFrame *pFrame, int y, int x,

BlinkenLib/BlinkenFrame.c  245)                           unsigned long color)

BlinkenFrame.c             246) {

BlinkenFrame.c             247)   int i, alpha, alpha_, c;

BlinkenFrame.c             248) 

BlinkenLib/BlinkenFrame.c  249)   if (pFrame == NULL ||
BlinkenLib/BlinkenFrame.c  250)       y < 0 || y >= pFrame->height || x < 0 || x >= pFrame->width)
BlinkenLib/BlinkenFrame.c  251)     return;

BlinkenFrame.c             252) 

BlinkenFrame.c             253)   i = x * pFrame->channels;

BlinkenFrame.c             254) 

BlinkenFrame.c             255)   alpha = (color >> 24) & 0xFF;
BlinkenFrame.c             256)   alpha_ = 255 - alpha;

BlinkenLib/BlinkenFrame.c  257)   if (pFrame->channels >= 1)
BlinkenLib/BlinkenFrame.c  258)     pFrame->ppData[y][i + 0] =
BlinkenLib/BlinkenFrame.c  259)         (unsigned
BlinkenLib/BlinkenFrame.c  260)          char)((((((color >> 16) & 0xFF) * pFrame->maxval +
BlinkenLib/BlinkenFrame.c  261)                   127) / 255) * alpha + (unsigned long)pFrame->ppData[y][i +
BlinkenLib/BlinkenFrame.c  262)                                                                          0] *
BlinkenLib/BlinkenFrame.c  263)                 alpha_) / 255);
BlinkenLib/BlinkenFrame.c  264)   if (pFrame->channels >= 2)
BlinkenLib/BlinkenFrame.c  265)     pFrame->ppData[y][i + 1] =
BlinkenLib/BlinkenFrame.c  266)         (unsigned
BlinkenLib/BlinkenFrame.c  267)          char)((((((color >> 8) & 0xFF) * pFrame->maxval +
BlinkenLib/BlinkenFrame.c  268)                   127) / 255) * alpha + (unsigned long)pFrame->ppData[y][i +
BlinkenLib/BlinkenFrame.c  269)                                                                          1] *
BlinkenLib/BlinkenFrame.c  270)                 alpha_) / 255);
BlinkenLib/BlinkenFrame.c  271)   if (pFrame->channels >= 3)
BlinkenLib/BlinkenFrame.c  272)     pFrame->ppData[y][i + 2] =
BlinkenLib/BlinkenFrame.c  273)         (unsigned
BlinkenLib/BlinkenFrame.c  274)          char)(((((color & 0xFF) * pFrame->maxval + 127) / 255) * alpha +
BlinkenLib/BlinkenFrame.c  275)                 (unsigned long)pFrame->ppData[y][i + 2] * alpha_) / 255);
BlinkenLib/BlinkenFrame.c  276)   for (c = 3; c < pFrame->channels; c++)

BlinkenLib/BlinkenFrame.c  277)     pFrame->ppData[y][i + c] = (unsigned char)((0 + (unsigned long)

BlinkenLib/BlinkenFrame.c  278)                                                 pFrame->ppData[y][i +
BlinkenLib/BlinkenFrame.c  279)                                                                   c] *
BlinkenLib/BlinkenFrame.c  280)                                                 alpha_) / 255);

BlinkenFrame.c             281) }
BlinkenFrame.c             282) 

BlinkenLib/BlinkenFrame.c  283) int BlinkenFrameIsEmpty(stBlinkenFrame *pFrame)

BlinkenLib/BlinkenFrame.c  284) // returns 1 if frame is empty (i.e. black), returns 0 otherwise

BlinkenLib/BlinkenFrame.c  285) {
BlinkenLib/BlinkenFrame.c  286)   int y, x, c, i;
BlinkenLib/BlinkenFrame.c  287) 

BlinkenLib/BlinkenFrame.c  288)   if (pFrame == NULL)

BlinkenLib/BlinkenFrame.c  289)     return 0;
BlinkenLib/BlinkenFrame.c  290) 

BlinkenLib/BlinkenFrame.c  291)   for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c  292)     for (x = 0, i = 0; x < pFrame->width; x++) {
BlinkenLib/BlinkenFrame.c  293)       for (c = 0; c < pFrame->channels; c++, i++) {
BlinkenLib/BlinkenFrame.c  294)         if (pFrame->ppData[y][i] != 0)
BlinkenLib/BlinkenFrame.c  295)           break;        // pixel is not black -> abort

BlinkenLib/BlinkenFrame.c  296)       }

BlinkenLib/BlinkenFrame.c  297)       if (c < pFrame->channels)

BlinkenLib/BlinkenFrame.c  298)         break;
BlinkenLib/BlinkenFrame.c  299)     }

BlinkenLib/BlinkenFrame.c  300)     if (x < pFrame->width)

BlinkenLib/BlinkenFrame.c  301)       break;
BlinkenLib/BlinkenFrame.c  302)   }

BlinkenLib/BlinkenFrame.c  303)   if (y < pFrame->height)
BlinkenLib/BlinkenFrame.c  304)     return 0;   // aborted somewhere -> at least ony pixel is not black

BlinkenLib/BlinkenFrame.c  305)   else

BlinkenLib/BlinkenFrame.c  306)     return 1;   // not aborted -> all pixels are black

BlinkenLib/BlinkenFrame.c  307) }
BlinkenLib/BlinkenFrame.c  308) 

BlinkenLib/BlinkenFrame.c  309) int BlinkenFrameCompare(stBlinkenFrame *pFrame1, stBlinkenFrame *pFrame2)

BlinkenLib/BlinkenFrame.c  310) // returns -1 for frame1 smaller, 0 for equal, 1 for frame2 smaller

BlinkenFrame.c             311) {
BlinkenFrame.c             312)   int y, cmp;
BlinkenFrame.c             313) 

BlinkenLib/BlinkenFrame.c  314)   if (pFrame1->height < pFrame2->height)

BlinkenFrame.c             315)     return -1;

BlinkenLib/BlinkenFrame.c  316)   if (pFrame1->height > pFrame2->height)

BlinkenFrame.c             317)     return 1;

BlinkenLib/BlinkenFrame.c  318)   if (pFrame1->width < pFrame2->width)

BlinkenFrame.c             319)     return -1;

BlinkenLib/BlinkenFrame.c  320)   if (pFrame1->width > pFrame2->width)

BlinkenFrame.c             321)     return 1;

BlinkenLib/BlinkenFrame.c  322)   if (pFrame1->channels < pFrame2->channels)

BlinkenFrame.c             323)     return -1;

BlinkenLib/BlinkenFrame.c  324)   if (pFrame1->channels > pFrame2->channels)

BlinkenFrame.c             325)     return 1;

BlinkenLib/BlinkenFrame.c  326)   if (pFrame1->maxval < pFrame2->maxval)

BlinkenFrame.c             327)     return -1;

BlinkenLib/BlinkenFrame.c  328)   if (pFrame1->maxval > pFrame2->maxval)

BlinkenFrame.c             329)     return 1;
BlinkenFrame.c             330) 

BlinkenLib/BlinkenFrame.c  331)   for (y = 0; y < pFrame1->height; y++) {
BlinkenLib/BlinkenFrame.c  332)     cmp =
BlinkenLib/BlinkenFrame.c  333)         memcmp(pFrame1->ppData[y], pFrame2->ppData[y],
BlinkenLib/BlinkenFrame.c  334)                pFrame1->width * pFrame2->channels);
BlinkenLib/BlinkenFrame.c  335)     if (cmp != 0)

BlinkenFrame.c             336)       return cmp;
BlinkenFrame.c             337)   }
BlinkenFrame.c             338) 
BlinkenFrame.c             339)   return 0;
BlinkenFrame.c             340) }
BlinkenFrame.c             341) 

BlinkenLib/BlinkenFrame.c  342) static void BlinkenFramePadCrop(stBlinkenFrame *pFrame, int height, int width,
BlinkenLib/BlinkenFrame.c  343)                                 int channels, int maxval,
BlinkenLib/BlinkenFrame.c  344)                                 int emptyY, int emptyX, int skipY, int skipX)

BlinkenFrame.c             345) {

BlinkenLib/BlinkenFrame.c  346)   unsigned char **ppData;

BlinkenFrame.c             347)   int y, x, c, i, j;

BlinkenLib/BlinkenFrame.c  348)   int rangeY, rangeX;

BlinkenFrame.c             349)   unsigned long val, div;
BlinkenFrame.c             350) 

BlinkenLib/BlinkenFrame.c  351)   if (pFrame == NULL)

BlinkenFrame.c             352)     return;
BlinkenFrame.c             353) 

BlinkenLib/BlinkenFrame.c  354)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  355)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  356)   if (height > BlinkenHeightMax)
BlinkenLib/BlinkenFrame.c  357)     height = BlinkenHeightMax;
BlinkenLib/BlinkenFrame.c  358)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  359)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  360)   if (width > BlinkenWidthMax)
BlinkenLib/BlinkenFrame.c  361)     width = BlinkenWidthMax;
BlinkenLib/BlinkenFrame.c  362)   if (channels < BlinkenChannelsMin)
BlinkenLib/BlinkenFrame.c  363)     channels = BlinkenChannelsMin;
BlinkenLib/BlinkenFrame.c  364)   if (channels > BlinkenChannelsMax)
BlinkenLib/BlinkenFrame.c  365)     channels = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  366)   if (maxval < BlinkenMaxvalMin)
BlinkenLib/BlinkenFrame.c  367)     maxval = BlinkenMaxvalMin;
BlinkenLib/BlinkenFrame.c  368)   if (maxval > BlinkenMaxvalMax)
BlinkenLib/BlinkenFrame.c  369)     maxval = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  370) 

BlinkenLib/BlinkenFrame.c  371)   if (height == pFrame->height && width == pFrame->width &&
BlinkenLib/BlinkenFrame.c  372)       channels == pFrame->channels && maxval == pFrame->maxval &&
BlinkenLib/BlinkenFrame.c  373)       emptyX == 0 && emptyY == 0 && skipY == 0 && skipX == 0)

BlinkenFrame.c             374)     return;
BlinkenFrame.c             375) 

BlinkenLib/BlinkenFrame.c  376)   // allocate new data array

BlinkenLib/BlinkenFrame.c  377)   ppData = (unsigned char **)BlinkenMalloc2D(height, width * channels,
BlinkenLib/BlinkenFrame.c  378)                                              sizeof(unsigned char));

BlinkenLib/BlinkenFrame.c  379)   if (ppData == NULL)

BlinkenFrame.c             380)     return;

BlinkenLib/BlinkenFrame.c  381)   for (y = 0; y < height; y++)
BlinkenLib/BlinkenFrame.c  382)     for (x = 0, i = 0; x < width; x++)
BlinkenLib/BlinkenFrame.c  383)       for (c = 0; c < channels; c++, i++)

BlinkenFrame.c             384)         ppData[y][i] = 0;

BlinkenFrame.c             385) 

BlinkenLib/BlinkenFrame.c  386)   // sanitize number of pixels to skip / to leave empty in X and Y direction
BlinkenLib/BlinkenFrame.c  387)   if (emptyY < 0)

BlinkenFrame.c             388)     emptyY = 0;

BlinkenLib/BlinkenFrame.c  389)   if (emptyY > height)
BlinkenLib/BlinkenFrame.c  390)     emptyY = height;
BlinkenLib/BlinkenFrame.c  391)   if (emptyX < 0)

BlinkenFrame.c             392)     emptyX = 0;

BlinkenLib/BlinkenFrame.c  393)   if (emptyX > width)
BlinkenLib/BlinkenFrame.c  394)     emptyX = width;
BlinkenLib/BlinkenFrame.c  395)   if (skipY < 0)
BlinkenLib/BlinkenFrame.c  396)     skipY = 0;
BlinkenLib/BlinkenFrame.c  397)   if (skipY > pFrame->height)
BlinkenLib/BlinkenFrame.c  398)     skipY = pFrame->height;
BlinkenLib/BlinkenFrame.c  399)   if (skipX < 0)
BlinkenLib/BlinkenFrame.c  400)     skipX = 0;
BlinkenLib/BlinkenFrame.c  401)   if (skipX > pFrame->width)
BlinkenLib/BlinkenFrame.c  402)     skipX = pFrame->width;
BlinkenLib/BlinkenFrame.c  403)   rangeY = mini(height - emptyY, pFrame->height - skipY);
BlinkenLib/BlinkenFrame.c  404)   rangeX = mini(width - emptyX, pFrame->width - skipX);

BlinkenFrame.c             405) 

BlinkenLib/BlinkenFrame.c  406)   // pad/crop frame with help of calculated parameters

BlinkenLib/BlinkenFrame.c  407)   for (y = 0; y < rangeY; y++) {
BlinkenLib/BlinkenFrame.c  408)     for (x = 0; x < rangeX; x++) {

BlinkenFrame.c             409)       i = (skipX + x) * pFrame->channels;
BlinkenFrame.c             410)       j = (emptyX + x) * channels;

BlinkenLib/BlinkenFrame.c  411)       if (channels >= pFrame->channels) // add channels: copy last channel
BlinkenLib/BlinkenFrame.c  412)         // into new channels

BlinkenFrame.c             413)       {

BlinkenLib/BlinkenFrame.c  414)         for (c = 0; c < pFrame->channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  415)           ppData[emptyY + y][j] =
BlinkenLib/BlinkenFrame.c  416)               (unsigned
BlinkenLib/BlinkenFrame.c  417)                char)(((unsigned long)pFrame->ppData[skipY + y][i] * maxval +
BlinkenLib/BlinkenFrame.c  418)                       pFrame->maxval / 2) / pFrame->maxval);
BlinkenLib/BlinkenFrame.c  419)         for (; c < channels; c++, j++)

BlinkenFrame.c             420)           ppData[emptyY + y][j] = ppData[emptyY + y][j - 1];

BlinkenLib/BlinkenFrame.c  421)       } else    // remove channels: merge leftover channels with last kept
BlinkenLib/BlinkenFrame.c  422)         // channel

BlinkenFrame.c             423)       {
BlinkenFrame.c             424)         val = 0;

BlinkenLib/BlinkenFrame.c  425)         for (c = 0; c < channels - 1; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  426)           ppData[emptyY + y][j] =
BlinkenLib/BlinkenFrame.c  427)               (unsigned
BlinkenLib/BlinkenFrame.c  428)                char)(((unsigned long)pFrame->ppData[skipY + y][i] * maxval +
BlinkenLib/BlinkenFrame.c  429)                       pFrame->maxval / 2) / pFrame->maxval);
BlinkenLib/BlinkenFrame.c  430)         for (c = channels - 1; c < pFrame->channels; c++, i++)

BlinkenFrame.c             431)           val += (unsigned long)pFrame->ppData[skipY + y][i];

BlinkenFrame.c             432)         div = pFrame->maxval * (pFrame->channels - channels + 1);

BlinkenLib/BlinkenFrame.c  433)         ppData[emptyY + y][j++] =
BlinkenLib/BlinkenFrame.c  434)             (unsigned char)((val * maxval + div / 2) / div);

BlinkenFrame.c             435)       }
BlinkenFrame.c             436)     }
BlinkenFrame.c             437)   }
BlinkenFrame.c             438) 
BlinkenFrame.c             439)   pFrame->height = height;
BlinkenFrame.c             440)   pFrame->width = width;
BlinkenFrame.c             441)   pFrame->channels = channels;
BlinkenFrame.c             442)   pFrame->maxval = maxval;

BlinkenLib/BlinkenFrame.c  443)   free(pFrame->ppData);

BlinkenFrame.c             444)   pFrame->ppData = ppData;

BlinkenFrame.c             445) }
BlinkenFrame.c             446) 

BlinkenLib/BlinkenFrame.c  447) void BlinkenFrameResize(stBlinkenFrame *pFrame, int height, int width,
BlinkenLib/BlinkenFrame.c  448)                         int channels, int maxval)
BlinkenLib/BlinkenFrame.c  449) {
BlinkenLib/BlinkenFrame.c  450)   int emptyY, emptyX, skipY, skipX;
BlinkenLib/BlinkenFrame.c  451) 
BlinkenLib/BlinkenFrame.c  452)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  453)     return;
BlinkenLib/BlinkenFrame.c  454) 
BlinkenLib/BlinkenFrame.c  455)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  456)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  457)   if (height > BlinkenHeightMax)
BlinkenLib/BlinkenFrame.c  458)     height = BlinkenHeightMax;
BlinkenLib/BlinkenFrame.c  459)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  460)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  461)   if (width > BlinkenWidthMax)
BlinkenLib/BlinkenFrame.c  462)     width = BlinkenWidthMax;
BlinkenLib/BlinkenFrame.c  463)   if (channels < BlinkenChannelsMin)
BlinkenLib/BlinkenFrame.c  464)     channels = BlinkenChannelsMin;
BlinkenLib/BlinkenFrame.c  465)   if (channels > BlinkenChannelsMax)
BlinkenLib/BlinkenFrame.c  466)     channels = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  467)   if (maxval < BlinkenMaxvalMin)
BlinkenLib/BlinkenFrame.c  468)     maxval = BlinkenMaxvalMin;
BlinkenLib/BlinkenFrame.c  469)   if (maxval > BlinkenMaxvalMax)
BlinkenLib/BlinkenFrame.c  470)     maxval = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  471) 
BlinkenLib/BlinkenFrame.c  472)   if (height == pFrame->height && width == pFrame->width &&
BlinkenLib/BlinkenFrame.c  473)       channels == pFrame->channels && maxval == pFrame->maxval)
BlinkenLib/BlinkenFrame.c  474)     return;
BlinkenLib/BlinkenFrame.c  475) 
BlinkenLib/BlinkenFrame.c  476)   // get number of pixels to skip / to leave empty in X and Y direction
BlinkenLib/BlinkenFrame.c  477)   if (height > pFrame->height) {
BlinkenLib/BlinkenFrame.c  478)     emptyY = (height - pFrame->height) / 2;
BlinkenLib/BlinkenFrame.c  479)     skipY = 0;
BlinkenLib/BlinkenFrame.c  480)   } else {
BlinkenLib/BlinkenFrame.c  481)     emptyY = 0;
BlinkenLib/BlinkenFrame.c  482)     skipY = (pFrame->height - height) / 2;
BlinkenLib/BlinkenFrame.c  483)   }
BlinkenLib/BlinkenFrame.c  484)   if (width > pFrame->width) {
BlinkenLib/BlinkenFrame.c  485)     emptyX = (width - pFrame->width) / 2;
BlinkenLib/BlinkenFrame.c  486)     skipX = 0;
BlinkenLib/BlinkenFrame.c  487)   } else {
BlinkenLib/BlinkenFrame.c  488)     emptyX = 0;
BlinkenLib/BlinkenFrame.c  489)     skipX = (pFrame->width - width) / 2;
BlinkenLib/BlinkenFrame.c  490)   }
BlinkenLib/BlinkenFrame.c  491) 
BlinkenLib/BlinkenFrame.c  492)   // resize frame with help of calculated parameters
BlinkenLib/BlinkenFrame.c  493)   BlinkenFramePadCrop(pFrame, height, width, channels, maxval,
BlinkenLib/BlinkenFrame.c  494)                       emptyY, emptyX, skipY, skipX);
BlinkenLib/BlinkenFrame.c  495) }
BlinkenLib/BlinkenFrame.c  496) 
BlinkenLib/BlinkenFrame.c  497) void BlinkenFrameCrop(stBlinkenFrame *pFrame, int top, int left,
BlinkenLib/BlinkenFrame.c  498)                       int height, int width)
BlinkenLib/BlinkenFrame.c  499) {
BlinkenLib/BlinkenFrame.c  500)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  501)     return;
BlinkenLib/BlinkenFrame.c  502) 
BlinkenLib/BlinkenFrame.c  503)   if (top < 0)
BlinkenLib/BlinkenFrame.c  504)     top = 0;
BlinkenLib/BlinkenFrame.c  505)   if (top > pFrame->height - BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  506)     top = pFrame->height - BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  507)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  508)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  509)   if (height > pFrame->height - top)
BlinkenLib/BlinkenFrame.c  510)     height = pFrame->height - top;
BlinkenLib/BlinkenFrame.c  511)   if (left < 0)
BlinkenLib/BlinkenFrame.c  512)     left = 0;
BlinkenLib/BlinkenFrame.c  513)   if (left > pFrame->width - BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  514)     left = pFrame->width - BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  515)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  516)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  517)   if (width > pFrame->width - left)
BlinkenLib/BlinkenFrame.c  518)     width = pFrame->width - left;
BlinkenLib/BlinkenFrame.c  519) 
BlinkenLib/BlinkenFrame.c  520)   if (top == 0 && left == 0 &&
BlinkenLib/BlinkenFrame.c  521)       height == pFrame->height && width == pFrame->width)
BlinkenLib/BlinkenFrame.c  522)     return;
BlinkenLib/BlinkenFrame.c  523) 
BlinkenLib/BlinkenFrame.c  524)   // crop frame with help of calculated parameters
BlinkenLib/BlinkenFrame.c  525)   BlinkenFramePadCrop(pFrame, height, width, pFrame->channels, pFrame->maxval,
BlinkenLib/BlinkenFrame.c  526)                       0, 0, top, left);
BlinkenLib/BlinkenFrame.c  527) }
BlinkenLib/BlinkenFrame.c  528) 

BlinkenLib/BlinkenFrame.c  529) void BlinkenFrameScale(stBlinkenFrame *pFrame, int height, int width)

BlinkenFrame.c             530) {

BlinkenLib/BlinkenFrame.c  531)   unsigned char **ppData;

BlinkenFrame.c             532)   double scaleHor, scaleVer, ox, oy, ox1, oy1, val;

BlinkenFrame.c             533)   int chans, c, nx, ny, x, y, oxi, oyi, ox1i, oy1i;

BlinkenFrame.c             534) 

BlinkenLib/BlinkenFrame.c  535)   if (pFrame == NULL)

BlinkenFrame.c             536)     return;
BlinkenFrame.c             537) 

BlinkenLib/BlinkenFrame.c  538)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  539)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  540)   if (height > BlinkenHeightMax)
BlinkenLib/BlinkenFrame.c  541)     height = BlinkenHeightMax;
BlinkenLib/BlinkenFrame.c  542)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  543)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  544)   if (width > BlinkenWidthMax)
BlinkenLib/BlinkenFrame.c  545)     width = BlinkenWidthMax;

BlinkenFrame.c             546) 

BlinkenLib/BlinkenFrame.c  547)   if (height == pFrame->height && width == pFrame->width)

BlinkenFrame.c             548)     return;
BlinkenFrame.c             549) 
BlinkenFrame.c             550)   scaleHor = (double)width / (double)pFrame->width;
BlinkenFrame.c             551)   scaleVer = (double)height / (double)pFrame->height;
BlinkenFrame.c             552) 

BlinkenLib/BlinkenFrame.c  553)   // allocate new data array
BlinkenLib/BlinkenFrame.c  554)   ppData =

BlinkenLib/BlinkenFrame.c  555)       (unsigned char **)BlinkenMalloc2D(height, width * pFrame->channels,
BlinkenLib/BlinkenFrame.c  556)                                         sizeof(unsigned char));

BlinkenLib/BlinkenFrame.c  557)   if (ppData == NULL)

BlinkenFrame.c             558)     return;
BlinkenFrame.c             559) 

BlinkenLib/BlinkenFrame.c  560)   // scale every channel

BlinkenFrame.c             561)   chans = pFrame->channels;

BlinkenLib/BlinkenFrame.c  562)   for (c = 0; c < chans; c++) {
BlinkenLib/BlinkenFrame.c  563)     for (ny = 0; ny < height; ny++) {
BlinkenLib/BlinkenFrame.c  564)       for (nx = 0; nx < width; nx++) {
BlinkenLib/BlinkenFrame.c  565)         oy = (double)ny / scaleVer;     // sub-pixel exact range in old
BlinkenLib/BlinkenFrame.c  566)         // picture

BlinkenFrame.c             567)         ox = (double)nx / scaleHor;
BlinkenFrame.c             568)         oy1 = (double)(ny + 1) / scaleVer - 0.000001;
BlinkenFrame.c             569)         ox1 = (double)(nx + 1) / scaleHor - 0.000001;

BlinkenLib/BlinkenFrame.c  570)         if (oy < 0 || ox < 0 || oy1 >= pFrame->height || ox1 >= pFrame->width)
BlinkenLib/BlinkenFrame.c  571)           // out of old picture

BlinkenFrame.c             572)           ppData[ny][nx * chans + c] = 0;

BlinkenLib/BlinkenFrame.c  573)         else {

BlinkenFrame.c             574)           oyi = (int)oy;
BlinkenFrame.c             575)           oxi = (int)ox;
BlinkenFrame.c             576)           oy1i = (int)oy1;
BlinkenFrame.c             577)           ox1i = (int)ox1;

BlinkenLib/BlinkenFrame.c  578)           if (oyi == oy1i) {
BlinkenLib/BlinkenFrame.c  579)             if (oxi == ox1i)    // one source pixel

BlinkenFrame.c             580)             {

BlinkenFrame.c             581)               val = (double)pFrame->ppData[oyi][oxi * chans + c];

BlinkenLib/BlinkenFrame.c  582)             } else      // one line of source pixels

BlinkenFrame.c             583)             {

BlinkenLib/BlinkenFrame.c  584)               val =
BlinkenLib/BlinkenFrame.c  585)                   (double)pFrame->ppData[oyi][oxi * chans + c] * (1 - ox +
BlinkenLib/BlinkenFrame.c  586)                                                                   oxi)
BlinkenLib/BlinkenFrame.c  587)                   + (double)pFrame->ppData[oyi][ox1i * chans + c] * (ox1 -
BlinkenLib/BlinkenFrame.c  588)                                                                      ox1i);
BlinkenLib/BlinkenFrame.c  589)               for (x = oxi + 1; x < ox1i; x++)

BlinkenFrame.c             590)                 val += (double)pFrame->ppData[oyi][x * chans + c];

BlinkenFrame.c             591)               val /= ox1 - ox;
BlinkenFrame.c             592)             }

BlinkenLib/BlinkenFrame.c  593)           } else        // one column of source pixels

BlinkenFrame.c             594)           {

BlinkenLib/BlinkenFrame.c  595)             if (oxi == ox1i) {
BlinkenLib/BlinkenFrame.c  596)               val =
BlinkenLib/BlinkenFrame.c  597)                   (double)pFrame->ppData[oyi][oxi * chans + c] * (1 - oy +
BlinkenLib/BlinkenFrame.c  598)                                                                   oyi)
BlinkenLib/BlinkenFrame.c  599)                   + (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 -
BlinkenLib/BlinkenFrame.c  600)                                                                      oy1i);
BlinkenLib/BlinkenFrame.c  601)               for (y = oyi + 1; y < oy1i; y++)

BlinkenFrame.c             602)                 val += (double)pFrame->ppData[y][oxi * chans + c];

BlinkenFrame.c             603)               val /= oy1 - oy;

BlinkenLib/BlinkenFrame.c  604)             } else      // rectangle of source pixels

BlinkenFrame.c             605)             {

BlinkenLib/BlinkenFrame.c  606)               val =
BlinkenLib/BlinkenFrame.c  607)                   (double)pFrame->ppData[oyi][oxi * chans + c] * (1 - oy +
BlinkenLib/BlinkenFrame.c  608)                                                                   oyi) * (1 -
BlinkenLib/BlinkenFrame.c  609)                                                                           ox +
BlinkenLib/BlinkenFrame.c  610)                                                                           oxi)
BlinkenLib/BlinkenFrame.c  611)                   + (double)pFrame->ppData[oyi][ox1i * chans + c] * (1 - oy +
BlinkenLib/BlinkenFrame.c  612)                                                                      oyi) *
BlinkenLib/BlinkenFrame.c  613)                   (ox1 - ox1i)
BlinkenLib/BlinkenFrame.c  614)                   + (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 -
BlinkenLib/BlinkenFrame.c  615)                                                                      oy1i) *
BlinkenLib/BlinkenFrame.c  616)                   (1 - ox + oxi)
BlinkenLib/BlinkenFrame.c  617)                   + (double)pFrame->ppData[oy1i][ox1i * chans + c] * (oy1 -
BlinkenLib/BlinkenFrame.c  618)                                                                       oy1i) *
BlinkenLib/BlinkenFrame.c  619)                   (ox1 - ox1i);
BlinkenLib/BlinkenFrame.c  620)               for (y = oyi + 1; y < oy1i; y++) {
BlinkenLib/BlinkenFrame.c  621)                 val +=
BlinkenLib/BlinkenFrame.c  622)                     (double)pFrame->ppData[y][oxi * chans + c] * (1 - ox +
BlinkenLib/BlinkenFrame.c  623)                                                                   oxi)
BlinkenLib/BlinkenFrame.c  624)                     + (double)pFrame->ppData[y][ox1i * chans + c] * (ox1 -
BlinkenLib/BlinkenFrame.c  625)                                                                      ox1i);

BlinkenFrame.c             626)               }

BlinkenLib/BlinkenFrame.c  627)               for (x = oxi + 1; x < ox1i; x++) {
BlinkenLib/BlinkenFrame.c  628)                 val +=
BlinkenLib/BlinkenFrame.c  629)                     (double)pFrame->ppData[oyi][x * chans + c] * (1 - oy +
BlinkenLib/BlinkenFrame.c  630)                                                                   oyi)
BlinkenLib/BlinkenFrame.c  631)                     + (double)pFrame->ppData[oy1i][x * chans + c] * (oy1 -
BlinkenLib/BlinkenFrame.c  632)                                                                      oy1i);

BlinkenFrame.c             633)               }

BlinkenLib/BlinkenFrame.c  634)               for (y = oyi + 1; y < oy1i; y++)
BlinkenLib/BlinkenFrame.c  635)                 for (x = oxi + 1; x < ox1i; x++)

BlinkenFrame.c             636)                   val += (double)pFrame->ppData[y][x * chans + c];

BlinkenFrame.c             637)               val /= (oy1 - oy) * (ox1 - ox);
BlinkenFrame.c             638)             }
BlinkenFrame.c             639)           }

BlinkenFrame.c             640)           ppData[ny][nx * chans + c] = (unsigned char)(val + 0.5);

BlinkenFrame.c             641)         }

BlinkenLib/BlinkenFrame.c  642)       } // for( nx ...
BlinkenLib/BlinkenFrame.c  643)     }   // for( ny ...
BlinkenLib/BlinkenFrame.c  644)   }     // for( c ...

BlinkenFrame.c             645) 
BlinkenFrame.c             646)   pFrame->height = height;
BlinkenFrame.c             647)   pFrame->width = width;

BlinkenLib/BlinkenFrame.c  648)   free(pFrame->ppData);

BlinkenFrame.c             649)   pFrame->ppData = ppData;

BlinkenFrame.c             650) }
BlinkenFrame.c             651) 

BlinkenLib/BlinkenFrame.c  652) void BlinkenFrameColorize(stBlinkenFrame *pFrame, int channels, int mode,

BlinkenLib/BlinkenFrame.c  653)                           int step)

BlinkenFrame.c             654) {

BlinkenLib/BlinkenFrame.c  655)   unsigned char **ppData;

BlinkenFrame.c             656)   int y, x, c, i, j;
BlinkenFrame.c             657)   unsigned int val;
BlinkenFrame.c             658) 

BlinkenLib/BlinkenFrame.c  659)   if (pFrame == NULL)

BlinkenFrame.c             660)     return;
BlinkenFrame.c             661) 

BlinkenLib/BlinkenFrame.c  662)   if (channels < BlinkenChannelsMin)
BlinkenLib/BlinkenFrame.c  663)     channels = BlinkenChannelsMin;
BlinkenLib/BlinkenFrame.c  664)   if (channels > BlinkenChannelsMax)
BlinkenLib/BlinkenFrame.c  665)     channels = BlinkenMaxvalMax;

BlinkenFrame.c             666) 

BlinkenLib/BlinkenFrame.c  667)   // allocate new data array
BlinkenLib/BlinkenFrame.c  668)   ppData =

BlinkenLib/BlinkenFrame.c  669)       (unsigned char **)BlinkenMalloc2D(pFrame->height,
BlinkenLib/BlinkenFrame.c  670)                                         pFrame->width * channels,
BlinkenLib/BlinkenFrame.c  671)                                         sizeof(unsigned char));

BlinkenLib/BlinkenFrame.c  672)   if (ppData == NULL)

BlinkenFrame.c             673)     return;

BlinkenLib/BlinkenFrame.c  674)   for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c  675)     for (x = 0, i = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c  676)       for (c = 0; c < channels; c++, i++)

BlinkenFrame.c             677)         ppData[y][i] = 0;
BlinkenFrame.c             678) 

BlinkenLib/BlinkenFrame.c  679)   // colorize frame
BlinkenLib/BlinkenFrame.c  680)   for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c  681)     for (x = 0; x < pFrame->width; x++) {

BlinkenFrame.c             682)       i = x * pFrame->channels;

BlinkenLib/BlinkenFrame.c  683)       // merge channels

BlinkenFrame.c             684)       val = 0;

BlinkenLib/BlinkenFrame.c  685)       for (c = 0; c < pFrame->channels; c++, i++)

BlinkenFrame.c             686)         val += pFrame->ppData[y][i];
BlinkenFrame.c             687)       val = (val + pFrame->channels / 2) / pFrame->channels;
BlinkenFrame.c             688)       val = (val * BlinkenMaxvalMax + pFrame->maxval / 2) / pFrame->maxval;

BlinkenLib/BlinkenFrame.c  689)       // colorize

BlinkenFrame.c             690)       j = x * channels;

BlinkenLib/BlinkenFrame.c  691)       for (c = 0; c < channels; c++, j++) {
BlinkenLib/BlinkenFrame.c  692)         int color = BlinkenColorizerGetColor(channels, mode, step, y, x, c);

BlinkenFrame.c             693)         ppData[y][j] = (unsigned char)((val * color + 127) / 255);
BlinkenFrame.c             694)       }
BlinkenFrame.c             695)     }
BlinkenFrame.c             696)   }
BlinkenFrame.c             697) 
BlinkenFrame.c             698)   pFrame->channels = channels;
BlinkenFrame.c             699)   pFrame->maxval = BlinkenMaxvalMax;

BlinkenLib/BlinkenFrame.c  700)   free(pFrame->ppData);

BlinkenFrame.c             701)   pFrame->ppData = ppData;
BlinkenFrame.c             702) }
BlinkenFrame.c             703) 

BlinkenLib/BlinkenFrame.c  704) void BlinkenFrameCopyRect(stBlinkenFrame *pDest, int destY, int destX,
BlinkenLib/BlinkenFrame.c  705)                           stBlinkenFrame *pSrc, int srcY, int srcX,
BlinkenLib/BlinkenFrame.c  706)                           int height, int width)
BlinkenLib/BlinkenFrame.c  707) {
BlinkenLib/BlinkenFrame.c  708)   int bFreeSrc = 0;
BlinkenLib/BlinkenFrame.c  709)   int destI, srcI, y, x, c, dy, sy, di, si;
BlinkenLib/BlinkenFrame.c  710) 
BlinkenLib/BlinkenFrame.c  711)   if (pDest == NULL || pSrc == NULL)
BlinkenLib/BlinkenFrame.c  712)     return;
BlinkenLib/BlinkenFrame.c  713) 
BlinkenLib/BlinkenFrame.c  714)   // make sure source frame matches dest frame in channels and maxval
BlinkenLib/BlinkenFrame.c  715)   if (pSrc->channels != pDest->channels || pSrc->maxval != pDest->maxval) {
BlinkenLib/BlinkenFrame.c  716)     pSrc = BlinkenFrameClone(pSrc);
BlinkenLib/BlinkenFrame.c  717)     if (pSrc == NULL)
BlinkenLib/BlinkenFrame.c  718)       return;
BlinkenLib/BlinkenFrame.c  719)     BlinkenFrameResize(pSrc, pSrc->height, pSrc->width,
BlinkenLib/BlinkenFrame.c  720)                        pDest->channels, pDest->maxval);
BlinkenLib/BlinkenFrame.c  721)     bFreeSrc = 1; // source is now a temporary copy that needs to be freed
BlinkenLib/BlinkenFrame.c  722)   }
BlinkenLib/BlinkenFrame.c  723) 
BlinkenLib/BlinkenFrame.c  724)   // correct coordinates
BlinkenLib/BlinkenFrame.c  725)   if (destY < 0) {
BlinkenLib/BlinkenFrame.c  726)     height += destY;
BlinkenLib/BlinkenFrame.c  727)     srcY -= destY;
BlinkenLib/BlinkenFrame.c  728)     destY = 0;
BlinkenLib/BlinkenFrame.c  729)   }
BlinkenLib/BlinkenFrame.c  730)   if (destX < 0) {
BlinkenLib/BlinkenFrame.c  731)     width += destX;
BlinkenLib/BlinkenFrame.c  732)     srcX -= destX;
BlinkenLib/BlinkenFrame.c  733)     destX = 0;
BlinkenLib/BlinkenFrame.c  734)   }
BlinkenLib/BlinkenFrame.c  735)   if (srcY < 0) {
BlinkenLib/BlinkenFrame.c  736)     height += srcY;
BlinkenLib/BlinkenFrame.c  737)     destY -= srcY;
BlinkenLib/BlinkenFrame.c  738)     srcY = 0;
BlinkenLib/BlinkenFrame.c  739)   }
BlinkenLib/BlinkenFrame.c  740)   if (srcX < 0) {
BlinkenLib/BlinkenFrame.c  741)     width += srcX;
BlinkenLib/BlinkenFrame.c  742)     destX -= srcX;
BlinkenLib/BlinkenFrame.c  743)     srcX = 0;
BlinkenLib/BlinkenFrame.c  744)   }
BlinkenLib/BlinkenFrame.c  745)   if (height > pDest->height - destY)
BlinkenLib/BlinkenFrame.c  746)     height = pDest->height - destY;
BlinkenLib/BlinkenFrame.c  747)   if (width > pDest->width - destX)
BlinkenLib/BlinkenFrame.c  748)     width = pDest->width - destX;
BlinkenLib/BlinkenFrame.c  749)   if (height > pSrc->height - srcY)
BlinkenLib/BlinkenFrame.c  750)     height = pSrc->height - srcY;
BlinkenLib/BlinkenFrame.c  751)   if (width > pSrc->width - srcX)
BlinkenLib/BlinkenFrame.c  752)     width = pSrc->width - srcX;
BlinkenLib/BlinkenFrame.c  753)   if (height < 0)
BlinkenLib/BlinkenFrame.c  754)     height = 0;
BlinkenLib/BlinkenFrame.c  755)   if (width < 0)
BlinkenLib/BlinkenFrame.c  756)     width = 0;
BlinkenLib/BlinkenFrame.c  757) 
BlinkenLib/BlinkenFrame.c  758)   // copy rectangular area
BlinkenLib/BlinkenFrame.c  759)   destI = destX * pDest->channels;
BlinkenLib/BlinkenFrame.c  760)   srcI = srcX * pSrc->channels;
BlinkenLib/BlinkenFrame.c  761)   for (y = 0, dy = destY, sy = srcY; y < height; y++, dy++, sy++)
BlinkenLib/BlinkenFrame.c  762)     for (x = 0, di = destI, si = srcI; x < width; x++)
BlinkenLib/BlinkenFrame.c  763)       for (c = 0; c < pDest->channels; c++, di++, si++)
BlinkenLib/BlinkenFrame.c  764)         pDest->ppData[dy][di] = pSrc->ppData[sy][si];
BlinkenLib/BlinkenFrame.c  765) 
BlinkenLib/BlinkenFrame.c  766)   // free source if it is a temporary copy
BlinkenLib/BlinkenFrame.c  767)   if (bFreeSrc)
BlinkenLib/BlinkenFrame.c  768)     BlinkenFrameFree(pSrc);
BlinkenLib/BlinkenFrame.c  769) }
BlinkenLib/BlinkenFrame.c  770) 

BlinkenLib/BlinkenFrame.c  771) void BlinkenFrameRotateCw(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  772) {
BlinkenLib/BlinkenFrame.c  773)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c  774)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c  775) 
BlinkenLib/BlinkenFrame.c  776)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  777)     return;
BlinkenLib/BlinkenFrame.c  778) 
BlinkenLib/BlinkenFrame.c  779)   // allocate new data array
BlinkenLib/BlinkenFrame.c  780)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c  781)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c  782)   channels = pFrame->channels;
BlinkenLib/BlinkenFrame.c  783)   ppData =
BlinkenLib/BlinkenFrame.c  784)       (unsigned char **)BlinkenMalloc2D(height, width * channels,
BlinkenLib/BlinkenFrame.c  785)                                         sizeof(unsigned char));
BlinkenLib/BlinkenFrame.c  786)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c  787)     return;
BlinkenLib/BlinkenFrame.c  788) 
BlinkenLib/BlinkenFrame.c  789)   // rotate
BlinkenLib/BlinkenFrame.c  790)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c  791)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c  792)       j = y * channels;
BlinkenLib/BlinkenFrame.c  793)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  794)         ppData[y][i] = pFrame->ppData[width - 1 - x][j];
BlinkenLib/BlinkenFrame.c  795)     }
BlinkenLib/BlinkenFrame.c  796)   }
BlinkenLib/BlinkenFrame.c  797) 
BlinkenLib/BlinkenFrame.c  798)   // use new data array
BlinkenLib/BlinkenFrame.c  799)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c  800)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c  801)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c  802)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c  803) }
BlinkenLib/BlinkenFrame.c  804) 
BlinkenLib/BlinkenFrame.c  805) void BlinkenFrameRotateCcw(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  806) {
BlinkenLib/BlinkenFrame.c  807)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c  808)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c  809) 
BlinkenLib/BlinkenFrame.c  810)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  811)     return;
BlinkenLib/BlinkenFrame.c  812) 
BlinkenLib/BlinkenFrame.c  813)   // allocate new data array
BlinkenLib/BlinkenFrame.c  814)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c  815)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c  816)   channels = pFrame->channels;
BlinkenLib/BlinkenFrame.c  817)   ppData =
BlinkenLib/BlinkenFrame.c  818)       (unsigned char **)BlinkenMalloc2D(height, width * channels,
BlinkenLib/BlinkenFrame.c  819)                                         sizeof(unsigned char));
BlinkenLib/BlinkenFrame.c  820)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c  821)     return;
BlinkenLib/BlinkenFrame.c  822) 
BlinkenLib/BlinkenFrame.c  823)   // rotate
BlinkenLib/BlinkenFrame.c  824)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c  825)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c  826)       j = (height - 1 - y) * channels;
BlinkenLib/BlinkenFrame.c  827)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  828)         ppData[y][i] = pFrame->ppData[x][j];
BlinkenLib/BlinkenFrame.c  829)     }
BlinkenLib/BlinkenFrame.c  830)   }
BlinkenLib/BlinkenFrame.c  831) 
BlinkenLib/BlinkenFrame.c  832)   // use new data array
BlinkenLib/BlinkenFrame.c  833)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c  834)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c  835)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c  836)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c  837) }
BlinkenLib/BlinkenFrame.c  838) 
BlinkenLib/BlinkenFrame.c  839) void BlinkenFrameRotateHalf(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  840) {
BlinkenLib/BlinkenFrame.c  841)   int y1, y2, x1, x2, c, i1, i2;
BlinkenLib/BlinkenFrame.c  842) 
BlinkenLib/BlinkenFrame.c  843)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  844)     return;
BlinkenLib/BlinkenFrame.c  845) 
BlinkenLib/BlinkenFrame.c  846)   for (y1 = 0, y2 = pFrame->height - 1 ; y1 < pFrame->height; y1++, y2--) {
BlinkenLib/BlinkenFrame.c  847)     for (x1 = 0, x2 = pFrame->width - 1,
BlinkenLib/BlinkenFrame.c  848)          i1 = 0, i2 = (pFrame->width - 1) * pFrame->channels;
BlinkenLib/BlinkenFrame.c  849)          x1 < pFrame->width / 2; x1++, x2--, i2 -= 2 * pFrame->channels) {
BlinkenLib/BlinkenFrame.c  850)       for (c = 0; c < pFrame->channels; c++, i1++, i2++) {
BlinkenLib/BlinkenFrame.c  851)         unsigned char tmp = pFrame->ppData[y1][i1];
BlinkenLib/BlinkenFrame.c  852)         pFrame->ppData[y1][i1] = pFrame->ppData[y2][i2];
BlinkenLib/BlinkenFrame.c  853)         pFrame->ppData[y2][i2] = tmp;
BlinkenLib/BlinkenFrame.c  854)       }
BlinkenLib/BlinkenFrame.c  855)     }
BlinkenLib/BlinkenFrame.c  856)   }
BlinkenLib/BlinkenFrame.c  857) }
BlinkenLib/BlinkenFrame.c  858) 
BlinkenLib/BlinkenFrame.c  859) void BlinkenFrameMirrorHor(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  860) {
BlinkenLib/BlinkenFrame.c  861)   int y, x1, x2, c, i1, i2;
BlinkenLib/BlinkenFrame.c  862) 
BlinkenLib/BlinkenFrame.c  863)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  864)     return;
BlinkenLib/BlinkenFrame.c  865) 
BlinkenLib/BlinkenFrame.c  866)   for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c  867)     for (x1 = 0, x2 = pFrame->width - 1,
BlinkenLib/BlinkenFrame.c  868)          i1 = 0, i2 = (pFrame->width - 1) * pFrame->channels;
BlinkenLib/BlinkenFrame.c  869)          x1 < pFrame->width / 2; x1++, x2--, i2 -= 2 * pFrame->channels) {
BlinkenLib/BlinkenFrame.c  870)       for (c = 0; c < pFrame->channels; c++, i1++, i2++) {
BlinkenLib/BlinkenFrame.c  871)         unsigned char tmp = pFrame->ppData[y][i1];
BlinkenLib/BlinkenFrame.c  872)         pFrame->ppData[y][i1] = pFrame->ppData[y][i2];
BlinkenLib/BlinkenFrame.c  873)         pFrame->ppData[y][i2] = tmp;
BlinkenLib/BlinkenFrame.c  874)       }
BlinkenLib/BlinkenFrame.c  875)     }
BlinkenLib/BlinkenFrame.c  876)   }
BlinkenLib/BlinkenFrame.c  877) }
BlinkenLib/BlinkenFrame.c  878) 
BlinkenLib/BlinkenFrame.c  879) void BlinkenFrameMirrorVer(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  880) {
BlinkenLib/BlinkenFrame.c  881)   int y1, y2, x, c, i;
BlinkenLib/BlinkenFrame.c  882) 
BlinkenLib/BlinkenFrame.c  883)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  884)     return;
BlinkenLib/BlinkenFrame.c  885) 
BlinkenLib/BlinkenFrame.c  886)   for (y1 = 0, y2 = pFrame->height - 1; y1 < pFrame->height / 2; y1++, y2--) {
BlinkenLib/BlinkenFrame.c  887)     for (x = 0, i = 0; x < pFrame->width; x++) {
BlinkenLib/BlinkenFrame.c  888)       for (c = 0; c < pFrame->channels; c++, i++) {
BlinkenLib/BlinkenFrame.c  889)         unsigned char tmp = pFrame->ppData[y1][i];
BlinkenLib/BlinkenFrame.c  890)         pFrame->ppData[y1][i] = pFrame->ppData[y2][i];
BlinkenLib/BlinkenFrame.c  891)         pFrame->ppData[y2][i] = tmp;
BlinkenLib/BlinkenFrame.c  892)       }
BlinkenLib/BlinkenFrame.c  893)     }
BlinkenLib/BlinkenFrame.c  894)   }
BlinkenLib/BlinkenFrame.c  895) }
BlinkenLib/BlinkenFrame.c  896) 
BlinkenLib/BlinkenFrame.c  897) void BlinkenFrameMirrorDiag(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  898) {
BlinkenLib/BlinkenFrame.c  899)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c  900)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c  901) 
BlinkenLib/BlinkenFrame.c  902)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  903)     return;
BlinkenLib/BlinkenFrame.c  904) 
BlinkenLib/BlinkenFrame.c  905)   // allocate new data array
BlinkenLib/BlinkenFrame.c  906)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c  907)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c  908)   channels = pFrame->channels;
BlinkenLib/BlinkenFrame.c  909)   ppData =
BlinkenLib/BlinkenFrame.c  910)       (unsigned char **)BlinkenMalloc2D(height, width * channels,
BlinkenLib/BlinkenFrame.c  911)                                         sizeof(unsigned char));
BlinkenLib/BlinkenFrame.c  912)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c  913)     return;
BlinkenLib/BlinkenFrame.c  914) 
BlinkenLib/BlinkenFrame.c  915)   // mirror
BlinkenLib/BlinkenFrame.c  916)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c  917)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c  918)       j = y * channels;
BlinkenLib/BlinkenFrame.c  919)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  920)         ppData[y][i] = pFrame->ppData[x][j];
BlinkenLib/BlinkenFrame.c  921)     }
BlinkenLib/BlinkenFrame.c  922)   }
BlinkenLib/BlinkenFrame.c  923) 
BlinkenLib/BlinkenFrame.c  924)   // use new data array
BlinkenLib/BlinkenFrame.c  925)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c  926)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c  927)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c  928)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c  929) }
BlinkenLib/BlinkenFrame.c  930) 
BlinkenLib/BlinkenFrame.c  931) void BlinkenFrameMirrorDiag2(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  932) {
BlinkenLib/BlinkenFrame.c  933)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c  934)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c  935) 
BlinkenLib/BlinkenFrame.c  936)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  937)     return;
BlinkenLib/BlinkenFrame.c  938) 
BlinkenLib/BlinkenFrame.c  939)   // allocate new data array
BlinkenLib/BlinkenFrame.c  940)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c  941)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c  942)   channels = pFrame->channels;
BlinkenLib/BlinkenFrame.c  943)   ppData =
BlinkenLib/BlinkenFrame.c  944)       (unsigned char **)BlinkenMalloc2D(height, width * channels,
BlinkenLib/BlinkenFrame.c  945)                                         sizeof(unsigned char));
BlinkenLib/BlinkenFrame.c  946)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c  947)     return;
BlinkenLib/BlinkenFrame.c  948) 
BlinkenLib/BlinkenFrame.c  949)   // mirror
BlinkenLib/BlinkenFrame.c  950)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c  951)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c  952)       j = (height - 1 - y) * channels;
BlinkenLib/BlinkenFrame.c  953)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  954)         ppData[y][i] = pFrame->ppData[width - 1 - x][j];
BlinkenLib/BlinkenFrame.c  955)     }
BlinkenLib/BlinkenFrame.c  956)   }
BlinkenLib/BlinkenFrame.c  957) 
BlinkenLib/BlinkenFrame.c  958)   // use new data array
BlinkenLib/BlinkenFrame.c  959)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c  960)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c  961)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c  962)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c  963) }
BlinkenLib/BlinkenFrame.c  964) 

BlinkenLib/BlinkenFrame.c  965) char *BlinkenFrameToString(stBlinkenFrame *pFrame)

BlinkenFrame.c             966) {

BlinkenFrame.c             967)   int size, y, x, c, i;

BlinkenLib/BlinkenFrame.c  968)   char *str, *ptr;

BlinkenFrame.c             969)   unsigned long val;
BlinkenFrame.c             970) 

BlinkenLib/BlinkenFrame.c  971)   if (pFrame == NULL)

BlinkenFrame.c             972)     return NULL;
BlinkenFrame.c             973) 
BlinkenFrame.c             974)   size = pFrame->height * (pFrame->width + 1) + 32;
BlinkenFrame.c             975) 

BlinkenLib/BlinkenFrame.c  976)   str = (char *)malloc(size);
BlinkenLib/BlinkenFrame.c  977)   if (str == NULL)

BlinkenFrame.c             978)     return NULL;
BlinkenFrame.c             979) 
BlinkenFrame.c             980)   ptr = str;

BlinkenLib/BlinkenFrame.c  981) 
BlinkenLib/BlinkenFrame.c  982)   for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c  983)     for (x = 0, i = 0; x < pFrame->width; x++) {

BlinkenFrame.c             984)       val = 0;

BlinkenLib/BlinkenFrame.c  985)       for (val = 0, c = 0; c < pFrame->channels; c++, i++)

BlinkenFrame.c             986)         val += pFrame->ppData[y][i];

BlinkenFrame.c             987)       val = val * 7 / pFrame->maxval / pFrame->channels;
BlinkenFrame.c             988)       *ptr = " -+*%#&@"[val];
BlinkenFrame.c             989)       ptr++;
BlinkenFrame.c             990)     }
BlinkenFrame.c             991)     *ptr = '\n';
BlinkenFrame.c             992)     ptr++;
BlinkenFrame.c             993)   }
BlinkenFrame.c             994) 

BlinkenLib/BlinkenFrame.c  995)   sprintf(ptr, "%u ms\n", pFrame->duration);

BlinkenFrame.c             996) 
BlinkenFrame.c             997)   return str;
BlinkenFrame.c             998) }
BlinkenFrame.c             999) 

BlinkenLib/BlinkenFrame.c 1000) int BlinkenFrameToNetwork(stBlinkenFrame *pFrame, etBlinkenProto proto,

BlinkenLib/BlinkenFrame.c 1001)                           char *pData, int maxLength)
BlinkenLib/BlinkenFrame.c 1002) // returns length or -1 on error

BlinkenFrame.c            1003) {

BlinkenFrame.c            1004)   int y, x, c, i, j, val;

BlinkenFrame.c            1005) 

BlinkenLib/BlinkenFrame.c 1006)   if (pFrame == NULL)

BlinkenFrame.c            1007)     return -1;
BlinkenFrame.c            1008) 

BlinkenLib/BlinkenFrame.c 1009)   switch (proto) {

BlinkenFrame.c            1010) 

BlinkenLib/BlinkenFrame.c 1011)   case BlinkenProtoNone:
BlinkenLib/BlinkenFrame.c 1012)     return 0;
BlinkenLib/BlinkenFrame.c 1013) 
BlinkenLib/BlinkenFrame.c 1014)   case BlinkenProtoBlp:

BlinkenLib/BlinkenFrame.c 1015)     // buffer too short
BlinkenLib/BlinkenFrame.c 1016)     if (maxLength < (int)sizeof(stBlinkenProtoBlpHdr) + pFrame->height * pFrame->width)

BlinkenLib/BlinkenFrame.c 1017)       return -1;

BlinkenLib/BlinkenFrame.c 1018)     // build header
BlinkenLib/BlinkenFrame.c 1019)     ((stBlinkenProtoBlpHdr *) pData)->magic = htonl(BlinkenProtoBlpMagic);

BlinkenLib/BlinkenFrame.c 1020)     ((stBlinkenProtoBlpHdr *) pData)->frameNo = htonl(0);
BlinkenLib/BlinkenFrame.c 1021)     ((stBlinkenProtoBlpHdr *) pData)->width = htons((uint16_t) pFrame->width);
BlinkenLib/BlinkenFrame.c 1022)     ((stBlinkenProtoBlpHdr *) pData)->height =
BlinkenLib/BlinkenFrame.c 1023)         htons((uint16_t) pFrame->height);
BlinkenLib/BlinkenFrame.c 1024)     i = sizeof(stBlinkenProtoBlpHdr);   // put data into packet
BlinkenLib/BlinkenFrame.c 1025)     for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c 1026)       for (x = 0, j = 0; x < pFrame->width; x++, i++) {
BlinkenLib/BlinkenFrame.c 1027)         val = 0;
BlinkenLib/BlinkenFrame.c 1028)         for (c = 0; c < pFrame->channels; c++, j++)
BlinkenLib/BlinkenFrame.c 1029)           val += pFrame->ppData[y][j];
BlinkenLib/BlinkenFrame.c 1030)         pData[i] =

BlinkenLib/BlinkenFrame.c 1031)             (val >= pFrame->channels * (pFrame->maxval + 1) / 2 ? 0x01 : 0x00);

BlinkenFrame.c            1032)       }

BlinkenLib/BlinkenFrame.c 1033)     }
BlinkenLib/BlinkenFrame.c 1034)     return i;   // return length
BlinkenLib/BlinkenFrame.c 1035) 
BlinkenLib/BlinkenFrame.c 1036)   case BlinkenProtoEblp:

BlinkenLib/BlinkenFrame.c 1037)     // buffer too short
BlinkenLib/BlinkenFrame.c 1038)     if (maxLength < (int)sizeof(stBlinkenProtoEblpHdr) + pFrame->height * pFrame->width)

BlinkenLib/BlinkenFrame.c 1039)       return -1;

BlinkenLib/BlinkenFrame.c 1040)     // build header
BlinkenLib/BlinkenFrame.c 1041)     ((stBlinkenProtoEblpHdr *) pData)->magic = htonl(BlinkenProtoEblpMagic);

BlinkenLib/BlinkenFrame.c 1042)     ((stBlinkenProtoEblpHdr *) pData)->frameNo = htonl(0);
BlinkenLib/BlinkenFrame.c 1043)     ((stBlinkenProtoEblpHdr *) pData)->width =
BlinkenLib/BlinkenFrame.c 1044)         htons((uint16_t) pFrame->width);
BlinkenLib/BlinkenFrame.c 1045)     ((stBlinkenProtoEblpHdr *) pData)->height =
BlinkenLib/BlinkenFrame.c 1046)         htons((uint16_t) pFrame->height);
BlinkenLib/BlinkenFrame.c 1047)     i = sizeof(stBlinkenProtoEblpHdr);  // put data into packet
BlinkenLib/BlinkenFrame.c 1048)     for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c 1049)       for (x = 0, j = 0; x < pFrame->width; x++, i++) {
BlinkenLib/BlinkenFrame.c 1050)         val = 0;
BlinkenLib/BlinkenFrame.c 1051)         for (c = 0; c < pFrame->channels; c++, j++)
BlinkenLib/BlinkenFrame.c 1052)           val += pFrame->ppData[y][j];
BlinkenLib/BlinkenFrame.c 1053)         val /= pFrame->channels;
BlinkenLib/BlinkenFrame.c 1054)         pData[i] = (pFrame->maxval == 255 ? (unsigned char)val
BlinkenLib/BlinkenFrame.c 1055)                     : (unsigned char)((val * 255 + pFrame->maxval / 2) /
BlinkenLib/BlinkenFrame.c 1056)                                       pFrame->maxval));

BlinkenFrame.c            1057)       }

BlinkenLib/BlinkenFrame.c 1058)     }
BlinkenLib/BlinkenFrame.c 1059)     return i;   // return length
BlinkenLib/BlinkenFrame.c 1060) 
BlinkenLib/BlinkenFrame.c 1061)   case BlinkenProtoMcuf:

BlinkenLib/BlinkenFrame.c 1062)     // buffer too short
BlinkenLib/BlinkenFrame.c 1063)     if (maxLength < (int)sizeof(stBlinkenProtoMcufHdr) + pFrame->height * pFrame->width * pFrame->channels)

BlinkenFrame.c            1064)       return -1;

BlinkenLib/BlinkenFrame.c 1065)     // build header
BlinkenLib/BlinkenFrame.c 1066)     ((stBlinkenProtoMcufHdr *) pData)->magic = htonl(BlinkenProtoMcufMagic);

BlinkenLib/BlinkenFrame.c 1067)     ((stBlinkenProtoMcufHdr *) pData)->height =
BlinkenLib/BlinkenFrame.c 1068)         htons((uint16_t) pFrame->height);
BlinkenLib/BlinkenFrame.c 1069)     ((stBlinkenProtoMcufHdr *) pData)->width =
BlinkenLib/BlinkenFrame.c 1070)         htons((uint16_t) pFrame->width);
BlinkenLib/BlinkenFrame.c 1071)     ((stBlinkenProtoMcufHdr *) pData)->channels =
BlinkenLib/BlinkenFrame.c 1072)         htons((uint16_t) pFrame->channels);
BlinkenLib/BlinkenFrame.c 1073)     ((stBlinkenProtoMcufHdr *) pData)->maxval =
BlinkenLib/BlinkenFrame.c 1074)         htons((uint16_t) pFrame->maxval);
BlinkenLib/BlinkenFrame.c 1075)     i = sizeof(stBlinkenProtoMcufHdr);  // put data into packet
BlinkenLib/BlinkenFrame.c 1076)     for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c 1077)       for (x = 0, j = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c 1078)         for (c = 0; c < pFrame->channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c 1079)           pData[i] = pFrame->ppData[y][j];
BlinkenLib/BlinkenFrame.c 1080)     return i;   // return length
BlinkenLib/BlinkenFrame.c 1081) 
BlinkenLib/BlinkenFrame.c 1082)   default:
BlinkenLib/BlinkenFrame.c 1083)     return -1;

BlinkenFrame.c            1084) 
BlinkenFrame.c            1085)   }
BlinkenFrame.c            1086) }
BlinkenFrame.c            1087) 

BlinkenLib/BlinkenFrame.c 1088) stBlinkenFrame *BlinkenFrameFromNetwork(const char *pData, int length,

BlinkenLib/BlinkenFrame.c 1089)                                         etBlinkenProto * pProto)
BlinkenLib/BlinkenFrame.c 1090) // returns protocol in *pProto if pProto not NULL

BlinkenFrame.c            1091) {

BlinkenLib/BlinkenFrame.c 1092)   stBlinkenFrame *pFrame;

BlinkenFrame.c            1093)   int height, width, channels, maxval, y, x, c, i, j;

BlinkenFrame.c            1094) 

BlinkenLib/BlinkenFrame.c 1095)   if (length >= (int)sizeof(stBlinkenProtoBlpHdr) &&
BlinkenLib/BlinkenFrame.c 1096)       ((stBlinkenProtoBlpHdr *) pData)->magic == htonl(BlinkenProtoBlpMagic))

BlinkenFrame.c            1097)   {

BlinkenLib/BlinkenFrame.c 1098)     if (pProto != NULL) // return protocol

BlinkenFrame.c            1099)       *pProto = BlinkenProtoBlp;

BlinkenLib/BlinkenFrame.c 1100)     // get header data
BlinkenLib/BlinkenFrame.c 1101)     height = ntohs(((stBlinkenProtoBlpHdr *) pData)->height);

BlinkenLib/BlinkenFrame.c 1102)     width = ntohs(((stBlinkenProtoBlpHdr *) pData)->width);

BlinkenLib/BlinkenFrame.c 1103)     // check length of packet
BlinkenLib/BlinkenFrame.c 1104)     if (length < (int)sizeof(stBlinkenProtoBlpHdr) + height * width)

BlinkenFrame.c            1105)       return NULL;

BlinkenLib/BlinkenFrame.c 1106)     // check header data
BlinkenLib/BlinkenFrame.c 1107)     if (height < BlinkenHeightMin || height > BlinkenHeightMax ||

BlinkenLib/BlinkenFrame.c 1108)         width < BlinkenWidthMin || width > BlinkenWidthMax)

BlinkenFrame.c            1109)       return NULL;

BlinkenLib/BlinkenFrame.c 1110)     pFrame = BlinkenFrameNew(height, width, 1, 1, 0);   // create frame
BlinkenLib/BlinkenFrame.c 1111)     // according to
BlinkenLib/BlinkenFrame.c 1112)     // header data
BlinkenLib/BlinkenFrame.c 1113)     if (pFrame == NULL)

BlinkenFrame.c            1114)       return NULL;

BlinkenLib/BlinkenFrame.c 1115)     i = sizeof(stBlinkenProtoBlpHdr);   // put data into frame
BlinkenLib/BlinkenFrame.c 1116)     for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c 1117)       for (x = 0; x < pFrame->width; x++, i++)

BlinkenFrame.c            1118)         pFrame->ppData[y][x] = pData[i] ? 0x01 : 0x00;

BlinkenFrame.c            1119)     return pFrame;
BlinkenFrame.c            1120)   }
BlinkenFrame.c            1121) 

BlinkenLib/BlinkenFrame.c 1122)   if (length >= (int)sizeof(stBlinkenProtoEblpHdr) &&
BlinkenLib/BlinkenFrame.c 1123)       ((stBlinkenProtoEblpHdr *) pData)->magic ==
BlinkenLib/BlinkenFrame.c 1124)       htonl(BlinkenProtoEblpMagic)) {
BlinkenLib/BlinkenFrame.c 1125)     if (pProto != NULL) // return protocol

BlinkenFrame.c            1126)       *pProto = BlinkenProtoEblp;

BlinkenLib/BlinkenFrame.c 1127)     // get header data
BlinkenLib/BlinkenFrame.c 1128)     height = ntohs(((stBlinkenProtoEblpHdr *) pData)->height);

BlinkenLib/BlinkenFrame.c 1129)     width = ntohs(((stBlinkenProtoEblpHdr *) pData)->width);

BlinkenLib/BlinkenFrame.c 1130)     // check length of packet
BlinkenLib/BlinkenFrame.c 1131)     if (length < (int)sizeof(stBlinkenProtoEblpHdr) + width * height)

BlinkenFrame.c            1132)       return NULL;

BlinkenLib/BlinkenFrame.c 1133)     // check header data
BlinkenLib/BlinkenFrame.c 1134)     if (height < BlinkenHeightMin || height > BlinkenHeightMax ||

BlinkenLib/BlinkenFrame.c 1135)         width < BlinkenWidthMin || width > BlinkenWidthMax)

BlinkenFrame.c            1136)       return NULL;

BlinkenLib/BlinkenFrame.c 1137)     pFrame = BlinkenFrameNew(height, width, 1, 255, 0); // create frame
BlinkenLib/BlinkenFrame.c 1138)     // according to
BlinkenLib/BlinkenFrame.c 1139)     // header data
BlinkenLib/BlinkenFrame.c 1140)     if (pFrame == NULL)

BlinkenFrame.c            1141)       return NULL;

BlinkenLib/BlinkenFrame.c 1142)     i = sizeof(stBlinkenProtoEblpHdr);  // put data into frame
BlinkenLib/BlinkenFrame.c 1143)     for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c 1144)       for (x = 0; x < pFrame->width; x++, i++)

BlinkenFrame.c            1145)         pFrame->ppData[y][x] = pData[i];

BlinkenFrame.c            1146)     return pFrame;
BlinkenFrame.c            1147)   }
BlinkenFrame.c            1148) 

BlinkenLib/BlinkenFrame.c 1149)   if (length >= (int)sizeof(stBlinkenProtoMcufHdr) &&
BlinkenLib/BlinkenFrame.c 1150)       ((stBlinkenProtoMcufHdr *) pData)->magic ==
BlinkenLib/BlinkenFrame.c 1151)       htonl(BlinkenProtoMcufMagic)) {
BlinkenLib/BlinkenFrame.c 1152)     if (pProto != NULL) // return protocol

BlinkenFrame.c            1153)       *pProto = BlinkenProtoMcuf;

BlinkenLib/BlinkenFrame.c 1154)     // get header data
BlinkenLib/BlinkenFrame.c 1155)     height = ntohs(((stBlinkenProtoMcufHdr *) pData)->height);

BlinkenLib/BlinkenFrame.c 1156)     width = ntohs(((stBlinkenProtoMcufHdr *) pData)->width);
BlinkenLib/BlinkenFrame.c 1157)     channels = ntohs(((stBlinkenProtoMcufHdr *) pData)->channels);
BlinkenLib/BlinkenFrame.c 1158)     maxval = ntohs(((stBlinkenProtoMcufHdr *) pData)->maxval);

BlinkenLib/BlinkenFrame.c 1159)     // check length of packet
BlinkenLib/BlinkenFrame.c 1160)     if (length < (int)sizeof(stBlinkenProtoMcufHdr) + height * width * channels)

BlinkenFrame.c            1161)       return NULL;

BlinkenLib/BlinkenFrame.c 1162)     // check header data
BlinkenLib/BlinkenFrame.c 1163)     if (height < BlinkenHeightMin || height > BlinkenHeightMax ||

BlinkenFrame.c            1164)         width < BlinkenWidthMin || width > BlinkenWidthMax ||
BlinkenFrame.c            1165)         channels < BlinkenChannelsMin || channels > BlinkenChannelsMax ||

BlinkenLib/BlinkenFrame.c 1166)         maxval < BlinkenMaxvalMin || maxval > BlinkenMaxvalMax)

BlinkenFrame.c            1167)       return NULL;

BlinkenLib/BlinkenFrame.c 1168)     // create frame according to header data
BlinkenLib/BlinkenFrame.c 1169)     pFrame = BlinkenFrameNew(height, width, channels, maxval, 0);

BlinkenLib/BlinkenFrame.c 1170)     if (pFrame == NULL)

BlinkenFrame.c            1171)       return NULL;

BlinkenLib/BlinkenFrame.c 1172)     i = sizeof(stBlinkenProtoMcufHdr);  // put data into frame
BlinkenLib/BlinkenFrame.c 1173)     for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c 1174)       for (x = 0, j = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c 1175)         for (c = 0; c < pFrame->channels; c++, i++, j++)

BlinkenFrame.c            1176)           pFrame->ppData[y][j] = pData[i];

BlinkenFrame.c            1177)     return pFrame;
BlinkenFrame.c            1178)   }
BlinkenFrame.c            1179) 

BlinkenLib/BlinkenFrame.c 1180)   if (pProto != NULL)   // return protocol