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) 

src/BlinkenFrame.c         283) void BlinkenFrameGetPixelData(stBlinkenFrame const *pFrame,
src/BlinkenFrame.c         284)                               int y, int dy, int x, int dx, int c, int dc,
src/BlinkenFrame.c         285)                               unsigned char *pData)
src/BlinkenFrame.c         286) {
src/BlinkenFrame.c         287)   int height, width, channels;
src/BlinkenFrame.c         288)   unsigned char const **ppFrameData;
src/BlinkenFrame.c         289)   int sy, ey, iy, sx, ex, ix, sc, ec, ic; // start/end/index x/y/channel
src/BlinkenFrame.c         290)   int fy, fix, fic; // indexes into frame data
src/BlinkenFrame.c         291)   int biy, bix, bic; // index into caller's data buffer
src/BlinkenFrame.c         292) 
src/BlinkenFrame.c         293)   // no frame -> leave
src/BlinkenFrame.c         294)   if (pFrame == NULL) {
src/BlinkenFrame.c         295)     return;
src/BlinkenFrame.c         296)   }
src/BlinkenFrame.c         297) 
src/BlinkenFrame.c         298)   height = pFrame->height;
src/BlinkenFrame.c         299)   width = pFrame->width;
src/BlinkenFrame.c         300)   channels = pFrame->channels;
src/BlinkenFrame.c         301)   ppFrameData = (unsigned char const **)pFrame->ppData;
src/BlinkenFrame.c         302) 
src/BlinkenFrame.c         303)   // compute start and end for each coordinate
src/BlinkenFrame.c         304)   sy = y < 0 ? -y : 0;
src/BlinkenFrame.c         305)   ey = y + dy > height ? height - y : dy;
src/BlinkenFrame.c         306)   sx = x < 0 ? -x : 0;
src/BlinkenFrame.c         307)   ex = x + dx > width ? width - x : dx;
src/BlinkenFrame.c         308)   sc = c < 0 ? -c : 0;
src/BlinkenFrame.c         309)   ec = c + dc > channels ? channels - c : dc;
src/BlinkenFrame.c         310) 
src/BlinkenFrame.c         311)   // get pixel data
src/BlinkenFrame.c         312)   for (iy = sy, fy = y, biy = (sy * dx + sx) * dc + sc;
src/BlinkenFrame.c         313)        iy < ey; ++iy, ++fy, biy += dx * dc) {
src/BlinkenFrame.c         314)     for (ix = sx, fix = x * channels + c, bix = biy;
src/BlinkenFrame.c         315)          ix < ex; ++ix, fix += channels, bix += dc) {
src/BlinkenFrame.c         316)       for (ic = sc, fic = fix, bic = bix; ic < ec; ++ic, ++fic, ++bic) {
src/BlinkenFrame.c         317)         pData[bic] = ppFrameData[fy][fic];
src/BlinkenFrame.c         318)       }
src/BlinkenFrame.c         319)     }
src/BlinkenFrame.c         320)   }
src/BlinkenFrame.c         321) }
src/BlinkenFrame.c         322) 
src/BlinkenFrame.c         323) void BlinkenFrameSetPixelData(stBlinkenFrame *pFrame,
src/BlinkenFrame.c         324)                               int y, int dy, int x, int dx, int c, int dc,
src/BlinkenFrame.c         325)                               unsigned char const *pData)
src/BlinkenFrame.c         326) {
src/BlinkenFrame.c         327)   int height, width, channels;
src/BlinkenFrame.c         328)   unsigned char maxval;
src/BlinkenFrame.c         329)   unsigned char **ppFrameData;
src/BlinkenFrame.c         330)   int sy, ey, iy, sx, ex, ix, sc, ec, ic; // start/end/index x/y/channel
src/BlinkenFrame.c         331)   int fy, fix, fic; // indexes into frame data
src/BlinkenFrame.c         332)   int biy, bix, bic; // index into caller's data buffer
src/BlinkenFrame.c         333)   unsigned char value;
src/BlinkenFrame.c         334) 
src/BlinkenFrame.c         335)   // no frame -> leave
src/BlinkenFrame.c         336)   if (pFrame == NULL) {
src/BlinkenFrame.c         337)     return;
src/BlinkenFrame.c         338)   }
src/BlinkenFrame.c         339) 
src/BlinkenFrame.c         340)   height = pFrame->height;
src/BlinkenFrame.c         341)   width = pFrame->width;
src/BlinkenFrame.c         342)   channels = pFrame->channels;
src/BlinkenFrame.c         343)   maxval = pFrame->maxval;
src/BlinkenFrame.c         344)   ppFrameData = pFrame->ppData;
src/BlinkenFrame.c         345) 
src/BlinkenFrame.c         346)   // compute start and end for each coordinate
src/BlinkenFrame.c         347)   sy = y < 0 ? -y : 0;
src/BlinkenFrame.c         348)   ey = y + dy > height ? height - y : dy;
src/BlinkenFrame.c         349)   sx = x < 0 ? -x : 0;
src/BlinkenFrame.c         350)   ex = x + dx > width ? width - x : dx;
src/BlinkenFrame.c         351)   sc = c < 0 ? -c : 0;
src/BlinkenFrame.c         352)   ec = c + dc > channels ? channels - c : dc;
src/BlinkenFrame.c         353) 
src/BlinkenFrame.c         354)   // set pixel data
src/BlinkenFrame.c         355)   for (iy = sy, fy = y, biy = (sy * dx + sx) * dc + sc;
src/BlinkenFrame.c         356)        iy < ey; ++iy, ++fy, biy += dx * dc) {
src/BlinkenFrame.c         357)     for (ix = sx, fix = x * channels + c, bix = biy;
src/BlinkenFrame.c         358)          ix < ex; ++ix, fix += channels, bix += dc) {
src/BlinkenFrame.c         359)       for (ic = sc, fic = fix, bic = bix; ic < ec; ++ic, ++fic, ++bic) {
src/BlinkenFrame.c         360)         value = pData[bic];
src/BlinkenFrame.c         361)         ppFrameData[fy][fic] = value > maxval ? maxval : value;
src/BlinkenFrame.c         362)       }
src/BlinkenFrame.c         363)     }
src/BlinkenFrame.c         364)   }
src/BlinkenFrame.c         365) }
src/BlinkenFrame.c         366) 

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

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

BlinkenLib/BlinkenFrame.c  369) {
BlinkenLib/BlinkenFrame.c  370)   int y, x, c, i;
BlinkenLib/BlinkenFrame.c  371) 

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

BlinkenLib/BlinkenFrame.c  373)     return 0;
BlinkenLib/BlinkenFrame.c  374) 

BlinkenLib/BlinkenFrame.c  375)   for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c  376)     for (x = 0, i = 0; x < pFrame->width; x++) {
BlinkenLib/BlinkenFrame.c  377)       for (c = 0; c < pFrame->channels; c++, i++) {
BlinkenLib/BlinkenFrame.c  378)         if (pFrame->ppData[y][i] != 0)
BlinkenLib/BlinkenFrame.c  379)           break;        // pixel is not black -> abort

BlinkenLib/BlinkenFrame.c  380)       }

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

BlinkenLib/BlinkenFrame.c  382)         break;
BlinkenLib/BlinkenFrame.c  383)     }

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

BlinkenLib/BlinkenFrame.c  385)       break;
BlinkenLib/BlinkenFrame.c  386)   }

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

BlinkenLib/BlinkenFrame.c  389)   else

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

BlinkenLib/BlinkenFrame.c  391) }
BlinkenLib/BlinkenFrame.c  392) 

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

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

BlinkenFrame.c             395) {
BlinkenFrame.c             396)   int y, cmp;
BlinkenFrame.c             397) 

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

BlinkenFrame.c             399)     return -1;

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

BlinkenFrame.c             401)     return 1;

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

BlinkenFrame.c             403)     return -1;

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

BlinkenFrame.c             405)     return 1;

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

BlinkenFrame.c             407)     return -1;

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

BlinkenFrame.c             409)     return 1;

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

BlinkenFrame.c             411)     return -1;

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

BlinkenFrame.c             413)     return 1;
BlinkenFrame.c             414) 

BlinkenLib/BlinkenFrame.c  415)   for (y = 0; y < pFrame1->height; y++) {
BlinkenLib/BlinkenFrame.c  416)     cmp =
BlinkenLib/BlinkenFrame.c  417)         memcmp(pFrame1->ppData[y], pFrame2->ppData[y],
BlinkenLib/BlinkenFrame.c  418)                pFrame1->width * pFrame2->channels);
BlinkenLib/BlinkenFrame.c  419)     if (cmp != 0)

BlinkenFrame.c             420)       return cmp;
BlinkenFrame.c             421)   }
BlinkenFrame.c             422) 
BlinkenFrame.c             423)   return 0;
BlinkenFrame.c             424) }
BlinkenFrame.c             425) 

BlinkenLib/BlinkenFrame.c  426) static void BlinkenFramePadCrop(stBlinkenFrame *pFrame, int height, int width,
BlinkenLib/BlinkenFrame.c  427)                                 int channels, int maxval,
BlinkenLib/BlinkenFrame.c  428)                                 int emptyY, int emptyX, int skipY, int skipX)

BlinkenFrame.c             429) {

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

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

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

BlinkenFrame.c             433)   unsigned long val, div;
BlinkenFrame.c             434) 

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

BlinkenFrame.c             436)     return;
BlinkenFrame.c             437) 

BlinkenLib/BlinkenFrame.c  438)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  439)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  440)   if (height > BlinkenHeightMax)
BlinkenLib/BlinkenFrame.c  441)     height = BlinkenHeightMax;
BlinkenLib/BlinkenFrame.c  442)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  443)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  444)   if (width > BlinkenWidthMax)
BlinkenLib/BlinkenFrame.c  445)     width = BlinkenWidthMax;
BlinkenLib/BlinkenFrame.c  446)   if (channels < BlinkenChannelsMin)
BlinkenLib/BlinkenFrame.c  447)     channels = BlinkenChannelsMin;
BlinkenLib/BlinkenFrame.c  448)   if (channels > BlinkenChannelsMax)
BlinkenLib/BlinkenFrame.c  449)     channels = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  450)   if (maxval < BlinkenMaxvalMin)
BlinkenLib/BlinkenFrame.c  451)     maxval = BlinkenMaxvalMin;
BlinkenLib/BlinkenFrame.c  452)   if (maxval > BlinkenMaxvalMax)
BlinkenLib/BlinkenFrame.c  453)     maxval = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  454) 

BlinkenLib/BlinkenFrame.c  455)   if (height == pFrame->height && width == pFrame->width &&
BlinkenLib/BlinkenFrame.c  456)       channels == pFrame->channels && maxval == pFrame->maxval &&
BlinkenLib/BlinkenFrame.c  457)       emptyX == 0 && emptyY == 0 && skipY == 0 && skipX == 0)

BlinkenFrame.c             458)     return;
BlinkenFrame.c             459) 

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

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

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

BlinkenFrame.c             464)     return;

BlinkenLib/BlinkenFrame.c  465)   for (y = 0; y < height; y++)
BlinkenLib/BlinkenFrame.c  466)     for (x = 0, i = 0; x < width; x++)
BlinkenLib/BlinkenFrame.c  467)       for (c = 0; c < channels; c++, i++)

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

BlinkenFrame.c             469) 

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

BlinkenFrame.c             472)     emptyY = 0;

BlinkenLib/BlinkenFrame.c  473)   if (emptyY > height)
BlinkenLib/BlinkenFrame.c  474)     emptyY = height;
BlinkenLib/BlinkenFrame.c  475)   if (emptyX < 0)

BlinkenFrame.c             476)     emptyX = 0;

BlinkenLib/BlinkenFrame.c  477)   if (emptyX > width)
BlinkenLib/BlinkenFrame.c  478)     emptyX = width;
BlinkenLib/BlinkenFrame.c  479)   if (skipY < 0)
BlinkenLib/BlinkenFrame.c  480)     skipY = 0;
BlinkenLib/BlinkenFrame.c  481)   if (skipY > pFrame->height)
BlinkenLib/BlinkenFrame.c  482)     skipY = pFrame->height;
BlinkenLib/BlinkenFrame.c  483)   if (skipX < 0)
BlinkenLib/BlinkenFrame.c  484)     skipX = 0;
BlinkenLib/BlinkenFrame.c  485)   if (skipX > pFrame->width)
BlinkenLib/BlinkenFrame.c  486)     skipX = pFrame->width;
BlinkenLib/BlinkenFrame.c  487)   rangeY = mini(height - emptyY, pFrame->height - skipY);
BlinkenLib/BlinkenFrame.c  488)   rangeX = mini(width - emptyX, pFrame->width - skipX);

BlinkenFrame.c             489) 

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

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

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

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

BlinkenFrame.c             497)       {

BlinkenLib/BlinkenFrame.c  498)         for (c = 0; c < pFrame->channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  499)           ppData[emptyY + y][j] =
BlinkenLib/BlinkenFrame.c  500)               (unsigned
BlinkenLib/BlinkenFrame.c  501)                char)(((unsigned long)pFrame->ppData[skipY + y][i] * maxval +
BlinkenLib/BlinkenFrame.c  502)                       pFrame->maxval / 2) / pFrame->maxval);
BlinkenLib/BlinkenFrame.c  503)         for (; c < channels; c++, j++)

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

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

BlinkenFrame.c             507)       {
BlinkenFrame.c             508)         val = 0;

BlinkenLib/BlinkenFrame.c  509)         for (c = 0; c < channels - 1; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  510)           ppData[emptyY + y][j] =
BlinkenLib/BlinkenFrame.c  511)               (unsigned
BlinkenLib/BlinkenFrame.c  512)                char)(((unsigned long)pFrame->ppData[skipY + y][i] * maxval +
BlinkenLib/BlinkenFrame.c  513)                       pFrame->maxval / 2) / pFrame->maxval);
BlinkenLib/BlinkenFrame.c  514)         for (c = channels - 1; c < pFrame->channels; c++, i++)

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

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

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

BlinkenFrame.c             519)       }
BlinkenFrame.c             520)     }
BlinkenFrame.c             521)   }
BlinkenFrame.c             522) 
BlinkenFrame.c             523)   pFrame->height = height;
BlinkenFrame.c             524)   pFrame->width = width;
BlinkenFrame.c             525)   pFrame->channels = channels;
BlinkenFrame.c             526)   pFrame->maxval = maxval;

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

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

BlinkenFrame.c             529) }
BlinkenFrame.c             530) 

BlinkenLib/BlinkenFrame.c  531) void BlinkenFrameResize(stBlinkenFrame *pFrame, int height, int width,
BlinkenLib/BlinkenFrame.c  532)                         int channels, int maxval)
BlinkenLib/BlinkenFrame.c  533) {
BlinkenLib/BlinkenFrame.c  534)   int emptyY, emptyX, skipY, skipX;
BlinkenLib/BlinkenFrame.c  535) 
BlinkenLib/BlinkenFrame.c  536)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  537)     return;
BlinkenLib/BlinkenFrame.c  538) 
BlinkenLib/BlinkenFrame.c  539)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  540)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  541)   if (height > BlinkenHeightMax)
BlinkenLib/BlinkenFrame.c  542)     height = BlinkenHeightMax;
BlinkenLib/BlinkenFrame.c  543)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  544)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  545)   if (width > BlinkenWidthMax)
BlinkenLib/BlinkenFrame.c  546)     width = BlinkenWidthMax;
BlinkenLib/BlinkenFrame.c  547)   if (channels < BlinkenChannelsMin)
BlinkenLib/BlinkenFrame.c  548)     channels = BlinkenChannelsMin;
BlinkenLib/BlinkenFrame.c  549)   if (channels > BlinkenChannelsMax)
BlinkenLib/BlinkenFrame.c  550)     channels = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  551)   if (maxval < BlinkenMaxvalMin)
BlinkenLib/BlinkenFrame.c  552)     maxval = BlinkenMaxvalMin;
BlinkenLib/BlinkenFrame.c  553)   if (maxval > BlinkenMaxvalMax)
BlinkenLib/BlinkenFrame.c  554)     maxval = BlinkenMaxvalMax;
BlinkenLib/BlinkenFrame.c  555) 
BlinkenLib/BlinkenFrame.c  556)   if (height == pFrame->height && width == pFrame->width &&
BlinkenLib/BlinkenFrame.c  557)       channels == pFrame->channels && maxval == pFrame->maxval)
BlinkenLib/BlinkenFrame.c  558)     return;
BlinkenLib/BlinkenFrame.c  559) 
BlinkenLib/BlinkenFrame.c  560)   // get number of pixels to skip / to leave empty in X and Y direction
BlinkenLib/BlinkenFrame.c  561)   if (height > pFrame->height) {
BlinkenLib/BlinkenFrame.c  562)     emptyY = (height - pFrame->height) / 2;
BlinkenLib/BlinkenFrame.c  563)     skipY = 0;
BlinkenLib/BlinkenFrame.c  564)   } else {
BlinkenLib/BlinkenFrame.c  565)     emptyY = 0;
BlinkenLib/BlinkenFrame.c  566)     skipY = (pFrame->height - height) / 2;
BlinkenLib/BlinkenFrame.c  567)   }
BlinkenLib/BlinkenFrame.c  568)   if (width > pFrame->width) {
BlinkenLib/BlinkenFrame.c  569)     emptyX = (width - pFrame->width) / 2;
BlinkenLib/BlinkenFrame.c  570)     skipX = 0;
BlinkenLib/BlinkenFrame.c  571)   } else {
BlinkenLib/BlinkenFrame.c  572)     emptyX = 0;
BlinkenLib/BlinkenFrame.c  573)     skipX = (pFrame->width - width) / 2;
BlinkenLib/BlinkenFrame.c  574)   }
BlinkenLib/BlinkenFrame.c  575) 
BlinkenLib/BlinkenFrame.c  576)   // resize frame with help of calculated parameters
BlinkenLib/BlinkenFrame.c  577)   BlinkenFramePadCrop(pFrame, height, width, channels, maxval,
BlinkenLib/BlinkenFrame.c  578)                       emptyY, emptyX, skipY, skipX);
BlinkenLib/BlinkenFrame.c  579) }
BlinkenLib/BlinkenFrame.c  580) 
BlinkenLib/BlinkenFrame.c  581) void BlinkenFrameCrop(stBlinkenFrame *pFrame, int top, int left,
BlinkenLib/BlinkenFrame.c  582)                       int height, int width)
BlinkenLib/BlinkenFrame.c  583) {
BlinkenLib/BlinkenFrame.c  584)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  585)     return;
BlinkenLib/BlinkenFrame.c  586) 
BlinkenLib/BlinkenFrame.c  587)   if (top < 0)
BlinkenLib/BlinkenFrame.c  588)     top = 0;
BlinkenLib/BlinkenFrame.c  589)   if (top > pFrame->height - BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  590)     top = pFrame->height - BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  591)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  592)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  593)   if (height > pFrame->height - top)
BlinkenLib/BlinkenFrame.c  594)     height = pFrame->height - top;
BlinkenLib/BlinkenFrame.c  595)   if (left < 0)
BlinkenLib/BlinkenFrame.c  596)     left = 0;
BlinkenLib/BlinkenFrame.c  597)   if (left > pFrame->width - BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  598)     left = pFrame->width - BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  599)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  600)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  601)   if (width > pFrame->width - left)
BlinkenLib/BlinkenFrame.c  602)     width = pFrame->width - left;
BlinkenLib/BlinkenFrame.c  603) 
BlinkenLib/BlinkenFrame.c  604)   if (top == 0 && left == 0 &&
BlinkenLib/BlinkenFrame.c  605)       height == pFrame->height && width == pFrame->width)
BlinkenLib/BlinkenFrame.c  606)     return;
BlinkenLib/BlinkenFrame.c  607) 
BlinkenLib/BlinkenFrame.c  608)   // crop frame with help of calculated parameters
BlinkenLib/BlinkenFrame.c  609)   BlinkenFramePadCrop(pFrame, height, width, pFrame->channels, pFrame->maxval,
BlinkenLib/BlinkenFrame.c  610)                       0, 0, top, left);
BlinkenLib/BlinkenFrame.c  611) }
BlinkenLib/BlinkenFrame.c  612) 

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

BlinkenFrame.c             614) {

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

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

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

BlinkenFrame.c             618) 

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

BlinkenFrame.c             620)     return;
BlinkenFrame.c             621) 

BlinkenLib/BlinkenFrame.c  622)   if (height < BlinkenHeightMin)
BlinkenLib/BlinkenFrame.c  623)     height = BlinkenHeightMin;
BlinkenLib/BlinkenFrame.c  624)   if (height > BlinkenHeightMax)
BlinkenLib/BlinkenFrame.c  625)     height = BlinkenHeightMax;
BlinkenLib/BlinkenFrame.c  626)   if (width < BlinkenWidthMin)
BlinkenLib/BlinkenFrame.c  627)     width = BlinkenWidthMin;
BlinkenLib/BlinkenFrame.c  628)   if (width > BlinkenWidthMax)
BlinkenLib/BlinkenFrame.c  629)     width = BlinkenWidthMax;

BlinkenFrame.c             630) 

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

BlinkenFrame.c             632)     return;
BlinkenFrame.c             633) 
BlinkenFrame.c             634)   scaleHor = (double)width / (double)pFrame->width;
BlinkenFrame.c             635)   scaleVer = (double)height / (double)pFrame->height;
BlinkenFrame.c             636) 

BlinkenLib/BlinkenFrame.c  637)   // allocate new data array
BlinkenLib/BlinkenFrame.c  638)   ppData =

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

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

BlinkenFrame.c             642)     return;
BlinkenFrame.c             643) 

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

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

BlinkenLib/BlinkenFrame.c  646)   for (c = 0; c < chans; c++) {
BlinkenLib/BlinkenFrame.c  647)     for (ny = 0; ny < height; ny++) {
BlinkenLib/BlinkenFrame.c  648)       for (nx = 0; nx < width; nx++) {
BlinkenLib/BlinkenFrame.c  649)         oy = (double)ny / scaleVer;     // sub-pixel exact range in old
BlinkenLib/BlinkenFrame.c  650)         // picture

BlinkenFrame.c             651)         ox = (double)nx / scaleHor;
BlinkenFrame.c             652)         oy1 = (double)(ny + 1) / scaleVer - 0.000001;
BlinkenFrame.c             653)         ox1 = (double)(nx + 1) / scaleHor - 0.000001;

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

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

BlinkenLib/BlinkenFrame.c  657)         else {

BlinkenFrame.c             658)           oyi = (int)oy;
BlinkenFrame.c             659)           oxi = (int)ox;
BlinkenFrame.c             660)           oy1i = (int)oy1;
BlinkenFrame.c             661)           ox1i = (int)ox1;

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

BlinkenFrame.c             664)             {

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

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

BlinkenFrame.c             667)             {

BlinkenLib/BlinkenFrame.c  668)               val =
BlinkenLib/BlinkenFrame.c  669)                   (double)pFrame->ppData[oyi][oxi * chans + c] * (1 - ox +
BlinkenLib/BlinkenFrame.c  670)                                                                   oxi)
BlinkenLib/BlinkenFrame.c  671)                   + (double)pFrame->ppData[oyi][ox1i * chans + c] * (ox1 -
BlinkenLib/BlinkenFrame.c  672)                                                                      ox1i);
BlinkenLib/BlinkenFrame.c  673)               for (x = oxi + 1; x < ox1i; x++)

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

BlinkenFrame.c             675)               val /= ox1 - ox;
BlinkenFrame.c             676)             }

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

BlinkenFrame.c             678)           {

BlinkenLib/BlinkenFrame.c  679)             if (oxi == ox1i) {
BlinkenLib/BlinkenFrame.c  680)               val =
BlinkenLib/BlinkenFrame.c  681)                   (double)pFrame->ppData[oyi][oxi * chans + c] * (1 - oy +
BlinkenLib/BlinkenFrame.c  682)                                                                   oyi)
BlinkenLib/BlinkenFrame.c  683)                   + (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 -
BlinkenLib/BlinkenFrame.c  684)                                                                      oy1i);
BlinkenLib/BlinkenFrame.c  685)               for (y = oyi + 1; y < oy1i; y++)

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

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

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

BlinkenFrame.c             689)             {

BlinkenLib/BlinkenFrame.c  690)               val =
BlinkenLib/BlinkenFrame.c  691)                   (double)pFrame->ppData[oyi][oxi * chans + c] * (1 - oy +
BlinkenLib/BlinkenFrame.c  692)                                                                   oyi) * (1 -
BlinkenLib/BlinkenFrame.c  693)                                                                           ox +
BlinkenLib/BlinkenFrame.c  694)                                                                           oxi)
BlinkenLib/BlinkenFrame.c  695)                   + (double)pFrame->ppData[oyi][ox1i * chans + c] * (1 - oy +
BlinkenLib/BlinkenFrame.c  696)                                                                      oyi) *
BlinkenLib/BlinkenFrame.c  697)                   (ox1 - ox1i)
BlinkenLib/BlinkenFrame.c  698)                   + (double)pFrame->ppData[oy1i][oxi * chans + c] * (oy1 -
BlinkenLib/BlinkenFrame.c  699)                                                                      oy1i) *
BlinkenLib/BlinkenFrame.c  700)                   (1 - ox + oxi)
BlinkenLib/BlinkenFrame.c  701)                   + (double)pFrame->ppData[oy1i][ox1i * chans + c] * (oy1 -
BlinkenLib/BlinkenFrame.c  702)                                                                       oy1i) *
BlinkenLib/BlinkenFrame.c  703)                   (ox1 - ox1i);
BlinkenLib/BlinkenFrame.c  704)               for (y = oyi + 1; y < oy1i; y++) {
BlinkenLib/BlinkenFrame.c  705)                 val +=
BlinkenLib/BlinkenFrame.c  706)                     (double)pFrame->ppData[y][oxi * chans + c] * (1 - ox +
BlinkenLib/BlinkenFrame.c  707)                                                                   oxi)
BlinkenLib/BlinkenFrame.c  708)                     + (double)pFrame->ppData[y][ox1i * chans + c] * (ox1 -
BlinkenLib/BlinkenFrame.c  709)                                                                      ox1i);

BlinkenFrame.c             710)               }

BlinkenLib/BlinkenFrame.c  711)               for (x = oxi + 1; x < ox1i; x++) {
BlinkenLib/BlinkenFrame.c  712)                 val +=
BlinkenLib/BlinkenFrame.c  713)                     (double)pFrame->ppData[oyi][x * chans + c] * (1 - oy +
BlinkenLib/BlinkenFrame.c  714)                                                                   oyi)
BlinkenLib/BlinkenFrame.c  715)                     + (double)pFrame->ppData[oy1i][x * chans + c] * (oy1 -
BlinkenLib/BlinkenFrame.c  716)                                                                      oy1i);

BlinkenFrame.c             717)               }

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

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

BlinkenFrame.c             721)               val /= (oy1 - oy) * (ox1 - ox);
BlinkenFrame.c             722)             }
BlinkenFrame.c             723)           }

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

BlinkenFrame.c             725)         }

BlinkenLib/BlinkenFrame.c  726)       } // for( nx ...
BlinkenLib/BlinkenFrame.c  727)     }   // for( ny ...
BlinkenLib/BlinkenFrame.c  728)   }     // for( c ...

BlinkenFrame.c             729) 
BlinkenFrame.c             730)   pFrame->height = height;
BlinkenFrame.c             731)   pFrame->width = width;

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

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

BlinkenFrame.c             734) }
BlinkenFrame.c             735) 

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

BlinkenLib/BlinkenFrame.c  737)                           int step)

BlinkenFrame.c             738) {

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

BlinkenFrame.c             740)   int y, x, c, i, j;
BlinkenFrame.c             741)   unsigned int val;
BlinkenFrame.c             742) 

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

BlinkenFrame.c             744)     return;
BlinkenFrame.c             745) 

BlinkenLib/BlinkenFrame.c  746)   if (channels < BlinkenChannelsMin)
BlinkenLib/BlinkenFrame.c  747)     channels = BlinkenChannelsMin;
BlinkenLib/BlinkenFrame.c  748)   if (channels > BlinkenChannelsMax)
BlinkenLib/BlinkenFrame.c  749)     channels = BlinkenMaxvalMax;

BlinkenFrame.c             750) 

BlinkenLib/BlinkenFrame.c  751)   // allocate new data array
BlinkenLib/BlinkenFrame.c  752)   ppData =

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

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

BlinkenFrame.c             757)     return;

BlinkenLib/BlinkenFrame.c  758)   for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c  759)     for (x = 0, i = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c  760)       for (c = 0; c < channels; c++, i++)

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

BlinkenLib/BlinkenFrame.c  763)   // colorize frame
BlinkenLib/BlinkenFrame.c  764)   for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c  765)     for (x = 0; x < pFrame->width; x++) {

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

BlinkenLib/BlinkenFrame.c  767)       // merge channels

BlinkenFrame.c             768)       val = 0;

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

BlinkenFrame.c             770)         val += pFrame->ppData[y][i];
BlinkenFrame.c             771)       val = (val + pFrame->channels / 2) / pFrame->channels;
BlinkenFrame.c             772)       val = (val * BlinkenMaxvalMax + pFrame->maxval / 2) / pFrame->maxval;

BlinkenLib/BlinkenFrame.c  773)       // colorize

BlinkenFrame.c             774)       j = x * channels;

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

BlinkenFrame.c             777)         ppData[y][j] = (unsigned char)((val * color + 127) / 255);
BlinkenFrame.c             778)       }
BlinkenFrame.c             779)     }
BlinkenFrame.c             780)   }
BlinkenFrame.c             781) 
BlinkenFrame.c             782)   pFrame->channels = channels;
BlinkenFrame.c             783)   pFrame->maxval = BlinkenMaxvalMax;

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

BlinkenFrame.c             785)   pFrame->ppData = ppData;
BlinkenFrame.c             786) }
BlinkenFrame.c             787) 

BlinkenLib/BlinkenFrame.c  788) void BlinkenFrameCopyRect(stBlinkenFrame *pDest, int destY, int destX,
BlinkenLib/BlinkenFrame.c  789)                           stBlinkenFrame *pSrc, int srcY, int srcX,
BlinkenLib/BlinkenFrame.c  790)                           int height, int width)
BlinkenLib/BlinkenFrame.c  791) {
BlinkenLib/BlinkenFrame.c  792)   int bFreeSrc = 0;
BlinkenLib/BlinkenFrame.c  793)   int destI, srcI, y, x, c, dy, sy, di, si;
BlinkenLib/BlinkenFrame.c  794) 
BlinkenLib/BlinkenFrame.c  795)   if (pDest == NULL || pSrc == NULL)
BlinkenLib/BlinkenFrame.c  796)     return;
BlinkenLib/BlinkenFrame.c  797) 
BlinkenLib/BlinkenFrame.c  798)   // make sure source frame matches dest frame in channels and maxval
BlinkenLib/BlinkenFrame.c  799)   if (pSrc->channels != pDest->channels || pSrc->maxval != pDest->maxval) {
BlinkenLib/BlinkenFrame.c  800)     pSrc = BlinkenFrameClone(pSrc);
BlinkenLib/BlinkenFrame.c  801)     if (pSrc == NULL)
BlinkenLib/BlinkenFrame.c  802)       return;
BlinkenLib/BlinkenFrame.c  803)     BlinkenFrameResize(pSrc, pSrc->height, pSrc->width,
BlinkenLib/BlinkenFrame.c  804)                        pDest->channels, pDest->maxval);
BlinkenLib/BlinkenFrame.c  805)     bFreeSrc = 1; // source is now a temporary copy that needs to be freed
BlinkenLib/BlinkenFrame.c  806)   }
BlinkenLib/BlinkenFrame.c  807) 
BlinkenLib/BlinkenFrame.c  808)   // correct coordinates
BlinkenLib/BlinkenFrame.c  809)   if (destY < 0) {
BlinkenLib/BlinkenFrame.c  810)     height += destY;
BlinkenLib/BlinkenFrame.c  811)     srcY -= destY;
BlinkenLib/BlinkenFrame.c  812)     destY = 0;
BlinkenLib/BlinkenFrame.c  813)   }
BlinkenLib/BlinkenFrame.c  814)   if (destX < 0) {
BlinkenLib/BlinkenFrame.c  815)     width += destX;
BlinkenLib/BlinkenFrame.c  816)     srcX -= destX;
BlinkenLib/BlinkenFrame.c  817)     destX = 0;
BlinkenLib/BlinkenFrame.c  818)   }
BlinkenLib/BlinkenFrame.c  819)   if (srcY < 0) {
BlinkenLib/BlinkenFrame.c  820)     height += srcY;
BlinkenLib/BlinkenFrame.c  821)     destY -= srcY;
BlinkenLib/BlinkenFrame.c  822)     srcY = 0;
BlinkenLib/BlinkenFrame.c  823)   }
BlinkenLib/BlinkenFrame.c  824)   if (srcX < 0) {
BlinkenLib/BlinkenFrame.c  825)     width += srcX;
BlinkenLib/BlinkenFrame.c  826)     destX -= srcX;
BlinkenLib/BlinkenFrame.c  827)     srcX = 0;
BlinkenLib/BlinkenFrame.c  828)   }
BlinkenLib/BlinkenFrame.c  829)   if (height > pDest->height - destY)
BlinkenLib/BlinkenFrame.c  830)     height = pDest->height - destY;
BlinkenLib/BlinkenFrame.c  831)   if (width > pDest->width - destX)
BlinkenLib/BlinkenFrame.c  832)     width = pDest->width - destX;
BlinkenLib/BlinkenFrame.c  833)   if (height > pSrc->height - srcY)
BlinkenLib/BlinkenFrame.c  834)     height = pSrc->height - srcY;
BlinkenLib/BlinkenFrame.c  835)   if (width > pSrc->width - srcX)
BlinkenLib/BlinkenFrame.c  836)     width = pSrc->width - srcX;
BlinkenLib/BlinkenFrame.c  837)   if (height < 0)
BlinkenLib/BlinkenFrame.c  838)     height = 0;
BlinkenLib/BlinkenFrame.c  839)   if (width < 0)
BlinkenLib/BlinkenFrame.c  840)     width = 0;
BlinkenLib/BlinkenFrame.c  841) 
BlinkenLib/BlinkenFrame.c  842)   // copy rectangular area
BlinkenLib/BlinkenFrame.c  843)   destI = destX * pDest->channels;
BlinkenLib/BlinkenFrame.c  844)   srcI = srcX * pSrc->channels;
BlinkenLib/BlinkenFrame.c  845)   for (y = 0, dy = destY, sy = srcY; y < height; y++, dy++, sy++)
BlinkenLib/BlinkenFrame.c  846)     for (x = 0, di = destI, si = srcI; x < width; x++)
BlinkenLib/BlinkenFrame.c  847)       for (c = 0; c < pDest->channels; c++, di++, si++)
BlinkenLib/BlinkenFrame.c  848)         pDest->ppData[dy][di] = pSrc->ppData[sy][si];
BlinkenLib/BlinkenFrame.c  849) 
BlinkenLib/BlinkenFrame.c  850)   // free source if it is a temporary copy
BlinkenLib/BlinkenFrame.c  851)   if (bFreeSrc)
BlinkenLib/BlinkenFrame.c  852)     BlinkenFrameFree(pSrc);
BlinkenLib/BlinkenFrame.c  853) }
BlinkenLib/BlinkenFrame.c  854) 

BlinkenLib/BlinkenFrame.c  855) void BlinkenFrameRotateCw(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  856) {
BlinkenLib/BlinkenFrame.c  857)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c  858)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c  859) 
BlinkenLib/BlinkenFrame.c  860)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  861)     return;
BlinkenLib/BlinkenFrame.c  862) 
BlinkenLib/BlinkenFrame.c  863)   // allocate new data array
BlinkenLib/BlinkenFrame.c  864)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c  865)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c  866)   channels = pFrame->channels;
BlinkenLib/BlinkenFrame.c  867)   ppData =
BlinkenLib/BlinkenFrame.c  868)       (unsigned char **)BlinkenMalloc2D(height, width * channels,
BlinkenLib/BlinkenFrame.c  869)                                         sizeof(unsigned char));
BlinkenLib/BlinkenFrame.c  870)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c  871)     return;
BlinkenLib/BlinkenFrame.c  872) 
BlinkenLib/BlinkenFrame.c  873)   // rotate
BlinkenLib/BlinkenFrame.c  874)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c  875)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c  876)       j = y * channels;
BlinkenLib/BlinkenFrame.c  877)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  878)         ppData[y][i] = pFrame->ppData[width - 1 - x][j];
BlinkenLib/BlinkenFrame.c  879)     }
BlinkenLib/BlinkenFrame.c  880)   }
BlinkenLib/BlinkenFrame.c  881) 
BlinkenLib/BlinkenFrame.c  882)   // use new data array
BlinkenLib/BlinkenFrame.c  883)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c  884)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c  885)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c  886)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c  887) }
BlinkenLib/BlinkenFrame.c  888) 
BlinkenLib/BlinkenFrame.c  889) void BlinkenFrameRotateCcw(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  890) {
BlinkenLib/BlinkenFrame.c  891)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c  892)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c  893) 
BlinkenLib/BlinkenFrame.c  894)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  895)     return;
BlinkenLib/BlinkenFrame.c  896) 
BlinkenLib/BlinkenFrame.c  897)   // allocate new data array
BlinkenLib/BlinkenFrame.c  898)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c  899)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c  900)   channels = pFrame->channels;
BlinkenLib/BlinkenFrame.c  901)   ppData =
BlinkenLib/BlinkenFrame.c  902)       (unsigned char **)BlinkenMalloc2D(height, width * channels,
BlinkenLib/BlinkenFrame.c  903)                                         sizeof(unsigned char));
BlinkenLib/BlinkenFrame.c  904)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c  905)     return;
BlinkenLib/BlinkenFrame.c  906) 
BlinkenLib/BlinkenFrame.c  907)   // rotate
BlinkenLib/BlinkenFrame.c  908)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c  909)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c  910)       j = (height - 1 - y) * channels;
BlinkenLib/BlinkenFrame.c  911)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c  912)         ppData[y][i] = pFrame->ppData[x][j];
BlinkenLib/BlinkenFrame.c  913)     }
BlinkenLib/BlinkenFrame.c  914)   }
BlinkenLib/BlinkenFrame.c  915) 
BlinkenLib/BlinkenFrame.c  916)   // use new data array
BlinkenLib/BlinkenFrame.c  917)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c  918)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c  919)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c  920)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c  921) }
BlinkenLib/BlinkenFrame.c  922) 
BlinkenLib/BlinkenFrame.c  923) void BlinkenFrameRotateHalf(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  924) {
BlinkenLib/BlinkenFrame.c  925)   int y1, y2, x1, x2, c, i1, i2;
BlinkenLib/BlinkenFrame.c  926) 
BlinkenLib/BlinkenFrame.c  927)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  928)     return;
BlinkenLib/BlinkenFrame.c  929) 
BlinkenLib/BlinkenFrame.c  930)   for (y1 = 0, y2 = pFrame->height - 1 ; y1 < pFrame->height; y1++, y2--) {
BlinkenLib/BlinkenFrame.c  931)     for (x1 = 0, x2 = pFrame->width - 1,
BlinkenLib/BlinkenFrame.c  932)          i1 = 0, i2 = (pFrame->width - 1) * pFrame->channels;
BlinkenLib/BlinkenFrame.c  933)          x1 < pFrame->width / 2; x1++, x2--, i2 -= 2 * pFrame->channels) {
BlinkenLib/BlinkenFrame.c  934)       for (c = 0; c < pFrame->channels; c++, i1++, i2++) {
BlinkenLib/BlinkenFrame.c  935)         unsigned char tmp = pFrame->ppData[y1][i1];
BlinkenLib/BlinkenFrame.c  936)         pFrame->ppData[y1][i1] = pFrame->ppData[y2][i2];
BlinkenLib/BlinkenFrame.c  937)         pFrame->ppData[y2][i2] = tmp;
BlinkenLib/BlinkenFrame.c  938)       }
BlinkenLib/BlinkenFrame.c  939)     }
BlinkenLib/BlinkenFrame.c  940)   }
BlinkenLib/BlinkenFrame.c  941) }
BlinkenLib/BlinkenFrame.c  942) 
BlinkenLib/BlinkenFrame.c  943) void BlinkenFrameMirrorHor(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  944) {
BlinkenLib/BlinkenFrame.c  945)   int y, x1, x2, c, i1, i2;
BlinkenLib/BlinkenFrame.c  946) 
BlinkenLib/BlinkenFrame.c  947)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  948)     return;
BlinkenLib/BlinkenFrame.c  949) 
BlinkenLib/BlinkenFrame.c  950)   for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c  951)     for (x1 = 0, x2 = pFrame->width - 1,
BlinkenLib/BlinkenFrame.c  952)          i1 = 0, i2 = (pFrame->width - 1) * pFrame->channels;
BlinkenLib/BlinkenFrame.c  953)          x1 < pFrame->width / 2; x1++, x2--, i2 -= 2 * pFrame->channels) {
BlinkenLib/BlinkenFrame.c  954)       for (c = 0; c < pFrame->channels; c++, i1++, i2++) {
BlinkenLib/BlinkenFrame.c  955)         unsigned char tmp = pFrame->ppData[y][i1];
BlinkenLib/BlinkenFrame.c  956)         pFrame->ppData[y][i1] = pFrame->ppData[y][i2];
BlinkenLib/BlinkenFrame.c  957)         pFrame->ppData[y][i2] = tmp;
BlinkenLib/BlinkenFrame.c  958)       }
BlinkenLib/BlinkenFrame.c  959)     }
BlinkenLib/BlinkenFrame.c  960)   }
BlinkenLib/BlinkenFrame.c  961) }
BlinkenLib/BlinkenFrame.c  962) 
BlinkenLib/BlinkenFrame.c  963) void BlinkenFrameMirrorVer(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  964) {
BlinkenLib/BlinkenFrame.c  965)   int y1, y2, x, c, i;
BlinkenLib/BlinkenFrame.c  966) 
BlinkenLib/BlinkenFrame.c  967)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  968)     return;
BlinkenLib/BlinkenFrame.c  969) 
BlinkenLib/BlinkenFrame.c  970)   for (y1 = 0, y2 = pFrame->height - 1; y1 < pFrame->height / 2; y1++, y2--) {
BlinkenLib/BlinkenFrame.c  971)     for (x = 0, i = 0; x < pFrame->width; x++) {
BlinkenLib/BlinkenFrame.c  972)       for (c = 0; c < pFrame->channels; c++, i++) {
BlinkenLib/BlinkenFrame.c  973)         unsigned char tmp = pFrame->ppData[y1][i];
BlinkenLib/BlinkenFrame.c  974)         pFrame->ppData[y1][i] = pFrame->ppData[y2][i];
BlinkenLib/BlinkenFrame.c  975)         pFrame->ppData[y2][i] = tmp;
BlinkenLib/BlinkenFrame.c  976)       }
BlinkenLib/BlinkenFrame.c  977)     }
BlinkenLib/BlinkenFrame.c  978)   }
BlinkenLib/BlinkenFrame.c  979) }
BlinkenLib/BlinkenFrame.c  980) 
BlinkenLib/BlinkenFrame.c  981) void BlinkenFrameMirrorDiag(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c  982) {
BlinkenLib/BlinkenFrame.c  983)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c  984)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c  985) 
BlinkenLib/BlinkenFrame.c  986)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c  987)     return;
BlinkenLib/BlinkenFrame.c  988) 
BlinkenLib/BlinkenFrame.c  989)   // allocate new data array
BlinkenLib/BlinkenFrame.c  990)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c  991)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c  992)   channels = pFrame->channels;
BlinkenLib/BlinkenFrame.c  993)   ppData =
BlinkenLib/BlinkenFrame.c  994)       (unsigned char **)BlinkenMalloc2D(height, width * channels,
BlinkenLib/BlinkenFrame.c  995)                                         sizeof(unsigned char));
BlinkenLib/BlinkenFrame.c  996)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c  997)     return;
BlinkenLib/BlinkenFrame.c  998) 
BlinkenLib/BlinkenFrame.c  999)   // mirror
BlinkenLib/BlinkenFrame.c 1000)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c 1001)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c 1002)       j = y * channels;
BlinkenLib/BlinkenFrame.c 1003)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c 1004)         ppData[y][i] = pFrame->ppData[x][j];
BlinkenLib/BlinkenFrame.c 1005)     }
BlinkenLib/BlinkenFrame.c 1006)   }
BlinkenLib/BlinkenFrame.c 1007) 
BlinkenLib/BlinkenFrame.c 1008)   // use new data array
BlinkenLib/BlinkenFrame.c 1009)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c 1010)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c 1011)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c 1012)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c 1013) }
BlinkenLib/BlinkenFrame.c 1014) 
BlinkenLib/BlinkenFrame.c 1015) void BlinkenFrameMirrorDiag2(stBlinkenFrame *pFrame)
BlinkenLib/BlinkenFrame.c 1016) {
BlinkenLib/BlinkenFrame.c 1017)   int height, width, channels, y, x, c, i, j;
BlinkenLib/BlinkenFrame.c 1018)   unsigned char **ppData;
BlinkenLib/BlinkenFrame.c 1019) 
BlinkenLib/BlinkenFrame.c 1020)   if (pFrame == NULL)
BlinkenLib/BlinkenFrame.c 1021)     return;
BlinkenLib/BlinkenFrame.c 1022) 
BlinkenLib/BlinkenFrame.c 1023)   // allocate new data array
BlinkenLib/BlinkenFrame.c 1024)   height = pFrame->width;
BlinkenLib/BlinkenFrame.c 1025)   width = pFrame->height;
BlinkenLib/BlinkenFrame.c 1026)   channels = pFrame->channels;
BlinkenLib/BlinkenFrame.c 1027)   ppData =
BlinkenLib/BlinkenFrame.c 1028)       (unsigned char **)BlinkenMalloc2D(height, width * channels,
BlinkenLib/BlinkenFrame.c 1029)                                         sizeof(unsigned char));
BlinkenLib/BlinkenFrame.c 1030)   if (ppData == NULL)
BlinkenLib/BlinkenFrame.c 1031)     return;
BlinkenLib/BlinkenFrame.c 1032) 
BlinkenLib/BlinkenFrame.c 1033)   // mirror
BlinkenLib/BlinkenFrame.c 1034)   for (y = 0; y < height; y++) {
BlinkenLib/BlinkenFrame.c 1035)     for (x = 0, i = 0; x < width; x++) {
BlinkenLib/BlinkenFrame.c 1036)       j = (height - 1 - y) * channels;
BlinkenLib/BlinkenFrame.c 1037)       for (c = 0; c < channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c 1038)         ppData[y][i] = pFrame->ppData[width - 1 - x][j];
BlinkenLib/BlinkenFrame.c 1039)     }
BlinkenLib/BlinkenFrame.c 1040)   }
BlinkenLib/BlinkenFrame.c 1041) 
BlinkenLib/BlinkenFrame.c 1042)   // use new data array
BlinkenLib/BlinkenFrame.c 1043)   pFrame->height = height;
BlinkenLib/BlinkenFrame.c 1044)   pFrame->width = width;
BlinkenLib/BlinkenFrame.c 1045)   free(pFrame->ppData);
BlinkenLib/BlinkenFrame.c 1046)   pFrame->ppData = ppData;
BlinkenLib/BlinkenFrame.c 1047) }
BlinkenLib/BlinkenFrame.c 1048) 

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

BlinkenFrame.c            1050) {

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

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

BlinkenFrame.c            1053)   unsigned long val;
BlinkenFrame.c            1054) 

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

BlinkenFrame.c            1056)     return NULL;
BlinkenFrame.c            1057) 
BlinkenFrame.c            1058)   size = pFrame->height * (pFrame->width + 1) + 32;
BlinkenFrame.c            1059) 

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

BlinkenFrame.c            1062)     return NULL;
BlinkenFrame.c            1063) 
BlinkenFrame.c            1064)   ptr = str;

BlinkenLib/BlinkenFrame.c 1065) 
BlinkenLib/BlinkenFrame.c 1066)   for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c 1067)     for (x = 0, i = 0; x < pFrame->width; x++) {

BlinkenFrame.c            1068)       val = 0;

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

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

BlinkenFrame.c            1071)       val = val * 7 / pFrame->maxval / pFrame->channels;
BlinkenFrame.c            1072)       *ptr = " -+*%#&@"[val];
BlinkenFrame.c            1073)       ptr++;
BlinkenFrame.c            1074)     }
BlinkenFrame.c            1075)     *ptr = '\n';
BlinkenFrame.c            1076)     ptr++;
BlinkenFrame.c            1077)   }
BlinkenFrame.c            1078) 

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

BlinkenFrame.c            1080) 
BlinkenFrame.c            1081)   return str;
BlinkenFrame.c            1082) }
BlinkenFrame.c            1083) 

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

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

BlinkenFrame.c            1087) {

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

BlinkenFrame.c            1089) 

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

BlinkenFrame.c            1091)     return -1;
BlinkenFrame.c            1092) 

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

BlinkenFrame.c            1094) 

BlinkenLib/BlinkenFrame.c 1095)   case BlinkenProtoNone:
BlinkenLib/BlinkenFrame.c 1096)     return 0;
BlinkenLib/BlinkenFrame.c 1097) 
BlinkenLib/BlinkenFrame.c 1098)   case BlinkenProtoBlp:

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

BlinkenLib/BlinkenFrame.c 1101)       return -1;

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

BlinkenLib/BlinkenFrame.c 1104)     ((stBlinkenProtoBlpHdr *) pData)->frameNo = htonl(0);
BlinkenLib/BlinkenFrame.c 1105)     ((stBlinkenProtoBlpHdr *) pData)->width = htons((uint16_t) pFrame->width);
BlinkenLib/BlinkenFrame.c 1106)     ((stBlinkenProtoBlpHdr *) pData)->height =
BlinkenLib/BlinkenFrame.c 1107)         htons((uint16_t) pFrame->height);
BlinkenLib/BlinkenFrame.c 1108)     i = sizeof(stBlinkenProtoBlpHdr);   // 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++, i++) {
BlinkenLib/BlinkenFrame.c 1111)         val = 0;
BlinkenLib/BlinkenFrame.c 1112)         for (c = 0; c < pFrame->channels; c++, j++)
BlinkenLib/BlinkenFrame.c 1113)           val += pFrame->ppData[y][j];
BlinkenLib/BlinkenFrame.c 1114)         pData[i] =

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

BlinkenFrame.c            1116)       }

BlinkenLib/BlinkenFrame.c 1117)     }
BlinkenLib/BlinkenFrame.c 1118)     return i;   // return length
BlinkenLib/BlinkenFrame.c 1119) 
BlinkenLib/BlinkenFrame.c 1120)   case BlinkenProtoEblp:

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

BlinkenLib/BlinkenFrame.c 1123)       return -1;

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

BlinkenLib/BlinkenFrame.c 1126)     ((stBlinkenProtoEblpHdr *) pData)->frameNo = htonl(0);
BlinkenLib/BlinkenFrame.c 1127)     ((stBlinkenProtoEblpHdr *) pData)->width =
BlinkenLib/BlinkenFrame.c 1128)         htons((uint16_t) pFrame->width);
BlinkenLib/BlinkenFrame.c 1129)     ((stBlinkenProtoEblpHdr *) pData)->height =
BlinkenLib/BlinkenFrame.c 1130)         htons((uint16_t) pFrame->height);
BlinkenLib/BlinkenFrame.c 1131)     i = sizeof(stBlinkenProtoEblpHdr);  // put data into packet
BlinkenLib/BlinkenFrame.c 1132)     for (y = 0; y < pFrame->height; y++) {
BlinkenLib/BlinkenFrame.c 1133)       for (x = 0, j = 0; x < pFrame->width; x++, i++) {
BlinkenLib/BlinkenFrame.c 1134)         val = 0;
BlinkenLib/BlinkenFrame.c 1135)         for (c = 0; c < pFrame->channels; c++, j++)
BlinkenLib/BlinkenFrame.c 1136)           val += pFrame->ppData[y][j];
BlinkenLib/BlinkenFrame.c 1137)         val /= pFrame->channels;
BlinkenLib/BlinkenFrame.c 1138)         pData[i] = (pFrame->maxval == 255 ? (unsigned char)val
BlinkenLib/BlinkenFrame.c 1139)                     : (unsigned char)((val * 255 + pFrame->maxval / 2) /
BlinkenLib/BlinkenFrame.c 1140)                                       pFrame->maxval));

BlinkenFrame.c            1141)       }

BlinkenLib/BlinkenFrame.c 1142)     }
BlinkenLib/BlinkenFrame.c 1143)     return i;   // return length
BlinkenLib/BlinkenFrame.c 1144) 
BlinkenLib/BlinkenFrame.c 1145)   case BlinkenProtoMcuf:

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

BlinkenFrame.c            1148)       return -1;

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

BlinkenLib/BlinkenFrame.c 1151)     ((stBlinkenProtoMcufHdr *) pData)->height =
BlinkenLib/BlinkenFrame.c 1152)         htons((uint16_t) pFrame->height);
BlinkenLib/BlinkenFrame.c 1153)     ((stBlinkenProtoMcufHdr *) pData)->width =
BlinkenLib/BlinkenFrame.c 1154)         htons((uint16_t) pFrame->width);
BlinkenLib/BlinkenFrame.c 1155)     ((stBlinkenProtoMcufHdr *) pData)->channels =
BlinkenLib/BlinkenFrame.c 1156)         htons((uint16_t) pFrame->channels);
BlinkenLib/BlinkenFrame.c 1157)     ((stBlinkenProtoMcufHdr *) pData)->maxval =
BlinkenLib/BlinkenFrame.c 1158)         htons((uint16_t) pFrame->maxval);
BlinkenLib/BlinkenFrame.c 1159)     i = sizeof(stBlinkenProtoMcufHdr);  // put data into packet
BlinkenLib/BlinkenFrame.c 1160)     for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c 1161)       for (x = 0, j = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c 1162)         for (c = 0; c < pFrame->channels; c++, i++, j++)
BlinkenLib/BlinkenFrame.c 1163)           pData[i] = pFrame->ppData[y][j];
BlinkenLib/BlinkenFrame.c 1164)     return i;   // return length
BlinkenLib/BlinkenFrame.c 1165) 
BlinkenLib/BlinkenFrame.c 1166)   default:
BlinkenLib/BlinkenFrame.c 1167)     return -1;

BlinkenFrame.c            1168) 
BlinkenFrame.c            1169)   }
BlinkenFrame.c            1170) }
BlinkenFrame.c            1171) 

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

BlinkenLib/BlinkenFrame.c 1173)                                         etBlinkenProto * pProto)
BlinkenLib/BlinkenFrame.c 1174) // returns protocol in *pProto if pProto not NULL

BlinkenFrame.c            1175) {

BlinkenLib/BlinkenFrame.c 1176)   stBlinkenFrame *pFrame;

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

BlinkenFrame.c            1178) 

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

BlinkenFrame.c            1181)   {

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

BlinkenFrame.c            1183)       *pProto = BlinkenProtoBlp;

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

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

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

BlinkenFrame.c            1189)       return NULL;

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

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

BlinkenFrame.c            1193)       return NULL;

BlinkenLib/BlinkenFrame.c 1194)     pFrame = BlinkenFrameNew(height, width, 1, 1, 0);   // create frame
BlinkenLib/BlinkenFrame.c 1195)     // according to
BlinkenLib/BlinkenFrame.c 1196)     // header data
BlinkenLib/BlinkenFrame.c 1197)     if (pFrame == NULL)

BlinkenFrame.c            1198)       return NULL;

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

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

BlinkenFrame.c            1203)     return pFrame;
BlinkenFrame.c            1204)   }
BlinkenFrame.c            1205) 

BlinkenLib/BlinkenFrame.c 1206)   if (length >= (int)sizeof(stBlinkenProtoEblpHdr) &&
BlinkenLib/BlinkenFrame.c 1207)       ((stBlinkenProtoEblpHdr *) pData)->magic ==
BlinkenLib/BlinkenFrame.c 1208)       htonl(BlinkenProtoEblpMagic)) {
BlinkenLib/BlinkenFrame.c 1209)     if (pProto != NULL) // return protocol

BlinkenFrame.c            1210)       *pProto = BlinkenProtoEblp;

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

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

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

BlinkenFrame.c            1216)       return NULL;

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

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

BlinkenFrame.c            1220)       return NULL;

BlinkenLib/BlinkenFrame.c 1221)     pFrame = BlinkenFrameNew(height, width, 1, 255, 0); // create frame
BlinkenLib/BlinkenFrame.c 1222)     // according to
BlinkenLib/BlinkenFrame.c 1223)     // header data
BlinkenLib/BlinkenFrame.c 1224)     if (pFrame == NULL)

BlinkenFrame.c            1225)       return NULL;

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

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

BlinkenFrame.c            1230)     return pFrame;
BlinkenFrame.c            1231)   }
BlinkenFrame.c            1232) 

BlinkenLib/BlinkenFrame.c 1233)   if (length >= (int)sizeof(stBlinkenProtoMcufHdr) &&
BlinkenLib/BlinkenFrame.c 1234)       ((stBlinkenProtoMcufHdr *) pData)->magic ==
BlinkenLib/BlinkenFrame.c 1235)       htonl(BlinkenProtoMcufMagic)) {
BlinkenLib/BlinkenFrame.c 1236)     if (pProto != NULL) // return protocol

BlinkenFrame.c            1237)       *pProto = BlinkenProtoMcuf;

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

BlinkenLib/BlinkenFrame.c 1240)     width = ntohs(((stBlinkenProtoMcufHdr *) pData)->width);
BlinkenLib/BlinkenFrame.c 1241)     channels = ntohs(((stBlinkenProtoMcufHdr *) pData)->channels);
BlinkenLib/BlinkenFrame.c 1242)     maxval = ntohs(((stBlinkenProtoMcufHdr *) pData)->maxval);

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

BlinkenFrame.c            1245)       return NULL;

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

BlinkenFrame.c            1248)         width < BlinkenWidthMin || width > BlinkenWidthMax ||
BlinkenFrame.c            1249)         channels < BlinkenChannelsMin || channels > BlinkenChannelsMax ||

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

BlinkenFrame.c            1251)       return NULL;

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

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

BlinkenFrame.c            1255)       return NULL;

BlinkenLib/BlinkenFrame.c 1256)     i = sizeof(stBlinkenProtoMcufHdr);  // put data into frame
BlinkenLib/BlinkenFrame.c 1257)     for (y = 0; y < pFrame->height; y++)
BlinkenLib/BlinkenFrame.c 1258)       for (x = 0, j = 0; x < pFrame->width; x++)
BlinkenLib/BlinkenFrame.c 1259)         for (c = 0; c < pFrame->channels; c++, i++, j++)

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

BlinkenFrame.c            1261)     return pFrame;
BlinkenFrame.c            1262)   }
BlinkenFrame.c            1263) 

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