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 <windows.h>

src/BlinkenFrame.c          11) #include <winsock2.h>

BlinkenFrame.c              12) typedef WORD uint16_t;
BlinkenFrame.c              13) typedef DWORD uint32_t;
BlinkenFrame.c              14) #else

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

src/BlinkenFrame.c          16) #include <stdint.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) 

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

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

src/BlinkenFrame.c          60)   pFrame = (stBlinkenFrame *)malloc(sizeof(stBlinkenFrame));

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

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

src/BlinkenFrame.c          70)   pFrame->ppData = (unsigned char **)BlinkenMalloc2D(height, width * channels,
src/BlinkenFrame.c          71)                                                      sizeof(unsigned char));

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

BlinkenFrame.c              74)     return NULL;
BlinkenFrame.c              75)   }
BlinkenFrame.c              76) 
BlinkenFrame.c              77)   return pFrame;
BlinkenFrame.c              78) }
BlinkenFrame.c              79) 

src/BlinkenFrame.c          80) stBlinkenFrame *BlinkenFrameClone(stBlinkenFrame *pSrcFrame) {

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

BlinkenLib/BlinkenFrame.c   82)   stBlinkenFrame *pFrame;

BlinkenFrame.c              83) 

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

BlinkenFrame.c              85)     return NULL;
BlinkenFrame.c              86) 

src/BlinkenFrame.c          87)   pFrame =
src/BlinkenFrame.c          88)       BlinkenFrameNew(pSrcFrame->height, pSrcFrame->width, pSrcFrame->channels,
src/BlinkenFrame.c          89)                       pSrcFrame->maxval, pSrcFrame->duration);

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

BlinkenFrame.c              91)     return NULL;
BlinkenFrame.c              92) 

BlinkenLib/BlinkenFrame.c   93)   for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c   94)     for (x = 0, i = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c   95)       for (c = 0; c < pFrame->channels; c++, i++)

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

BlinkenFrame.c              97) 
BlinkenFrame.c              98)   return pFrame;
BlinkenFrame.c              99) }
BlinkenFrame.c             100) 

src/BlinkenFrame.c         101) void BlinkenFrameFree(stBlinkenFrame *pFrame) {

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

BlinkenFrame.c             103)     return;
BlinkenFrame.c             104) 

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

BlinkenFrame.c             107) }
BlinkenFrame.c             108) 

src/BlinkenFrame.c         109) void BlinkenFrameClear(stBlinkenFrame *pFrame) {

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

BlinkenFrame.c             111) 

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

BlinkenFrame.c             113)     return;
BlinkenFrame.c             114) 

BlinkenLib/BlinkenFrame.c  115)   for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c  116)     for (x = 0, i = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c  117)       for (c = 0; c < pFrame->channels; c++, i++)

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

BlinkenFrame.c             119) }
BlinkenFrame.c             120) 

src/BlinkenFrame.c         121) int BlinkenFrameGetHeight(stBlinkenFrame *pFrame) {

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

BlinkenFrame.c             123)     return 0;
BlinkenFrame.c             124) 
BlinkenFrame.c             125)   return pFrame->height;
BlinkenFrame.c             126) }
BlinkenFrame.c             127) 

src/BlinkenFrame.c         128) int BlinkenFrameGetWidth(stBlinkenFrame *pFrame) {

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

BlinkenFrame.c             130)     return 0;
BlinkenFrame.c             131) 
BlinkenFrame.c             132)   return pFrame->width;
BlinkenFrame.c             133) }
BlinkenFrame.c             134) 

src/BlinkenFrame.c         135) int BlinkenFrameGetChannels(stBlinkenFrame *pFrame) {

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

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

src/BlinkenFrame.c         142) int BlinkenFrameGetMaxval(stBlinkenFrame *pFrame) {

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

BlinkenFrame.c             144)     return 0;
BlinkenFrame.c             145) 
BlinkenFrame.c             146)   return pFrame->maxval;
BlinkenFrame.c             147) }
BlinkenFrame.c             148) 

src/BlinkenFrame.c         149) int BlinkenFrameGetDuration(stBlinkenFrame *pFrame) {

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

BlinkenFrame.c             151)     return 0;
BlinkenFrame.c             152) 
BlinkenFrame.c             153)   return pFrame->duration;
BlinkenFrame.c             154) }
BlinkenFrame.c             155) 

src/BlinkenFrame.c         156) void BlinkenFrameSetDuration(stBlinkenFrame *pFrame, int duration) {

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

BlinkenFrame.c             158)     return;
BlinkenFrame.c             159) 

BlinkenLib/BlinkenFrame.c  160)   if (duration < BlinkenDurationMin)
BlinkenLib/BlinkenFrame.c  161)     duration = BlinkenDurationMin;
BlinkenLib/BlinkenFrame.c  162)   if (duration > BlinkenDurationMax)
BlinkenLib/BlinkenFrame.c  163)     duration = BlinkenDurationMax;

BlinkenFrame.c             164) 
BlinkenFrame.c             165)   pFrame->duration = duration;
BlinkenFrame.c             166) }
BlinkenFrame.c             167) 

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

src/BlinkenFrame.c         169)                                    int c) {
src/BlinkenFrame.c         170)   if (pFrame == NULL || y < 0 || y >= pFrame->height || x < 0 ||
src/BlinkenFrame.c         171)       x >= pFrame->width || c < 0 || c >= pFrame->channels)

BlinkenLib/BlinkenFrame.c  172)     return 0;

BlinkenFrame.c             173) 

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

BlinkenFrame.c             175) }
BlinkenFrame.c             176) 

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

src/BlinkenFrame.c         178)                           unsigned char val) {
src/BlinkenFrame.c         179)   if (pFrame == NULL || y < 0 || y >= pFrame->height || x < 0 ||
src/BlinkenFrame.c         180)       x >= pFrame->width || c < 0 || c >= pFrame->channels)

BlinkenLib/BlinkenFrame.c  181)     return;

BlinkenFrame.c             182) 

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

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

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

BlinkenFrame.c             186) }
BlinkenFrame.c             187) 

src/BlinkenFrame.c         188) unsigned long BlinkenFrameGetColor(stBlinkenFrame *pFrame, int y, int x) {

BlinkenFrame.c             189)   int i;
BlinkenFrame.c             190) 

src/BlinkenFrame.c         191)   if (pFrame == NULL || y < 0 || y >= pFrame->height || x < 0 ||
src/BlinkenFrame.c         192)       x >= pFrame->width)

BlinkenLib/BlinkenFrame.c  193)     return 0;

BlinkenFrame.c             194) 

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

BlinkenFrame.c             196) 

BlinkenLib/BlinkenFrame.c  197)   if (pFrame->channels == 1)
BlinkenLib/BlinkenFrame.c  198)     return (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
BlinkenLib/BlinkenFrame.c  199)              pFrame->maxval / 2) /

src/BlinkenFrame.c         200)             pFrame->maxval)
src/BlinkenFrame.c         201)                << 16 |
src/BlinkenFrame.c         202)            (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
src/BlinkenFrame.c         203)              pFrame->maxval / 2) /
src/BlinkenFrame.c         204)             pFrame->maxval)
src/BlinkenFrame.c         205)                << 8 |
src/BlinkenFrame.c         206)            (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
src/BlinkenFrame.c         207)              pFrame->maxval / 2) /
src/BlinkenFrame.c         208)             pFrame->maxval);

BlinkenLib/BlinkenFrame.c  209)   if (pFrame->channels == 2)
BlinkenLib/BlinkenFrame.c  210)     return (((unsigned long)pFrame->ppData[y][i + 0] * 255 +
BlinkenLib/BlinkenFrame.c  211)              pFrame->maxval / 2) /

src/BlinkenFrame.c         212)             pFrame->maxval)
src/BlinkenFrame.c         213)                << 16 |
src/BlinkenFrame.c         214)            (((unsigned long)pFrame->ppData[y][i + 1] * 255 +
src/BlinkenFrame.c         215)              pFrame->maxval / 2) /
src/BlinkenFrame.c         216)             pFrame->maxval)
src/BlinkenFrame.c         217)                << 8;
src/BlinkenFrame.c         218)   return (((unsigned long)pFrame->ppData[y][i + 0] * 255 + pFrame->maxval / 2) /
src/BlinkenFrame.c         219)           pFrame->maxval)
src/BlinkenFrame.c         220)              << 16 |
src/BlinkenFrame.c         221)          (((unsigned long)pFrame->ppData[y][i + 1] * 255 + pFrame->maxval / 2) /
src/BlinkenFrame.c         222)           pFrame->maxval)
src/BlinkenFrame.c         223)              << 8 |
src/BlinkenFrame.c         224)          (((unsigned long)pFrame->ppData[y][i + 2] * 255 + pFrame->maxval / 2) /
src/BlinkenFrame.c         225)           pFrame->maxval);

BlinkenFrame.c             226) }
BlinkenFrame.c             227) 

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

src/BlinkenFrame.c         229)                           unsigned long color) {

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

BlinkenFrame.c             231) 

src/BlinkenFrame.c         232)   if (pFrame == NULL || y < 0 || y >= pFrame->height || x < 0 ||
src/BlinkenFrame.c         233)       x >= pFrame->width)

BlinkenLib/BlinkenFrame.c  234)     return;

BlinkenFrame.c             235) 

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

BlinkenFrame.c             237) 

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

BlinkenLib/BlinkenFrame.c  240)   if (pFrame->channels >= 1)
BlinkenLib/BlinkenFrame.c  241)     pFrame->ppData[y][i + 0] =

src/BlinkenFrame.c         242)         (unsigned char)((((((color >> 16) & 0xFF) * pFrame->maxval + 127) /
src/BlinkenFrame.c         243)                           255) *
src/BlinkenFrame.c         244)                              alpha +
src/BlinkenFrame.c         245)                          (unsigned long)pFrame->ppData[y][i + 0] * alpha_) /
src/BlinkenFrame.c         246)                         255);

BlinkenLib/BlinkenFrame.c  247)   if (pFrame->channels >= 2)
BlinkenLib/BlinkenFrame.c  248)     pFrame->ppData[y][i + 1] =

src/BlinkenFrame.c         249)         (unsigned char)((((((color >> 8) & 0xFF) * pFrame->maxval + 127) /
src/BlinkenFrame.c         250)                           255) *
src/BlinkenFrame.c         251)                              alpha +
src/BlinkenFrame.c         252)                          (unsigned long)pFrame->ppData[y][i + 1] * alpha_) /
src/BlinkenFrame.c         253)                         255);

BlinkenLib/BlinkenFrame.c  254)   if (pFrame->channels >= 3)
BlinkenLib/BlinkenFrame.c  255)     pFrame->ppData[y][i + 2] =

src/BlinkenFrame.c         256)         (unsigned char)(((((color & 0xFF) * pFrame->maxval + 127) / 255) *
src/BlinkenFrame.c         257)                              alpha +
src/BlinkenFrame.c         258)                          (unsigned long)pFrame->ppData[y][i + 2] * alpha_) /
src/BlinkenFrame.c         259)                         255);

BlinkenLib/BlinkenFrame.c  260)   for (c = 3; c < pFrame->channels; c++)

src/BlinkenFrame.c         261)     pFrame->ppData[y][i + c] =
src/BlinkenFrame.c         262)         (unsigned char)((0 + (unsigned long)pFrame->ppData[y][i + c] * alpha_) /
src/BlinkenFrame.c         263)                         255);

BlinkenFrame.c             264) }
BlinkenFrame.c             265) 

src/BlinkenFrame.c         266) void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame, int y, int dy,
src/BlinkenFrame.c         267)                               int x, int dx, int c, int dc,
src/BlinkenFrame.c         268)                               unsigned char *pData) {

src/BlinkenFrame.c         269)   int height, width, channels;
src/BlinkenFrame.c         270)   unsigned char const **ppFrameData;
src/BlinkenFrame.c         271)   int sy, ey, iy, sx, ex, ix, sc, ec, ic; // start/end/index x/y/channel

src/BlinkenFrame.c         272)   int fy, fix, fic;                       // indexes into frame data
src/BlinkenFrame.c         273)   int biy, bix, bic;                      // index into caller's data buffer

src/BlinkenFrame.c         274) 
src/BlinkenFrame.c         275)   // no frame -> leave
src/BlinkenFrame.c         276)   if (pFrame == NULL) {
src/BlinkenFrame.c         277)     return;
src/BlinkenFrame.c         278)   }
src/BlinkenFrame.c         279) 
src/BlinkenFrame.c         280)   height = pFrame->height;
src/BlinkenFrame.c         281)   width = pFrame->width;
src/BlinkenFrame.c         282)   channels = pFrame->channels;
src/BlinkenFrame.c         283)   ppFrameData = (unsigned char const **)pFrame->ppData;
src/BlinkenFrame.c         284) 
src/BlinkenFrame.c         285)   // compute start and end for each coordinate
src/BlinkenFrame.c         286)   sy = y < 0 ? -y : 0;
src/BlinkenFrame.c         287)   ey = y + dy > height ? height - y : dy;
src/BlinkenFrame.c         288)   sx = x < 0 ? -x : 0;
src/BlinkenFrame.c         289)   ex = x + dx > width ? width - x : dx;
src/BlinkenFrame.c         290)   sc = c < 0 ? -c : 0;
src/BlinkenFrame.c         291)   ec = c + dc > channels ? channels - c : dc;
src/BlinkenFrame.c         292) 
src/BlinkenFrame.c         293)   // get pixel data

src/BlinkenFrame.c         294)   for (iy = sy, fy = y, biy = (sy * dx + sx) * dc + sc; iy < ey;
src/BlinkenFrame.c         295)        ++iy, ++fy, biy += dx * dc) {
src/BlinkenFrame.c         296)     for (ix = sx, fix = x * channels + c, bix = biy; ix < ex;
src/BlinkenFrame.c         297)          ++ix, fix += channels, bix += dc) {

src/BlinkenFrame.c         298)       for (ic = sc, fic = fix, bic = bix; ic < ec; ++ic, ++fic, ++bic) {
src/BlinkenFrame.c         299)         pData[bic] = ppFrameData[fy][fic];
src/BlinkenFrame.c         300)       }
src/BlinkenFrame.c         301)     }
src/BlinkenFrame.c         302)   }
src/BlinkenFrame.c         303) }
src/BlinkenFrame.c         304) 

src/BlinkenFrame.c         305) void BlinkenFrameSetPixelData(stBlinkenFrame *pFrame, int y, int dy, int x,
src/BlinkenFrame.c         306)                               int dx, int c, int dc,
src/BlinkenFrame.c         307)                               unsigned char const *pData) {

src/BlinkenFrame.c         308)   int height, width, channels;
src/BlinkenFrame.c         309)   unsigned char maxval;
src/BlinkenFrame.c         310)   unsigned char **ppFrameData;
src/BlinkenFrame.c         311)   int sy, ey, iy, sx, ex, ix, sc, ec, ic; // start/end/index x/y/channel

src/BlinkenFrame.c         312)   int fy, fix, fic;                       // indexes into frame data
src/BlinkenFrame.c         313)   int biy, bix, bic;                      // index into caller's data buffer

src/BlinkenFrame.c         314)   unsigned char value;
src/BlinkenFrame.c         315) 
src/BlinkenFrame.c         316)   // no frame -> leave
src/BlinkenFrame.c         317)   if (pFrame == NULL) {
src/BlinkenFrame.c         318)     return;
src/BlinkenFrame.c         319)   }
src/BlinkenFrame.c         320) 
src/BlinkenFrame.c         321)   height = pFrame->height;
src/BlinkenFrame.c         322)   width = pFrame->width;
src/BlinkenFrame.c         323)   channels = pFrame->channels;
src/BlinkenFrame.c         324)   maxval = pFrame->maxval;
src/BlinkenFrame.c         325)   ppFrameData = pFrame->ppData;
src/BlinkenFrame.c         326) 
src/BlinkenFrame.c         327)   // compute start and end for each coordinate
src/BlinkenFrame.c         328)   sy = y < 0 ? -y : 0;
src/BlinkenFrame.c         329)   ey = y + dy > height ? height - y : dy;
src/BlinkenFrame.c         330)   sx = x < 0 ? -x : 0;
src/BlinkenFrame.c         331)   ex = x + dx > width ? width - x : dx;
src/BlinkenFrame.c         332)   sc = c < 0 ? -c : 0;
src/BlinkenFrame.c         333)   ec = c + dc > channels ? channels - c : dc;
src/BlinkenFrame.c         334) 
src/BlinkenFrame.c         335)   // set pixel data

src/BlinkenFrame.c         336)   for (iy = sy, fy = y, biy = (sy * dx + sx) * dc + sc; iy < ey;
src/BlinkenFrame.c         337)        ++iy, ++fy, biy += dx * dc) {
src/BlinkenFrame.c         338)     for (ix = sx, fix = x * channels + c, bix = biy; ix < ex;
src/BlinkenFrame.c         339)          ++ix, fix += channels, bix += dc) {

src/BlinkenFrame.c         340)       for (ic = sc, fic = fix, bic = bix; ic < ec; ++ic, ++fic, ++bic) {
src/BlinkenFrame.c         341)         value = pData[bic];
src/BlinkenFrame.c         342)         ppFrameData[fy][fic] = value > maxval ? maxval : value;
src/BlinkenFrame.c         343)       }
src/BlinkenFrame.c         344)     }
src/BlinkenFrame.c         345)   }
src/BlinkenFrame.c         346) }
src/BlinkenFrame.c         347) 

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

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

BlinkenLib/BlinkenFrame.c  350) {
BlinkenLib/BlinkenFrame.c  351)   int y, x, c, i;
BlinkenLib/BlinkenFrame.c  352) 

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

BlinkenLib/BlinkenFrame.c  354)     return 0;
BlinkenLib/BlinkenFrame.c  355) 

BlinkenLib/BlinkenFrame.c  356)   for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c  357)     for (x = 0, i = 0; x < pFrame->width; x++) {
BlinkenLib/BlinkenFrame.c  358)       for (c = 0; c < pFrame->channels; c++, i++) {
BlinkenLib/BlinkenFrame.c  359)         if (pFrame->ppData[y][i] != 0)

src/BlinkenFrame.c         360)           break; // pixel is not black -> abort

BlinkenLib/BlinkenFrame.c  361)       }

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

BlinkenLib/BlinkenFrame.c  363)         break;
BlinkenLib/BlinkenFrame.c  364)     }

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

BlinkenLib/BlinkenFrame.c  366)       break;
BlinkenLib/BlinkenFrame.c  367)   }

BlinkenLib/BlinkenFrame.c  368)   if (y < pFrame->height)

src/BlinkenFrame.c         369)     return 0; // aborted somewhere -> at least ony pixel is not black

BlinkenLib/BlinkenFrame.c  370)   else

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

BlinkenLib/BlinkenFrame.c  372) }
BlinkenLib/BlinkenFrame.c  373) 

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

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

BlinkenFrame.c             376) {
BlinkenFrame.c             377)   int y, cmp;
BlinkenFrame.c             378) 

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

BlinkenFrame.c             380)     return -1;

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

BlinkenFrame.c             382)     return 1;

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

BlinkenFrame.c             384)     return -1;

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

BlinkenFrame.c             386)     return 1;

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

BlinkenFrame.c             388)     return -1;

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

BlinkenFrame.c             390)     return 1;

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

BlinkenFrame.c             392)     return -1;

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

BlinkenFrame.c             394)     return 1;
BlinkenFrame.c             395) 

BlinkenLib/BlinkenFrame.c  396)   for (y = 0; y < pFrame1->height; y++) {

src/BlinkenFrame.c         397)     cmp = memcmp(pFrame1->ppData[y], pFrame2->ppData[y],
src/BlinkenFrame.c         398)                  pFrame1->width * pFrame2->channels);

BlinkenLib/BlinkenFrame.c  399)     if (cmp != 0)

BlinkenFrame.c             400)       return cmp;
BlinkenFrame.c             401)   }
BlinkenFrame.c             402) 
BlinkenFrame.c             403)   return 0;
BlinkenFrame.c             404) }
BlinkenFrame.c             405) 

BlinkenLib/BlinkenFrame.c  406) static void BlinkenFramePadCrop(stBlinkenFrame *pFrame, int height, int width,

src/BlinkenFrame.c         407)                                 int channels, int maxval, int emptyY,
src/BlinkenFrame.c         408)                                 int emptyX, int skipY, int skipX) {

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

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

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

BlinkenFrame.c             412)   unsigned long val, div;
BlinkenFrame.c             413) 

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

BlinkenFrame.c             415)     return;
BlinkenFrame.c             416) 

BlinkenLib/BlinkenFrame.c  417)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  418)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  419)   if (height > BlinkenHeightMax)
BlinkenLib/BlinkenFrame.c  420)     height = BlinkenHeightMax;
BlinkenLib/BlinkenFrame.c  421)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  422)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  423)   if (width > BlinkenWidthMax)
BlinkenLib/BlinkenFrame.c  424)     width = BlinkenWidthMax;
BlinkenLib/BlinkenFrame.c  425)   if (channels < BlinkenChannelsMin)
BlinkenLib/BlinkenFrame.c  426)     channels = BlinkenChannelsMin;
BlinkenLib/BlinkenFrame.c  427)   if (channels > BlinkenChannelsMax)
BlinkenLib/BlinkenFrame.c  428)     channels = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  429)   if (maxval < BlinkenMaxvalMin)
BlinkenLib/BlinkenFrame.c  430)     maxval = BlinkenMaxvalMin;
BlinkenLib/BlinkenFrame.c  431)   if (maxval > BlinkenMaxvalMax)
BlinkenLib/BlinkenFrame.c  432)     maxval = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  433) 

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

src/BlinkenFrame.c         435)       channels == pFrame->channels && maxval == pFrame->maxval && emptyX == 0 &&
src/BlinkenFrame.c         436)       emptyY == 0 && skipY == 0 && skipX == 0)

BlinkenFrame.c             437)     return;
BlinkenFrame.c             438) 

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

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

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

BlinkenFrame.c             443)     return;

BlinkenLib/BlinkenFrame.c  444)   for (y = 0; y < height; y++)
BlinkenLib/BlinkenFrame.c  445)     for (x = 0, i = 0; x < width; x++)
BlinkenLib/BlinkenFrame.c  446)       for (c = 0; c < channels; c++, i++)

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

BlinkenFrame.c             448) 

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

BlinkenFrame.c             451)     emptyY = 0;

BlinkenLib/BlinkenFrame.c  452)   if (emptyY > height)
BlinkenLib/BlinkenFrame.c  453)     emptyY = height;
BlinkenLib/BlinkenFrame.c  454)   if (emptyX < 0)

BlinkenFrame.c             455)     emptyX = 0;

BlinkenLib/BlinkenFrame.c  456)   if (emptyX > width)
BlinkenLib/BlinkenFrame.c  457)     emptyX = width;
BlinkenLib/BlinkenFrame.c  458)   if (skipY < 0)
BlinkenLib/BlinkenFrame.c  459)     skipY = 0;
BlinkenLib/BlinkenFrame.c  460)   if (skipY > pFrame->height)
BlinkenLib/BlinkenFrame.c  461)     skipY = pFrame->height;
BlinkenLib/BlinkenFrame.c  462)   if (skipX < 0)
BlinkenLib/BlinkenFrame.c  463)     skipX = 0;
BlinkenLib/BlinkenFrame.c  464)   if (skipX > pFrame->width)
BlinkenLib/BlinkenFrame.c  465)     skipX = pFrame->width;
BlinkenLib/BlinkenFrame.c  466)   rangeY = mini(height - emptyY, pFrame->height - skipY);
BlinkenLib/BlinkenFrame.c  467)   rangeX = mini(width - emptyX, pFrame->width - skipX);

BlinkenFrame.c             468) 

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

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

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

BlinkenLib/BlinkenFrame.c  474)       if (channels >= pFrame->channels) // add channels: copy last channel

src/BlinkenFrame.c         475)                                         // into new channels

BlinkenFrame.c             476)       {

BlinkenLib/BlinkenFrame.c  477)         for (c = 0; c < pFrame->channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  478)           ppData[emptyY + y][j] =

src/BlinkenFrame.c         479)               (unsigned char)(((unsigned long)pFrame->ppData[skipY + y][i] *
src/BlinkenFrame.c         480)                                    maxval +
src/BlinkenFrame.c         481)                                pFrame->maxval / 2) /
src/BlinkenFrame.c         482)                               pFrame->maxval);

BlinkenLib/BlinkenFrame.c  483)         for (; c < channels; c++, j++)

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

src/BlinkenFrame.c         485)       } else // remove channels: merge leftover channels with last kept
src/BlinkenFrame.c         486)              // channel

BlinkenFrame.c             487)       {
BlinkenFrame.c             488)         val = 0;

BlinkenLib/BlinkenFrame.c  489)         for (c = 0; c < channels - 1; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  490)           ppData[emptyY + y][j] =

src/BlinkenFrame.c         491)               (unsigned char)(((unsigned long)pFrame->ppData[skipY + y][i] *
src/BlinkenFrame.c         492)                                    maxval +
src/BlinkenFrame.c         493)                                pFrame->maxval / 2) /
src/BlinkenFrame.c         494)                               pFrame->maxval);

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

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

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

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

BlinkenFrame.c             500)       }
BlinkenFrame.c             501)     }
BlinkenFrame.c             502)   }
BlinkenFrame.c             503) 
BlinkenFrame.c             504)   pFrame->height = height;
BlinkenFrame.c             505)   pFrame->width = width;
BlinkenFrame.c             506)   pFrame->channels = channels;
BlinkenFrame.c             507)   pFrame->maxval = maxval;

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

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

BlinkenFrame.c             510) }
BlinkenFrame.c             511) 

BlinkenLib/BlinkenFrame.c  512) void BlinkenFrameResize(stBlinkenFrame *pFrame, int height, int width,

src/BlinkenFrame.c         513)                         int channels, int maxval) {

BlinkenLib/BlinkenFrame.c  514)   int emptyY, emptyX, skipY, skipX;
BlinkenLib/BlinkenFrame.c  515) 
BlinkenLib/BlinkenFrame.c  516)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  517)     return;
BlinkenLib/BlinkenFrame.c  518) 
BlinkenLib/BlinkenFrame.c  519)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  520)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  521)   if (height > BlinkenHeightMax)
BlinkenLib/BlinkenFrame.c  522)     height = BlinkenHeightMax;
BlinkenLib/BlinkenFrame.c  523)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  524)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  525)   if (width > BlinkenWidthMax)
BlinkenLib/BlinkenFrame.c  526)     width = BlinkenWidthMax;
BlinkenLib/BlinkenFrame.c  527)   if (channels < BlinkenChannelsMin)
BlinkenLib/BlinkenFrame.c  528)     channels = BlinkenChannelsMin;
BlinkenLib/BlinkenFrame.c  529)   if (channels > BlinkenChannelsMax)
BlinkenLib/BlinkenFrame.c  530)     channels = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  531)   if (maxval < BlinkenMaxvalMin)
BlinkenLib/BlinkenFrame.c  532)     maxval = BlinkenMaxvalMin;
BlinkenLib/BlinkenFrame.c  533)   if (maxval > BlinkenMaxvalMax)
BlinkenLib/BlinkenFrame.c  534)     maxval = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  535) 
BlinkenLib/BlinkenFrame.c  536)   if (height == pFrame->height && width == pFrame->width &&
BlinkenLib/BlinkenFrame.c  537)       channels == pFrame->channels && maxval == pFrame->maxval)
BlinkenLib/BlinkenFrame.c  538)     return;
BlinkenLib/BlinkenFrame.c  539) 
BlinkenLib/BlinkenFrame.c  540)   // get number of pixels to skip / to leave empty in X and Y direction
BlinkenLib/BlinkenFrame.c  541)   if (height > pFrame->height) {
BlinkenLib/BlinkenFrame.c  542)     emptyY = (height - pFrame->height) / 2;
BlinkenLib/BlinkenFrame.c  543)     skipY = 0;
BlinkenLib/BlinkenFrame.c  544)   } else {
BlinkenLib/BlinkenFrame.c  545)     emptyY = 0;
BlinkenLib/BlinkenFrame.c  546)     skipY = (pFrame->height - height) / 2;
BlinkenLib/BlinkenFrame.c  547)   }
BlinkenLib/BlinkenFrame.c  548)   if (width > pFrame->width) {
BlinkenLib/BlinkenFrame.c  549)     emptyX = (width - pFrame->width) / 2;
BlinkenLib/BlinkenFrame.c  550)     skipX = 0;
BlinkenLib/BlinkenFrame.c  551)   } else {
BlinkenLib/BlinkenFrame.c  552)     emptyX = 0;
BlinkenLib/BlinkenFrame.c  553)     skipX = (pFrame->width - width) / 2;
BlinkenLib/BlinkenFrame.c  554)   }
BlinkenLib/BlinkenFrame.c  555) 
BlinkenLib/BlinkenFrame.c  556)   // resize frame with help of calculated parameters

src/BlinkenFrame.c         557)   BlinkenFramePadCrop(pFrame, height, width, channels, maxval, emptyY, emptyX,
src/BlinkenFrame.c         558)                       skipY, skipX);

BlinkenLib/BlinkenFrame.c  559) }
BlinkenLib/BlinkenFrame.c  560) 

src/BlinkenFrame.c         561) void BlinkenFrameCrop(stBlinkenFrame *pFrame, int top, int left, int height,
src/BlinkenFrame.c         562)                       int width) {

BlinkenLib/BlinkenFrame.c  563)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  564)     return;
BlinkenLib/BlinkenFrame.c  565) 
BlinkenLib/BlinkenFrame.c  566)   if (top < 0)
BlinkenLib/BlinkenFrame.c  567)     top = 0;
BlinkenLib/BlinkenFrame.c  568)   if (top > pFrame->height - BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  569)     top = pFrame->height - BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  570)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  571)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  572)   if (height > pFrame->height - top)
BlinkenLib/BlinkenFrame.c  573)     height = pFrame->height - top;
BlinkenLib/BlinkenFrame.c  574)   if (left < 0)
BlinkenLib/BlinkenFrame.c  575)     left = 0;
BlinkenLib/BlinkenFrame.c  576)   if (left > pFrame->width - BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  577)     left = pFrame->width - BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  578)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  579)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  580)   if (width > pFrame->width - left)
BlinkenLib/BlinkenFrame.c  581)     width = pFrame->width - left;
BlinkenLib/BlinkenFrame.c  582) 

src/BlinkenFrame.c         583)   if (top == 0 && left == 0 && height == pFrame->height &&
src/BlinkenFrame.c         584)       width == pFrame->width)

BlinkenLib/BlinkenFrame.c  585)     return;
BlinkenLib/BlinkenFrame.c  586) 
BlinkenLib/BlinkenFrame.c  587)   // crop frame with help of calculated parameters
BlinkenLib/BlinkenFrame.c  588)   BlinkenFramePadCrop(pFrame, height, width, pFrame->channels, pFrame->maxval,
BlinkenLib/BlinkenFrame.c  589)                       0, 0, top, left);
BlinkenLib/BlinkenFrame.c  590) }
BlinkenLib/BlinkenFrame.c  591) 

src/BlinkenFrame.c         592) void BlinkenFrameScale(stBlinkenFrame *pFrame, int height, int width) {

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

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

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

BlinkenFrame.c             596) 

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

BlinkenFrame.c             598)     return;
BlinkenFrame.c             599) 

BlinkenLib/BlinkenFrame.c  600)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  601)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  602)   if (height > BlinkenHeightMax)
BlinkenLib/BlinkenFrame.c  603)     height = BlinkenHeightMax;
BlinkenLib/BlinkenFrame.c  604)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  605)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  606)   if (width > BlinkenWidthMax)
BlinkenLib/BlinkenFrame.c  607)     width = BlinkenWidthMax;

BlinkenFrame.c             608) 

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

BlinkenFrame.c             610)     return;
BlinkenFrame.c             611) 
BlinkenFrame.c             612)   scaleHor = (double)width / (double)pFrame->width;
BlinkenFrame.c             613)   scaleVer = (double)height / (double)pFrame->height;
BlinkenFrame.c             614) 

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

src/BlinkenFrame.c         616)   ppData = (unsigned char **)BlinkenMalloc2D(height, width * pFrame->channels,
src/BlinkenFrame.c         617)                                              sizeof(unsigned char));

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

BlinkenFrame.c             619)     return;
BlinkenFrame.c             620) 

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

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

BlinkenLib/BlinkenFrame.c  623)   for (c = 0; c < chans; c++) {
BlinkenLib/BlinkenFrame.c  624)     for (ny = 0; ny < height; ny++) {
BlinkenLib/BlinkenFrame.c  625)       for (nx = 0; nx < width; nx++) {

src/BlinkenFrame.c         626)         oy = (double)ny / scaleVer; // sub-pixel exact range in old

BlinkenLib/BlinkenFrame.c  627)         // picture

BlinkenFrame.c             628)         ox = (double)nx / scaleHor;
BlinkenFrame.c             629)         oy1 = (double)(ny + 1) / scaleVer - 0.000001;
BlinkenFrame.c             630)         ox1 = (double)(nx + 1) / scaleHor - 0.000001;

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

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

BlinkenLib/BlinkenFrame.c  634)         else {

BlinkenFrame.c             635)           oyi = (int)oy;
BlinkenFrame.c             636)           oxi = (int)ox;
BlinkenFrame.c             637)           oy1i = (int)oy1;
BlinkenFrame.c             638)           ox1i = (int)ox1;

BlinkenLib/BlinkenFrame.c  639)           if (oyi == oy1i) {

src/BlinkenFrame.c         640)             if (oxi == ox1i) // one source pixel

BlinkenFrame.c             641)             {

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

src/BlinkenFrame.c         643)             } else // one line of source pixels

BlinkenFrame.c             644)             {

BlinkenLib/BlinkenFrame.c  645)               val =

src/BlinkenFrame.c         646)                   (double)pFrame->ppData[oyi][oxi * chans + c] *
src/BlinkenFrame.c         647)                       (1 - ox + oxi) +
src/BlinkenFrame.c         648)                   (double)pFrame->ppData[oyi][ox1i * chans + c] * (ox1 - ox1i);

BlinkenLib/BlinkenFrame.c  649)               for (x = oxi + 1; x < ox1i; x++)

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

BlinkenFrame.c             651)               val /= ox1 - ox;
BlinkenFrame.c             652)             }

src/BlinkenFrame.c         653)           } else // one column of source pixels

BlinkenFrame.c             654)           {

BlinkenLib/BlinkenFrame.c  655)             if (oxi == ox1i) {
BlinkenLib/BlinkenFrame.c  656)               val =

src/BlinkenFrame.c         657)                   (double)pFrame->ppData[oyi][oxi * chans + c] *
src/BlinkenFrame.c         658)                       (1 - oy + oyi) +
src/BlinkenFrame.c         659)                   (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 - oy1i);

BlinkenLib/BlinkenFrame.c  660)               for (y = oyi + 1; y < oy1i; y++)

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

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

src/BlinkenFrame.c         663)             } else // rectangle of source pixels

BlinkenFrame.c             664)             {

src/BlinkenFrame.c         665)               val = (double)pFrame->ppData[oyi][oxi * chans + c] *
src/BlinkenFrame.c         666)                         (1 - oy + oyi) * (1 - ox + oxi) +
src/BlinkenFrame.c         667)                     (double)pFrame->ppData[oyi][ox1i * chans + c] *
src/BlinkenFrame.c         668)                         (1 - oy + oyi) * (ox1 - ox1i) +
src/BlinkenFrame.c         669)                     (double)pFrame->ppData[oy1i][oxi * chans + c] *
src/BlinkenFrame.c         670)                         (oy1 - oy1i) * (1 - ox + oxi) +
src/BlinkenFrame.c         671)                     (double)pFrame->ppData[oy1i][ox1i * chans + c] *
src/BlinkenFrame.c         672)                         (oy1 - oy1i) * (ox1 - ox1i);

BlinkenLib/BlinkenFrame.c  673)               for (y = oyi + 1; y < oy1i; y++) {
BlinkenLib/BlinkenFrame.c  674)                 val +=

src/BlinkenFrame.c         675)                     (double)pFrame->ppData[y][oxi * chans + c] *
src/BlinkenFrame.c         676)                         (1 - ox + oxi) +
src/BlinkenFrame.c         677)                     (double)pFrame->ppData[y][ox1i * chans + c] * (ox1 - ox1i);

BlinkenFrame.c             678)               }

BlinkenLib/BlinkenFrame.c  679)               for (x = oxi + 1; x < ox1i; x++) {
BlinkenLib/BlinkenFrame.c  680)                 val +=

src/BlinkenFrame.c         681)                     (double)pFrame->ppData[oyi][x * chans + c] *
src/BlinkenFrame.c         682)                         (1 - oy + oyi) +
src/BlinkenFrame.c         683)                     (double)pFrame->ppData[oy1i][x * chans + c] * (oy1 - oy1i);

BlinkenFrame.c             684)               }

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

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

BlinkenFrame.c             688)               val /= (oy1 - oy) * (ox1 - ox);
BlinkenFrame.c             689)             }
BlinkenFrame.c             690)           }

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

BlinkenFrame.c             692)         }

BlinkenLib/BlinkenFrame.c  693)       } // for( nx ...
BlinkenLib/BlinkenFrame.c  694)     }   // for( ny ...
BlinkenLib/BlinkenFrame.c  695)   }     // for( c ...

BlinkenFrame.c             696) 
BlinkenFrame.c             697)   pFrame->height = height;
BlinkenFrame.c             698)   pFrame->width = width;

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

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

BlinkenFrame.c             701) }
BlinkenFrame.c             702) 

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

src/BlinkenFrame.c         704)                           int step) {

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

BlinkenFrame.c             706)   int y, x, c, i, j;
BlinkenFrame.c             707)   unsigned int val;
BlinkenFrame.c             708) 

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

BlinkenFrame.c             710)     return;
BlinkenFrame.c             711) 

BlinkenLib/BlinkenFrame.c  712)   if (channels < BlinkenChannelsMin)
BlinkenLib/BlinkenFrame.c  713)     channels = BlinkenChannelsMin;
BlinkenLib/BlinkenFrame.c  714)   if (channels > BlinkenChannelsMax)
BlinkenLib/BlinkenFrame.c  715)     channels = BlinkenMaxvalMax;

BlinkenFrame.c             716) 

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

src/BlinkenFrame.c         718)   ppData = (unsigned char **)BlinkenMalloc2D(
src/BlinkenFrame.c         719)       pFrame->height, pFrame->width * channels, sizeof(unsigned char));

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

BlinkenFrame.c             721)     return;

BlinkenLib/BlinkenFrame.c  722)   for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c  723)     for (x = 0, i = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c  724)       for (c = 0; c < channels; c++, i++)

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

BlinkenLib/BlinkenFrame.c  727)   // colorize frame
BlinkenLib/BlinkenFrame.c  728)   for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c  729)     for (x = 0; x < pFrame->width; x++) {

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

BlinkenLib/BlinkenFrame.c  731)       // merge channels

BlinkenFrame.c             732)       val = 0;

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

BlinkenFrame.c             734)         val += pFrame->ppData[y][i];
BlinkenFrame.c             735)       val = (val + pFrame->channels / 2) / pFrame->channels;
BlinkenFrame.c             736)       val = (val * BlinkenMaxvalMax + pFrame->maxval / 2) / pFrame->maxval;

BlinkenLib/BlinkenFrame.c  737)       // colorize

BlinkenFrame.c             738)       j = x * channels;

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

BlinkenFrame.c             741)         ppData[y][j] = (unsigned char)((val * color + 127) / 255);
BlinkenFrame.c             742)       }
BlinkenFrame.c             743)     }
BlinkenFrame.c             744)   }
BlinkenFrame.c             745) 
BlinkenFrame.c             746)   pFrame->channels = channels;
BlinkenFrame.c             747)   pFrame->maxval = BlinkenMaxvalMax;

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

BlinkenFrame.c             749)   pFrame->ppData = ppData;
BlinkenFrame.c             750) }
BlinkenFrame.c             751) 

BlinkenLib/BlinkenFrame.c  752) void BlinkenFrameCopyRect(stBlinkenFrame *pDest, int destY, int destX,

src/BlinkenFrame.c         753)                           stBlinkenFrame *pSrc, int srcY, int srcX, int height,
src/BlinkenFrame.c         754)                           int width) {

BlinkenLib/BlinkenFrame.c  755)   int bFreeSrc = 0;
BlinkenLib/BlinkenFrame.c  756)   int destI, srcI, y, x, c, dy, sy, di, si;
BlinkenLib/BlinkenFrame.c  757) 
BlinkenLib/BlinkenFrame.c  758)   if (pDest == NULL || pSrc == NULL)
BlinkenLib/BlinkenFrame.c  759)     return;
BlinkenLib/BlinkenFrame.c  760) 
BlinkenLib/BlinkenFrame.c  761)   // make sure source frame matches dest frame in channels and maxval
BlinkenLib/BlinkenFrame.c  762)   if (pSrc->channels != pDest->channels || pSrc->maxval != pDest->maxval) {
BlinkenLib/BlinkenFrame.c  763)     pSrc = BlinkenFrameClone(pSrc);
BlinkenLib/BlinkenFrame.c  764)     if (pSrc == NULL)
BlinkenLib/BlinkenFrame.c  765)       return;

src/BlinkenFrame.c         766)     BlinkenFrameResize(pSrc, pSrc->height, pSrc->width, pDest->channels,
src/BlinkenFrame.c         767)                        pDest->maxval);

BlinkenLib/BlinkenFrame.c  768)     bFreeSrc = 1; // source is now a temporary copy that needs to be freed
BlinkenLib/BlinkenFrame.c  769)   }
BlinkenLib/BlinkenFrame.c  770) 
BlinkenLib/BlinkenFrame.c  771)   // correct coordinates
BlinkenLib/BlinkenFrame.c  772)   if (destY < 0) {
BlinkenLib/BlinkenFrame.c  773)     height += destY;
BlinkenLib/BlinkenFrame.c  774)     srcY -= destY;
BlinkenLib/BlinkenFrame.c  775)     destY = 0;
BlinkenLib/BlinkenFrame.c  776)   }
BlinkenLib/BlinkenFrame.c  777)   if (destX < 0) {
BlinkenLib/BlinkenFrame.c  778)     width += destX;
BlinkenLib/BlinkenFrame.c  779)     srcX -= destX;
BlinkenLib/BlinkenFrame.c  780)     destX = 0;
BlinkenLib/BlinkenFrame.c  781)   }
BlinkenLib/BlinkenFrame.c  782)   if (srcY < 0) {
BlinkenLib/BlinkenFrame.c  783)     height += srcY;
BlinkenLib/BlinkenFrame.c  784)     destY -= srcY;
BlinkenLib/BlinkenFrame.c  785)     srcY = 0;
BlinkenLib/BlinkenFrame.c  786)   }
BlinkenLib/BlinkenFrame.c  787)   if (srcX < 0) {
BlinkenLib/BlinkenFrame.c  788)     width += srcX;
BlinkenLib/BlinkenFrame.c  789)     destX -= srcX;
BlinkenLib/BlinkenFrame.c  790)     srcX = 0;
BlinkenLib/BlinkenFrame.c  791)   }
BlinkenLib/BlinkenFrame.c  792)   if (height > pDest->height - destY)
BlinkenLib/BlinkenFrame.c  793)     height = pDest->height - destY;
BlinkenLib/BlinkenFrame.c  794)   if (width > pDest->width - destX)
BlinkenLib/BlinkenFrame.c  795)     width = pDest->width - destX;
BlinkenLib/BlinkenFrame.c  796)   if (height > pSrc->height - srcY)
BlinkenLib/BlinkenFrame.c  797)     height = pSrc->height - srcY;
BlinkenLib/BlinkenFrame.c  798)   if (width > pSrc->width - srcX)
BlinkenLib/BlinkenFrame.c  799)     width = pSrc->width - srcX;
BlinkenLib/BlinkenFrame.c  800)   if (height < 0)
BlinkenLib/BlinkenFrame.c  801)     height = 0;
BlinkenLib/BlinkenFrame.c  802)   if (width < 0)
BlinkenLib/BlinkenFrame.c  803)     width = 0;
BlinkenLib/BlinkenFrame.c  804) 
BlinkenLib/BlinkenFrame.c  805)   // copy rectangular area
BlinkenLib/BlinkenFrame.c  806)   destI = destX * pDest->channels;
BlinkenLib/BlinkenFrame.c  807)   srcI = srcX * pSrc->channels;
BlinkenLib/BlinkenFrame.c  808)   for (y = 0, dy = destY, sy = srcY; y < height; y++, dy++, sy++)
BlinkenLib/BlinkenFrame.c  809)     for (x = 0, di = destI, si = srcI; x < width; x++)
BlinkenLib/BlinkenFrame.c  810)       for (c = 0; c < pDest->channels; c++, di++, si++)
BlinkenLib/BlinkenFrame.c  811)         pDest->ppData[dy][di] = pSrc->ppData[sy][si];
BlinkenLib/BlinkenFrame.c  812) 
BlinkenLib/BlinkenFrame.c  813)   // free source if it is a temporary copy
BlinkenLib/BlinkenFrame.c  814)   if (bFreeSrc)
BlinkenLib/BlinkenFrame.c  815)     BlinkenFrameFree(pSrc);
BlinkenLib/BlinkenFrame.c  816) }
BlinkenLib/BlinkenFrame.c  817) 

src/BlinkenFrame.c         818) void BlinkenFrameRotateCw(stBlinkenFrame *pFrame) {

BlinkenLib/BlinkenFrame.c  819)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c  820)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c  821) 
BlinkenLib/BlinkenFrame.c  822)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  823)     return;
BlinkenLib/BlinkenFrame.c  824) 
BlinkenLib/BlinkenFrame.c  825)   // allocate new data array
BlinkenLib/BlinkenFrame.c  826)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c  827)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c  828)   channels = pFrame->channels;

src/BlinkenFrame.c         829)   ppData = (unsigned char **)BlinkenMalloc2D(height, width * channels,
src/BlinkenFrame.c         830)                                              sizeof(unsigned char));

BlinkenLib/BlinkenFrame.c  831)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c  832)     return;
BlinkenLib/BlinkenFrame.c  833) 
BlinkenLib/BlinkenFrame.c  834)   // rotate
BlinkenLib/BlinkenFrame.c  835)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c  836)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c  837)       j = y * channels;
BlinkenLib/BlinkenFrame.c  838)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  839)         ppData[y][i] = pFrame->ppData[width - 1 - x][j];
BlinkenLib/BlinkenFrame.c  840)     }
BlinkenLib/BlinkenFrame.c  841)   }
BlinkenLib/BlinkenFrame.c  842) 
BlinkenLib/BlinkenFrame.c  843)   // use new data array
BlinkenLib/BlinkenFrame.c  844)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c  845)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c  846)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c  847)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c  848) }
BlinkenLib/BlinkenFrame.c  849) 

src/BlinkenFrame.c         850) void BlinkenFrameRotateCcw(stBlinkenFrame *pFrame) {

BlinkenLib/BlinkenFrame.c  851)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c  852)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c  853) 
BlinkenLib/BlinkenFrame.c  854)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  855)     return;
BlinkenLib/BlinkenFrame.c  856) 
BlinkenLib/BlinkenFrame.c  857)   // allocate new data array
BlinkenLib/BlinkenFrame.c  858)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c  859)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c  860)   channels = pFrame->channels;

src/BlinkenFrame.c         861)   ppData = (unsigned char **)BlinkenMalloc2D(height, width * channels,
src/BlinkenFrame.c         862)                                              sizeof(unsigned char));

BlinkenLib/BlinkenFrame.c  863)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c  864)     return;
BlinkenLib/BlinkenFrame.c  865) 
BlinkenLib/BlinkenFrame.c  866)   // rotate
BlinkenLib/BlinkenFrame.c  867)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c  868)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c  869)       j = (height - 1 - y) * channels;
BlinkenLib/BlinkenFrame.c  870)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  871)         ppData[y][i] = pFrame->ppData[x][j];
BlinkenLib/BlinkenFrame.c  872)     }
BlinkenLib/BlinkenFrame.c  873)   }
BlinkenLib/BlinkenFrame.c  874) 
BlinkenLib/BlinkenFrame.c  875)   // use new data array
BlinkenLib/BlinkenFrame.c  876)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c  877)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c  878)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c  879)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c  880) }
BlinkenLib/BlinkenFrame.c  881) 

src/BlinkenFrame.c         882) void BlinkenFrameRotateHalf(stBlinkenFrame *pFrame) {

BlinkenLib/BlinkenFrame.c  883)   int y1, y2, x1, x2, c, i1, i2;
BlinkenLib/BlinkenFrame.c  884) 
BlinkenLib/BlinkenFrame.c  885)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  886)     return;
BlinkenLib/BlinkenFrame.c  887) 

src/BlinkenFrame.c         888)   for (y1 = 0, y2 = pFrame->height - 1; y1 < pFrame->height; y1++, y2--) {
src/BlinkenFrame.c         889)     for (x1 = 0, x2 = pFrame->width - 1, i1 = 0,
src/BlinkenFrame.c         890)         i2 = (pFrame->width - 1) * pFrame->channels;

BlinkenLib/BlinkenFrame.c  891)          x1 < pFrame->width / 2; x1++, x2--, i2 -= 2 * pFrame->channels) {
BlinkenLib/BlinkenFrame.c  892)       for (c = 0; c < pFrame->channels; c++, i1++, i2++) {
BlinkenLib/BlinkenFrame.c  893)         unsigned char tmp = pFrame->ppData[y1][i1];
BlinkenLib/BlinkenFrame.c  894)         pFrame->ppData[y1][i1] = pFrame->ppData[y2][i2];
BlinkenLib/BlinkenFrame.c  895)         pFrame->ppData[y2][i2] = tmp;
BlinkenLib/BlinkenFrame.c  896)       }
BlinkenLib/BlinkenFrame.c  897)     }
BlinkenLib/BlinkenFrame.c  898)   }
BlinkenLib/BlinkenFrame.c  899) }
BlinkenLib/BlinkenFrame.c  900) 

src/BlinkenFrame.c         901) void BlinkenFrameMirrorHor(stBlinkenFrame *pFrame) {

BlinkenLib/BlinkenFrame.c  902)   int y, x1, x2, c, i1, i2;
BlinkenLib/BlinkenFrame.c  903) 
BlinkenLib/BlinkenFrame.c  904)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  905)     return;
BlinkenLib/BlinkenFrame.c  906) 
BlinkenLib/BlinkenFrame.c  907)   for (y = 0; y < pFrame->height; y++) {

src/BlinkenFrame.c         908)     for (x1 = 0, x2 = pFrame->width - 1, i1 = 0,
src/BlinkenFrame.c         909)         i2 = (pFrame->width - 1) * pFrame->channels;

BlinkenLib/BlinkenFrame.c  910)          x1 < pFrame->width / 2; x1++, x2--, i2 -= 2 * pFrame->channels) {
BlinkenLib/BlinkenFrame.c  911)       for (c = 0; c < pFrame->channels; c++, i1++, i2++) {
BlinkenLib/BlinkenFrame.c  912)         unsigned char tmp = pFrame->ppData[y][i1];
BlinkenLib/BlinkenFrame.c  913)         pFrame->ppData[y][i1] = pFrame->ppData[y][i2];
BlinkenLib/BlinkenFrame.c  914)         pFrame->ppData[y][i2] = tmp;
BlinkenLib/BlinkenFrame.c  915)       }
BlinkenLib/BlinkenFrame.c  916)     }
BlinkenLib/BlinkenFrame.c  917)   }
BlinkenLib/BlinkenFrame.c  918) }
BlinkenLib/BlinkenFrame.c  919) 

src/BlinkenFrame.c         920) void BlinkenFrameMirrorVer(stBlinkenFrame *pFrame) {

BlinkenLib/BlinkenFrame.c  921)   int y1, y2, x, c, i;
BlinkenLib/BlinkenFrame.c  922) 
BlinkenLib/BlinkenFrame.c  923)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  924)     return;
BlinkenLib/BlinkenFrame.c  925) 
BlinkenLib/BlinkenFrame.c  926)   for (y1 = 0, y2 = pFrame->height - 1; y1 < pFrame->height / 2; y1++, y2--) {
BlinkenLib/BlinkenFrame.c  927)     for (x = 0, i = 0; x < pFrame->width; x++) {
BlinkenLib/BlinkenFrame.c  928)       for (c = 0; c < pFrame->channels; c++, i++) {
BlinkenLib/BlinkenFrame.c  929)         unsigned char tmp = pFrame->ppData[y1][i];
BlinkenLib/BlinkenFrame.c  930)         pFrame->ppData[y1][i] = pFrame->ppData[y2][i];
BlinkenLib/BlinkenFrame.c  931)         pFrame->ppData[y2][i] = tmp;
BlinkenLib/BlinkenFrame.c  932)       }
BlinkenLib/BlinkenFrame.c  933)     }
BlinkenLib/BlinkenFrame.c  934)   }
BlinkenLib/BlinkenFrame.c  935) }
BlinkenLib/BlinkenFrame.c  936) 

src/BlinkenFrame.c         937) void BlinkenFrameMirrorDiag(stBlinkenFrame *pFrame) {

BlinkenLib/BlinkenFrame.c  938)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c  939)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c  940) 
BlinkenLib/BlinkenFrame.c  941)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  942)     return;
BlinkenLib/BlinkenFrame.c  943) 
BlinkenLib/BlinkenFrame.c  944)   // allocate new data array
BlinkenLib/BlinkenFrame.c  945)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c  946)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c  947)   channels = pFrame->channels;

src/BlinkenFrame.c         948)   ppData = (unsigned char **)BlinkenMalloc2D(height, width * channels,
src/BlinkenFrame.c         949)                                              sizeof(unsigned char));

BlinkenLib/BlinkenFrame.c  950)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c  951)     return;
BlinkenLib/BlinkenFrame.c  952) 
BlinkenLib/BlinkenFrame.c  953)   // mirror
BlinkenLib/BlinkenFrame.c  954)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c  955)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c  956)       j = y * channels;
BlinkenLib/BlinkenFrame.c  957)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  958)         ppData[y][i] = pFrame->ppData[x][j];
BlinkenLib/BlinkenFrame.c  959)     }
BlinkenLib/BlinkenFrame.c  960)   }
BlinkenLib/BlinkenFrame.c  961) 
BlinkenLib/BlinkenFrame.c  962)   // use new data array
BlinkenLib/BlinkenFrame.c  963)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c  964)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c  965)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c  966)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c  967) }
BlinkenLib/BlinkenFrame.c  968) 

src/BlinkenFrame.c         969) void BlinkenFrameMirrorDiag2(stBlinkenFrame *pFrame) {

BlinkenLib/BlinkenFrame.c  970)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c  971)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c  972) 
BlinkenLib/BlinkenFrame.c  973)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  974)     return;
BlinkenLib/BlinkenFrame.c  975) 
BlinkenLib/BlinkenFrame.c  976)   // allocate new data array
BlinkenLib/BlinkenFrame.c  977)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c  978)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c  979)   channels = pFrame->channels;

src/BlinkenFrame.c         980)   ppData = (unsigned char **)BlinkenMalloc2D(height, width * channels,
src/BlinkenFrame.c         981)                                              sizeof(unsigned char));

BlinkenLib/BlinkenFrame.c  982)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c  983)     return;
BlinkenLib/BlinkenFrame.c  984) 
BlinkenLib/BlinkenFrame.c  985)   // mirror
BlinkenLib/BlinkenFrame.c  986)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c  987)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c  988)       j = (height - 1 - y) * channels;
BlinkenLib/BlinkenFrame.c  989)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  990)         ppData[y][i] = pFrame->ppData[width - 1 - x][j];
BlinkenLib/BlinkenFrame.c  991)     }
BlinkenLib/BlinkenFrame.c  992)   }
BlinkenLib/BlinkenFrame.c  993) 
BlinkenLib/BlinkenFrame.c  994)   // use new data array
BlinkenLib/BlinkenFrame.c  995)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c  996)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c  997)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c  998)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c  999) }
BlinkenLib/BlinkenFrame.c 1000) 

src/BlinkenFrame.c        1001) char *BlinkenFrameToString(stBlinkenFrame *pFrame) {

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

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

BlinkenFrame.c            1004)   unsigned long val;
BlinkenFrame.c            1005) 

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

BlinkenFrame.c            1007)     return NULL;
BlinkenFrame.c            1008) 
BlinkenFrame.c            1009)   size = pFrame->height * (pFrame->width + 1) + 32;
BlinkenFrame.c            1010) 

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

BlinkenFrame.c            1013)     return NULL;
BlinkenFrame.c            1014) 
BlinkenFrame.c            1015)   ptr = str;

BlinkenLib/BlinkenFrame.c 1016) 
BlinkenLib/BlinkenFrame.c 1017)   for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c 1018)     for (x = 0, i = 0; x < pFrame->width; x++) {

BlinkenFrame.c            1019)       val = 0;

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

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

BlinkenFrame.c            1022)       val = val * 7 / pFrame->maxval / pFrame->channels;
BlinkenFrame.c            1023)       *ptr = " -+*%#&@"[val];
BlinkenFrame.c            1024)       ptr++;
BlinkenFrame.c            1025)     }
BlinkenFrame.c            1026)     *ptr = '\n';
BlinkenFrame.c            1027)     ptr++;
BlinkenFrame.c            1028)   }
BlinkenFrame.c            1029) 

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

BlinkenFrame.c            1031) 
BlinkenFrame.c            1032)   return str;
BlinkenFrame.c            1033) }
BlinkenFrame.c            1034) 

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

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

BlinkenFrame.c            1038) {

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

BlinkenFrame.c            1040) 

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

BlinkenFrame.c            1042)     return -1;
BlinkenFrame.c            1043) 

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

BlinkenFrame.c            1045) 

BlinkenLib/BlinkenFrame.c 1046)   case BlinkenProtoNone:
BlinkenLib/BlinkenFrame.c 1047)     return 0;
BlinkenLib/BlinkenFrame.c 1048) 
BlinkenLib/BlinkenFrame.c 1049)   case BlinkenProtoBlp:

BlinkenLib/BlinkenFrame.c 1050)     // buffer too short

src/BlinkenFrame.c        1051)     if (maxLength <
src/BlinkenFrame.c        1052)         (int)sizeof(stBlinkenProtoBlpHdr) + pFrame->height * pFrame->width)

BlinkenLib/BlinkenFrame.c 1053)       return -1;

BlinkenLib/BlinkenFrame.c 1054)     // build header

src/BlinkenFrame.c        1055)     ((stBlinkenProtoBlpHdr *)pData)->magic = htonl(BlinkenProtoBlpMagic);
src/BlinkenFrame.c        1056)     ((stBlinkenProtoBlpHdr *)pData)->frameNo = htonl(0);
src/BlinkenFrame.c        1057)     ((stBlinkenProtoBlpHdr *)pData)->width = htons((uint16_t)pFrame->width);
src/BlinkenFrame.c        1058)     ((stBlinkenProtoBlpHdr *)pData)->height = htons((uint16_t)pFrame->height);
src/BlinkenFrame.c        1059)     i = sizeof(stBlinkenProtoBlpHdr); // put data into packet

BlinkenLib/BlinkenFrame.c 1060)     for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c 1061)       for (x = 0, j = 0; x < pFrame->width; x++, i++) {
BlinkenLib/BlinkenFrame.c 1062)         val = 0;
BlinkenLib/BlinkenFrame.c 1063)         for (c = 0; c < pFrame->channels; c++, j++)
BlinkenLib/BlinkenFrame.c 1064)           val += pFrame->ppData[y][j];
BlinkenLib/BlinkenFrame.c 1065)         pData[i] =

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

BlinkenFrame.c            1067)       }

BlinkenLib/BlinkenFrame.c 1068)     }

src/BlinkenFrame.c        1069)     return i; // return length

BlinkenLib/BlinkenFrame.c 1070) 
BlinkenLib/BlinkenFrame.c 1071)   case BlinkenProtoEblp:

BlinkenLib/BlinkenFrame.c 1072)     // buffer too short

src/BlinkenFrame.c        1073)     if (maxLength <
src/BlinkenFrame.c        1074)         (int)sizeof(stBlinkenProtoEblpHdr) + pFrame->height * pFrame->width)

BlinkenLib/BlinkenFrame.c 1075)       return -1;

BlinkenLib/BlinkenFrame.c 1076)     // build header

src/BlinkenFrame.c        1077)     ((stBlinkenProtoEblpHdr *)pData)->magic = htonl(BlinkenProtoEblpMagic);
src/BlinkenFrame.c        1078)     ((stBlinkenProtoEblpHdr *)pData)->frameNo = htonl(0);
src/BlinkenFrame.c        1079)     ((stBlinkenProtoEblpHdr *)pData)->width = htons((uint16_t)pFrame->width);
src/BlinkenFrame.c        1080)     ((stBlinkenProtoEblpHdr *)pData)->height = htons((uint16_t)pFrame->height);
src/BlinkenFrame.c        1081)     i = sizeof(stBlinkenProtoEblpHdr); // put data into packet

BlinkenLib/BlinkenFrame.c 1082)     for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c 1083)       for (x = 0, j = 0; x < pFrame->width; x++, i++) {
BlinkenLib/BlinkenFrame.c 1084)         val = 0;
BlinkenLib/BlinkenFrame.c 1085)         for (c = 0; c < pFrame->channels; c++, j++)
BlinkenLib/BlinkenFrame.c 1086)           val += pFrame->ppData[y][j];
BlinkenLib/BlinkenFrame.c 1087)         val /= pFrame->channels;

src/BlinkenFrame.c        1088)         pData[i] = (pFrame->maxval == 255
src/BlinkenFrame.c        1089)                         ? (unsigned char)val
src/BlinkenFrame.c        1090)                         : (unsigned char)((val * 255 + pFrame->maxval / 2) /
src/BlinkenFrame.c        1091)                                           pFrame->maxval));

BlinkenFrame.c            1092)       }

BlinkenLib/BlinkenFrame.c 1093)     }

src/BlinkenFrame.c        1094)     return i; // return length

BlinkenLib/BlinkenFrame.c 1095) 
BlinkenLib/BlinkenFrame.c 1096)   case BlinkenProtoMcuf:

BlinkenLib/BlinkenFrame.c 1097)     // buffer too short

src/BlinkenFrame.c        1098)     if (maxLength < (int)sizeof(stBlinkenProtoMcufHdr) +
src/BlinkenFrame.c        1099)                         pFrame->height * pFrame->width * pFrame->channels)

BlinkenFrame.c            1100)       return -1;

BlinkenLib/BlinkenFrame.c 1101)     // build header

src/BlinkenFrame.c        1102)     ((stBlinkenProtoMcufHdr *)pData)->magic = htonl(BlinkenProtoMcufMagic);
src/BlinkenFrame.c        1103)     ((stBlinkenProtoMcufHdr *)pData)->height = htons((uint16_t)pFrame->height);
src/BlinkenFrame.c        1104)     ((stBlinkenProtoMcufHdr *)pData)->width = htons((uint16_t)pFrame->width);
src/BlinkenFrame.c        1105)     ((stBlinkenProtoMcufHdr *)pData)->channels =
src/BlinkenFrame.c        1106)         htons((uint16_t)pFrame->channels);
src/BlinkenFrame.c        1107)     ((stBlinkenProtoMcufHdr *)pData)->maxval = htons((uint16_t)pFrame->maxval);
src/BlinkenFrame.c        1108)     i = sizeof(stBlinkenProtoMcufHdr); // put data into packet

BlinkenLib/BlinkenFrame.c 1109)     for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c 1110)       for (x = 0, j = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c 1111)         for (c = 0; c < pFrame->channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c 1112)           pData[i] = pFrame->ppData[y][j];

src/BlinkenFrame.c        1113)     return i; // return length

BlinkenLib/BlinkenFrame.c 1114) 
BlinkenLib/BlinkenFrame.c 1115)   default:
BlinkenLib/BlinkenFrame.c 1116)     return -1;

BlinkenFrame.c            1117)   }
BlinkenFrame.c            1118) }
BlinkenFrame.c            1119) 

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

src/BlinkenFrame.c        1121)                                         etBlinkenProto *pProto)

BlinkenLib/BlinkenFrame.c 1122) // returns protocol in *pProto if pProto not NULL

BlinkenFrame.c            1123) {

BlinkenLib/BlinkenFrame.c 1124)   stBlinkenFrame *pFrame;

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

BlinkenFrame.c            1126) 

BlinkenLib/BlinkenFrame.c 1127)   if (length >= (int)sizeof(stBlinkenProtoBlpHdr) &&

src/BlinkenFrame.c        1128)       ((stBlinkenProtoBlpHdr *)pData)->magic == htonl(BlinkenProtoBlpMagic)) {

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

BlinkenFrame.c            1130)       *pProto = BlinkenProtoBlp;

BlinkenLib/BlinkenFrame.c 1131)     // get header data

src/BlinkenFrame.c        1132)     height = ntohs(((stBlinkenProtoBlpHdr *)pData)->height);
src/BlinkenFrame.c        1133)     width = ntohs(((stBlinkenProtoBlpHdr *)pData)->width);

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

BlinkenFrame.c            1136)       return NULL;

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

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

BlinkenFrame.c            1140)       return NULL;

src/BlinkenFrame.c        1141)     pFrame = BlinkenFrameNew(height, width, 1, 1, 0); // create frame

BlinkenLib/BlinkenFrame.c 1142)     // according to
BlinkenLib/BlinkenFrame.c 1143)     // header data
BlinkenLib/BlinkenFrame.c 1144)     if (pFrame == NULL)

BlinkenFrame.c            1145)       return NULL;

src/BlinkenFrame.c        1146)     i = sizeof(stBlinkenProtoBlpHdr); // put data into frame

BlinkenLib/BlinkenFrame.c 1147)     for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c 1148)       for (x = 0; x < pFrame->width; x++, i++)

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

BlinkenFrame.c            1150)     return pFrame;
BlinkenFrame.c            1151)   }
BlinkenFrame.c            1152) 

BlinkenLib/BlinkenFrame.c 1153)   if (length >= (int)sizeof(stBlinkenProtoEblpHdr) &&

src/BlinkenFrame.c        1154)       ((stBlinkenProtoEblpHdr *)pData)->magic == htonl(BlinkenProtoEblpMagic)) {

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

BlinkenFrame.c            1156)       *pProto = BlinkenProtoEblp;

BlinkenLib/BlinkenFrame.c 1157)     // get header data

src/BlinkenFrame.c        1158)     height = ntohs(((stBlinkenProtoEblpHdr *)pData)->height);
src/BlinkenFrame.c        1159)     width = ntohs(((stBlinkenProtoEblpHdr *)pData)->width);

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

BlinkenFrame.c            1162)       return NULL;

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

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

BlinkenFrame.c            1166)       return NULL;

BlinkenLib/BlinkenFrame.c 1167)     pFrame = BlinkenFrameNew(height, width, 1, 255, 0); // create frame
BlinkenLib/BlinkenFrame.c 1168)     // according to
BlinkenLib/BlinkenFrame.c 1169)     // header data
BlinkenLib/BlinkenFrame.c 1170)     if (pFrame == NULL)

BlinkenFrame.c            1171)       return NULL;

src/BlinkenFrame.c        1172)     i = sizeof(stBlinkenProtoEblpHdr); // put data into frame

BlinkenLib/BlinkenFrame.c 1173)     for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c 1174)       for (x = 0; x < pFrame->width; x++, i++)

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

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

BlinkenLib/BlinkenFrame.c 1179)   if (length >= (int)sizeof(stBlinkenProtoMcufHdr) &&

src/BlinkenFrame.c        1180)       ((stBlinkenProtoMcufHdr *)pData)->magic == htonl(BlinkenProtoMcufMagic)) {

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

BlinkenFrame.c            1182)       *pProto = BlinkenProtoMcuf;

BlinkenLib/BlinkenFrame.c 1183)     // get header data

src/BlinkenFrame.c        1184)     height = ntohs(((stBlinkenProtoMcufHdr *)pData)->height);
src/BlinkenFrame.c        1185)     width = ntohs(((stBlinkenProtoMcufHdr *)pData)->width);
src/BlinkenFrame.c        1186)     channels = ntohs(((stBlinkenProtoMcufHdr *)pData)->channels);
src/BlinkenFrame.c        1187)     maxval = ntohs(((stBlinkenProtoMcufHdr *)pData)->maxval);

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

BlinkenFrame.c            1190)       return NULL;

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

BlinkenFrame.c            1193)         width < BlinkenWidthMin || width > BlinkenWidthMax ||
BlinkenFrame.c            1194)         channels < BlinkenChannelsMin || channels > BlinkenChannelsMax ||

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

BlinkenFrame.c            1196)       return NULL;

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

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

BlinkenFrame.c            1200)       return NULL;

src/BlinkenFrame.c        1201)     i = sizeof(stBlinkenProtoMcufHdr); // put data into frame

BlinkenLib/BlinkenFrame.c 1202)     for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c 1203)       for (x = 0, j = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c 1204)         for (c = 0; c < pFrame->channels; c++, i++, j++)

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

BlinkenFrame.c            1206)     return pFrame;
BlinkenFrame.c            1207)   }
BlinkenFrame.c            1208) 

src/BlinkenFrame.c        1209)   if (pProto != NULL) // return protocol