gd_error_ex: 103| 27|{ 104| 27| va_list args; 105| | 106| 27| va_start(args, format); 107| 27| _gd_error_ex(priority, format, args); 108| | va_end(args); 109| 27|} gdImageCreate: 162| 407|{ 163| 407| int i; 164| 407| gdImagePtr im; 165| | 166| 407| if (overflow2(sx, sy)) { ------------------ | Branch (166:9): [True: 24, False: 383] ------------------ 167| 24| return NULL; 168| 24| } 169| | 170| 383| if (overflow2(sizeof(unsigned char *), sy)) { ------------------ | Branch (170:9): [True: 3, False: 380] ------------------ 171| 3| return NULL; 172| 3| } 173| 380| if (overflow2(sizeof(unsigned char), sx)) { ------------------ | Branch (173:9): [True: 0, False: 380] ------------------ 174| 0| return NULL; 175| 0| } 176| | 177| 380| im = (gdImage *)gdCalloc(1, sizeof(gdImage)); 178| 380| if (!im) { ------------------ | Branch (178:9): [True: 0, False: 380] ------------------ 179| 0| return NULL; 180| 0| } 181| | 182| | /* Row-major ever since gd 1.3 */ 183| 380| im->pixels = (unsigned char **)gdMalloc(sizeof(unsigned char *) * sy); 184| 380| if (!im->pixels) { ------------------ | Branch (184:9): [True: 0, False: 380] ------------------ 185| 0| gdFree(im); 186| 0| return NULL; 187| 0| } 188| | 189| 380| im->polyInts = 0; 190| 380| im->polyAllocated = 0; 191| 380| im->brush = 0; 192| 380| im->tile = 0; 193| 380| im->style = 0; 194| 553k| for (i = 0; (i < sy); i++) { ------------------ | Branch (194:17): [True: 553k, False: 380] ------------------ 195| | /* Row-major ever since gd 1.3 */ 196| 553k| im->pixels[i] = (unsigned char *)gdCalloc(sx, sizeof(unsigned char)); 197| 553k| if (!im->pixels[i]) { ------------------ | Branch (197:13): [True: 0, False: 553k] ------------------ 198| 0| for (--i; i >= 0; i--) { ------------------ | Branch (198:23): [True: 0, False: 0] ------------------ 199| 0| gdFree(im->pixels[i]); 200| 0| } 201| 0| gdFree(im->pixels); 202| 0| gdFree(im); 203| 0| return NULL; 204| 0| } 205| 553k| } 206| 380| im->sx = sx; 207| 380| im->sy = sy; 208| 380| im->colorsTotal = 0; 209| 380| im->transparent = (-1); 210| 380| im->interlace = 0; 211| 380| im->thick = 1; 212| 380| im->AA = 0; 213| 97.6k| for (i = 0; (i < gdMaxColors); i++) { ------------------ | | 117| 97.6k|#define gdMaxColors 256 ------------------ | Branch (213:17): [True: 97.2k, False: 380] ------------------ 214| 97.2k| im->open[i] = 1; 215| 97.2k| im->red[i] = 0; 216| 97.2k| im->green[i] = 0; 217| 97.2k| im->blue[i] = 0; 218| 97.2k| }; 219| 380| im->trueColor = 0; 220| 380| im->tpixels = 0; 221| 380| im->cx1 = 0; 222| 380| im->cy1 = 0; 223| 380| im->cx2 = im->sx - 1; 224| 380| im->cy2 = im->sy - 1; 225| 380| im->res_x = GD_RESOLUTION; ------------------ | | 8517| 380|#define GD_RESOLUTION 96 /* pixels per inch */ ------------------ 226| 380| im->res_y = GD_RESOLUTION; ------------------ | | 8517| 380|#define GD_RESOLUTION 96 /* pixels per inch */ ------------------ 227| | im->interpolation = NULL; 228| 380| im->interpolation_id = GD_BILINEAR_FIXED; 229| 380| return im; 230| 380|} gdImageDestroy: 340| 380|{ 341| 380| int i; 342| 380| if (im->pixels) { ------------------ | Branch (342:9): [True: 380, False: 0] ------------------ 343| 553k| for (i = 0; (i < im->sy); i++) { ------------------ | Branch (343:21): [True: 553k, False: 380] ------------------ 344| 553k| gdFree(im->pixels[i]); 345| 553k| } 346| 380| gdFree(im->pixels); 347| 380| } 348| 380| if (im->tpixels) { ------------------ | Branch (348:9): [True: 0, False: 380] ------------------ 349| 0| for (i = 0; (i < im->sy); i++) { ------------------ | Branch (349:21): [True: 0, False: 0] ------------------ 350| 0| gdFree(im->tpixels[i]); 351| 0| } 352| 0| gdFree(im->tpixels); 353| 0| } 354| 380| if (im->polyInts) { ------------------ | Branch (354:9): [True: 0, False: 380] ------------------ 355| 0| gdFree(im->polyInts); 356| 0| } 357| 380| if (im->style) { ------------------ | Branch (357:9): [True: 0, False: 380] ------------------ 358| 0| gdFree(im->style); 359| 0| } 360| 380| gdFree(im); 361| 380|} gdImageColorTransparent: 644| 15|{ 645| | // Reset ::transparent 646| 15| if (color == -1) { ------------------ | Branch (646:9): [True: 0, False: 15] ------------------ 647| 0| im->transparent = -1; 648| 0| return; 649| 0| } 650| 15| if (color < -1) { ------------------ | Branch (650:9): [True: 0, False: 15] ------------------ 651| 0| return; 652| 0| } 653| | 654| 15| if (im->trueColor) { ------------------ | Branch (654:9): [True: 0, False: 15] ------------------ 655| 0| im->transparent = color; 656| 0| return; 657| 0| } 658| | 659| | // Palette Image 660| 15| if (color >= gdMaxColors) { ------------------ | | 117| 15|#define gdMaxColors 256 ------------------ | Branch (660:9): [True: 0, False: 15] ------------------ 661| 0| return; 662| 0| } 663| 15| if (im->transparent != -1) { ------------------ | Branch (663:9): [True: 0, False: 15] ------------------ 664| 0| im->alpha[im->transparent] = gdAlphaOpaque; ------------------ | | 141| 0|#define gdAlphaOpaque 0 ------------------ 665| 0| } 666| 15| im->alpha[color] = gdAlphaTransparent; ------------------ | | 142| 15|#define gdAlphaTransparent 127 ------------------ 667| 15| im->transparent = color; 668| 15|} gdImageSetPixel: 966| 264k|{ 967| 264k| int p; 968| 264k| switch (color) { 969| 0| case gdStyled: ------------------ | | 616| 0|#define gdStyled (-2) ------------------ | Branch (969:5): [True: 0, False: 264k] ------------------ 970| 0| if (!im->style) { ------------------ | Branch (970:13): [True: 0, False: 0] ------------------ 971| | /* Refuse to draw if no style is set. */ 972| 0| return; 973| 0| } else { 974| 0| p = im->style[im->stylePos++]; 975| 0| } 976| 0| if (p != (gdTransparent)) { ------------------ | | 623| 0|#define gdTransparent (-6) ------------------ | Branch (976:13): [True: 0, False: 0] ------------------ 977| 0| gdImageSetPixel(im, x, y, p); 978| 0| } 979| 0| im->stylePos = im->stylePos % im->styleLength; 980| 0| break; 981| 0| case gdStyledBrushed: ------------------ | | 618| 0|#define gdStyledBrushed (-4) ------------------ | Branch (981:5): [True: 0, False: 264k] ------------------ 982| 0| if (!im->style) { ------------------ | Branch (982:13): [True: 0, False: 0] ------------------ 983| | /* Refuse to draw if no style is set. */ 984| 0| return; 985| 0| } 986| 0| p = im->style[im->stylePos++]; 987| 0| if ((p != gdTransparent) && (p != 0)) { ------------------ | | 623| 0|#define gdTransparent (-6) ------------------ | Branch (987:13): [True: 0, False: 0] | Branch (987:37): [True: 0, False: 0] ------------------ 988| 0| gdImageSetPixel(im, x, y, gdBrushed); ------------------ | | 617| 0|#define gdBrushed (-3) ------------------ 989| 0| } 990| 0| im->stylePos = im->stylePos % im->styleLength; 991| 0| break; 992| 0| case gdBrushed: ------------------ | | 617| 0|#define gdBrushed (-3) ------------------ | Branch (992:5): [True: 0, False: 264k] ------------------ 993| 0| gdImageBrushApply(im, x, y); 994| 0| break; 995| 0| case gdTiled: ------------------ | | 619| 0|#define gdTiled (-5) ------------------ | Branch (995:5): [True: 0, False: 264k] ------------------ 996| 0| gdImageTileApply(im, x, y); 997| 0| break; 998| 0| case gdAntiAliased: ------------------ | | 625| 0|#define gdAntiAliased (-7) ------------------ | Branch (998:5): [True: 0, False: 264k] ------------------ 999| | /* This shouldn't happen (2.0.26) because we just call 1000| | gdImageAALine now, but do something sane. */ 1001| 0| gdImageSetPixel(im, x, y, im->AA_color); 1002| 0| break; 1003| 264k| default: ------------------ | Branch (1003:5): [True: 264k, False: 0] ------------------ 1004| 264k| if (gdImageBoundsSafeMacro(im, x, y)) { ------------------ | | 60| 264k| (!((((y) < (im)->cy1) || ((y) > (im)->cy2)) || (((x) < (im)->cx1) || ((x) > (im)->cx2)))) | | ------------------ | | | Branch (60:9): [True: 0, False: 264k] | | | Branch (60:30): [True: 0, False: 264k] | | | Branch (60:53): [True: 0, False: 264k] | | | Branch (60:74): [True: 0, False: 264k] | | ------------------ ------------------ 1005| 264k| if (im->trueColor) { ------------------ | Branch (1005:17): [True: 0, False: 264k] ------------------ 1006| 0| switch (im->alphaBlendingFlag) { 1007| 0| default: ------------------ | Branch (1007:17): [True: 0, False: 0] ------------------ 1008| 0| case gdEffectReplace: ------------------ | | 225| 0|#define gdEffectReplace 0 ------------------ | Branch (1008:17): [True: 0, False: 0] ------------------ 1009| 0| im->tpixels[y][x] = color; 1010| 0| break; 1011| 0| case gdEffectAlphaBlend: ------------------ | | 226| 0|#define gdEffectAlphaBlend 1 ------------------ | Branch (1011:17): [True: 0, False: 0] ------------------ 1012| 0| case gdEffectNormal: ------------------ | | 227| 0|#define gdEffectNormal 2 ------------------ | Branch (1012:17): [True: 0, False: 0] ------------------ 1013| 0| im->tpixels[y][x] = gdAlphaBlend(im->tpixels[y][x], color); 1014| 0| break; 1015| 0| case gdEffectOverlay: ------------------ | | 228| 0|#define gdEffectOverlay 3 ------------------ | Branch (1015:17): [True: 0, False: 0] ------------------ 1016| 0| im->tpixels[y][x] = gdLayerOverlay(im->tpixels[y][x], color); 1017| 0| break; 1018| 0| case gdEffectMultiply: ------------------ | | 229| 0|#define gdEffectMultiply 4 ------------------ | Branch (1018:17): [True: 0, False: 0] ------------------ 1019| 0| im->tpixels[y][x] = gdLayerMultiply(im->tpixels[y][x], color); 1020| 0| break; 1021| 0| } 1022| 264k| } else { 1023| 264k| im->pixels[y][x] = color; 1024| 264k| } 1025| 264k| } 1026| 264k| break; 1027| 264k| } 1028| 264k|} gd.c:_gd_error_ex: 88| 27|{ 89| 27| if (gd_error_method) { ------------------ | Branch (89:9): [True: 27, False: 0] ------------------ 90| 27| gd_error_method(priority, format, args); 91| 27| } 92| 27|} gd.c:gd_stderr_error: 63| 27|{ 64| 27| switch (priority) { ------------------ | Branch (64:13): [True: 27, False: 0] ------------------ 65| 0| case GD_ERROR: ------------------ | | 37| 0|#define GD_ERROR LOG_ERR ------------------ | Branch (65:5): [True: 0, False: 27] ------------------ 66| 0| fputs("GD Error: ", stderr); 67| 0| break; 68| 27| case GD_WARNING: ------------------ | | 38| 27|#define GD_WARNING LOG_WARNING ------------------ | Branch (68:5): [True: 27, False: 0] ------------------ 69| 27| fputs("GD Warning: ", stderr); 70| 27| break; 71| 0| case GD_NOTICE: ------------------ | | 39| 0|#define GD_NOTICE LOG_NOTICE ------------------ | Branch (71:5): [True: 0, False: 27] ------------------ 72| 0| fputs("GD Notice: ", stderr); 73| 0| break; 74| 0| case GD_INFO: ------------------ | | 40| 0|#define GD_INFO LOG_INFO ------------------ | Branch (74:5): [True: 0, False: 27] ------------------ 75| 0| fputs("GD Info: ", stderr); 76| 0| break; 77| 0| case GD_DEBUG: ------------------ | | 41| 0|#define GD_DEBUG LOG_DEBUG ------------------ | Branch (77:5): [True: 0, False: 27] ------------------ 78| 0| fputs("GD Debug: ", stderr); 79| 0| break; 80| 27| } 81| 27| vfprintf(stderr, format, args); 82| | fflush(stderr); 83| 27|} gdImageCreateFromGifPtr: 968| 739|{ 969| 739| gdImagePtr im; 970| 739| gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); 971| 739| if (!in) { ------------------ | Branch (971:9): [True: 0, False: 739] ------------------ 972| 0| return 0; 973| 0| } 974| 739| im = gdImageCreateFromGifCtx(in); 975| 739| in->gd_free(in); 976| 739| return im; 977| 739|} gdImageCreateFromGifCtx: 980| 739|{ 981| 739| int BitPixel; 982| |#if 0 983| | int ColorResolution; 984| | int Background; 985| | int AspectRatio; 986| |#endif 987| 739| int Transparent = (-1); 988| 739| unsigned char buf[16]; 989| 739| unsigned char c; 990| 739| unsigned char ColorMap[3][MAXCOLORMAPSIZE]; 991| 739| unsigned char localColorMap[3][MAXCOLORMAPSIZE]; 992| 739| int imw, imh, screen_width, screen_height; 993| 739| int useGlobalColormap; 994| 739| int bitPixel, i; 995| | /*1.4//int imageCount = 0; */ 996| | /* 2.0.28: threadsafe storage */ 997| 739| int ZeroDataBlock = FALSE; ------------------ | | 44| 739|#define FALSE 0 ------------------ 998| 739| int haveGlobalColormap; 999| | 1000| 739| gdImagePtr im = 0; 1001| | 1002| 739| memset(ColorMap, 0, 3 * MAXCOLORMAPSIZE); ------------------ | | 41| 739|#define MAXCOLORMAPSIZE 256 ------------------ 1003| 739| memset(localColorMap, 0, 3 * MAXCOLORMAPSIZE); ------------------ | | 41| 739|#define MAXCOLORMAPSIZE 256 ------------------ 1004| | 1005| 739| if (!ReadOK(fd, buf, 6)) { ------------------ | | 57| 739|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1005:9): [True: 4, False: 735] ------------------ 1006| 4| return 0; 1007| 4| } 1008| | 1009| 735| if (strncmp((char *)buf, "GIF", 3) != 0) { ------------------ | Branch (1009:9): [True: 33, False: 702] ------------------ 1010| 33| return 0; 1011| 33| } 1012| | 1013| 702| if (memcmp((char *)buf + 3, "87a", 3) == 0) { ------------------ | Branch (1013:9): [True: 220, False: 482] ------------------ 1014| | /* GIF87a */ 1015| 482| } else if (memcmp((char *)buf + 3, "89a", 3) == 0) { ------------------ | Branch (1015:16): [True: 451, False: 31] ------------------ 1016| | /* GIF89a */ 1017| 451| } else { 1018| 31| return 0; 1019| 31| } 1020| | 1021| 671| if (!ReadOK(fd, buf, 7)) { ------------------ | | 57| 671|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1021:9): [True: 6, False: 665] ------------------ 1022| 6| return 0; 1023| 6| } 1024| | 1025| 665| BitPixel = 2 << (buf[4] & 0x07); 1026| |#if 0 1027| | ColorResolution = (int) (((buf[4]&0x70)>>3)+1); 1028| | Background = buf[5]; 1029| | AspectRatio = buf[6]; 1030| |#endif 1031| 665| screen_width = imw = LM_to_uint(buf[0], buf[1]); ------------------ | | 59| 665|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1032| 665| screen_height = imh = LM_to_uint(buf[2], buf[3]); ------------------ | | 59| 665|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1033| | 1034| 665| haveGlobalColormap = BitSet(buf[4], LOCALCOLORMAP); /* Global Colormap */ ------------------ | | 55| 665|#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) ------------------ 1035| 665| if (haveGlobalColormap) { ------------------ | Branch (1035:9): [True: 23, False: 642] ------------------ 1036| 23| if (ReadColorMap(fd, BitPixel, ColorMap)) { ------------------ | Branch (1036:13): [True: 19, False: 4] ------------------ 1037| 19| return 0; 1038| 19| } 1039| 23| } 1040| | 1041| 4.52M| for (;;) { 1042| 4.52M| int top, left; 1043| 4.52M| int width, height; 1044| | 1045| 4.52M| if (!ReadOK(fd, &c, 1)) { ------------------ | | 57| 4.52M|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1045:13): [True: 195, False: 4.52M] ------------------ 1046| 195| return 0; 1047| 195| } 1048| | 1049| 4.52M| if (c == ';') { /* GIF terminator */ ------------------ | Branch (1049:13): [True: 1, False: 4.52M] ------------------ 1050| 1| goto terminated; 1051| 1| } 1052| | 1053| 4.52M| if (c == '!') { /* Extension */ ------------------ | Branch (1053:13): [True: 21.0k, False: 4.50M] ------------------ 1054| 21.0k| if (!ReadOK(fd, &c, 1)) { ------------------ | | 57| 21.0k|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1054:17): [True: 1, False: 21.0k] ------------------ 1055| 1| return 0; 1056| 1| } 1057| | 1058| 21.0k| DoExtension(fd, c, &Transparent, &ZeroDataBlock); 1059| 21.0k| continue; 1060| 21.0k| } 1061| | 1062| 4.50M| if (c != ',') { /* Not a valid start character */ ------------------ | Branch (1062:13): [True: 4.50M, False: 449] ------------------ 1063| 4.50M| continue; 1064| 4.50M| } 1065| | 1066| | /*1.4//++imageCount; */ 1067| | 1068| 449| if (!ReadOK(fd, buf, 9)) { ------------------ | | 57| 449|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1068:13): [True: 5, False: 444] ------------------ 1069| 5| return 0; 1070| 5| } 1071| | 1072| 444| useGlobalColormap = !BitSet(buf[8], LOCALCOLORMAP); ------------------ | | 55| 444|#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) ------------------ 1073| | 1074| 444| bitPixel = 1 << ((buf[8] & 0x07) + 1); 1075| 444| left = LM_to_uint(buf[0], buf[1]); ------------------ | | 59| 444|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1076| 444| top = LM_to_uint(buf[2], buf[3]); ------------------ | | 59| 444|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1077| 444| width = LM_to_uint(buf[4], buf[5]); ------------------ | | 59| 444|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1078| 444| height = LM_to_uint(buf[6], buf[7]); ------------------ | | 59| 444|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1079| | 1080| 444| if (((left + width) > screen_width) || ((top + height) > screen_height)) { ------------------ | Branch (1080:13): [True: 19, False: 425] | Branch (1080:48): [True: 18, False: 407] ------------------ 1081| 37| if (VERBOSE) { ------------------ | | 37| 37|#define VERBOSE 0 | | ------------------ | | | Branch (37:17): [Folded, False: 37] | | ------------------ ------------------ 1082| 0| printf("Frame is not confined to screen dimension.\n"); 1083| 0| } 1084| 37| return 0; 1085| 37| } 1086| | 1087| 407| if (!(im = gdImageCreate(width, height))) { ------------------ | Branch (1087:13): [True: 27, False: 380] ------------------ 1088| 27| return 0; 1089| 27| } 1090| | 1091| 380| im->interlace = BitSet(buf[8], INTERLACE); ------------------ | | 55| 380|#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) ------------------ 1092| 380| if (!useGlobalColormap) { ------------------ | Branch (1092:13): [True: 27, False: 353] ------------------ 1093| 27| if (ReadColorMap(fd, bitPixel, localColorMap)) { ------------------ | Branch (1093:17): [True: 21, False: 6] ------------------ 1094| 21| gdImageDestroy(im); 1095| 21| return 0; 1096| 21| } 1097| | 1098| | /* Legacy gdImageCreateFromGif* is intentionally tolerant of 1099| | * out-of-palette LZW results and maps them to color 0. The newer 1100| | * iterator API passes the actual color table size and rejects those 1101| | * malformed frames instead. 1102| | */ 1103| 6| if (!ReadImage(im, fd, width, height, localColorMap, 0, BitSet(buf[8], INTERLACE), ------------------ | | 55| 6|#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) ------------------ | Branch (1103:17): [True: 2, False: 4] ------------------ 1104| 6| &ZeroDataBlock)) { 1105| 2| gdImageDestroy(im); 1106| 2| return 0; 1107| 2| } 1108| 353| } else { 1109| 353| if (!haveGlobalColormap) { ------------------ | Branch (1109:17): [True: 351, False: 2] ------------------ 1110| | // Still a valid gif, apply simple default palette as per spec 1111| 351| ColorMap[CM_RED][1] = 0xff; ------------------ | | 46| 351|#define CM_RED 0 ------------------ 1112| 351| ColorMap[CM_GREEN][1] = 0xff; ------------------ | | 47| 351|#define CM_GREEN 1 ------------------ 1113| 351| ColorMap[CM_BLUE][1] = 0xff; ------------------ | | 48| 351|#define CM_BLUE 2 ------------------ 1114| 351| } 1115| | 1116| | /* Keep legacy tolerance here as above; strict validation is used by 1117| | * the animated GIF iterator. 1118| | */ 1119| 353| if (!ReadImage(im, fd, width, height, ColorMap, 0, BitSet(buf[8], INTERLACE), ------------------ | | 55| 353|#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) ------------------ | Branch (1119:17): [True: 16, False: 337] ------------------ 1120| 353| &ZeroDataBlock)) { 1121| 16| gdImageDestroy(im); 1122| 16| return 0; 1123| 16| } 1124| 353| } 1125| | 1126| 341| if (Transparent != (-1)) { ------------------ | Branch (1126:13): [True: 15, False: 326] ------------------ 1127| 15| gdImageColorTransparent(im, Transparent); 1128| 15| } 1129| | 1130| 341| goto terminated; 1131| 380| } 1132| | 1133| 342|terminated: 1134| | /* Terminator before any image was declared! */ 1135| 342| if (!im) { ------------------ | Branch (1135:9): [True: 1, False: 341] ------------------ 1136| 1| return 0; 1137| 1| } 1138| | 1139| | /* Check for open colors at the end, so 1140| | * we can reduce colorsTotal and ultimately 1141| | * BitsPerPixel */ 1142| 71.7k| for (i = im->colorsTotal - 1; i >= 0; i--) { ------------------ | Branch (1142:35): [True: 71.6k, False: 41] ------------------ 1143| 71.6k| if (im->open[i]) { ------------------ | Branch (1143:13): [True: 71.3k, False: 300] ------------------ 1144| 71.3k| im->colorsTotal--; 1145| 71.3k| } else { 1146| 300| break; 1147| 300| } 1148| 71.6k| } 1149| | 1150| 341| if (!im->colorsTotal) { ------------------ | Branch (1150:9): [True: 41, False: 300] ------------------ 1151| 41| gdImageDestroy(im); 1152| 41| return 0; 1153| 41| } 1154| | 1155| 300| return im; 1156| 341|} gd_gif_in.c:GetDataBlock: 1226| 164k|{ 1227| 164k| int rv, i; 1228| | 1229| 164k| rv = GetDataBlock_(fd, buf, ZeroDataBlockP); 1230| | 1231| 164k| if (VERBOSE) { ------------------ | | 37| 164k|#define VERBOSE 0 | | ------------------ | | | Branch (37:17): [Folded, False: 164k] | | ------------------ ------------------ 1232| 0| printf("[GetDataBlock returning %d", rv); 1233| 0| if (rv > 0) { ------------------ | Branch (1233:13): [True: 0, False: 0] ------------------ 1234| 0| printf(":"); 1235| 0| for (i = 0; i < rv; i++) { ------------------ | Branch (1235:25): [True: 0, False: 0] ------------------ 1236| 0| printf(" %02x", buf[i]); 1237| 0| } 1238| 0| } 1239| 0| printf("]\n"); 1240| 0| } 1241| | 1242| 164k| return rv; 1243| 164k|} gd_gif_in.c:GetDataBlock_: 1209| 164k|{ 1210| 164k| unsigned char count; 1211| | 1212| 164k| if (!ReadOK(fd, &count, 1)) { ------------------ | | 57| 164k|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1212:9): [True: 425, False: 163k] ------------------ 1213| 425| return -1; 1214| 425| } 1215| | 1216| 163k| *ZeroDataBlockP = count == 0; 1217| | 1218| 163k| if ((count != 0) && (!ReadOK(fd, buf, count))) { ------------------ | | 57| 139k|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1218:9): [True: 139k, False: 23.6k] | Branch (1218:25): [True: 81, False: 139k] ------------------ 1219| 81| return -1; 1220| 81| } 1221| | 1222| 163k| return count; 1223| 163k|} gd_gif_in.c:ReadColorMap: 1159| 50|{ 1160| 50| int i; 1161| 50| unsigned char rgb[3]; 1162| | 1163| 1.16k| for (i = 0; i < number; ++i) { ------------------ | Branch (1163:17): [True: 1.15k, False: 10] ------------------ 1164| 1.15k| if (!ReadOK(fd, rgb, sizeof(rgb))) { ------------------ | | 57| 1.15k|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1164:13): [True: 40, False: 1.11k] ------------------ 1165| 40| return TRUE; ------------------ | | 43| 40|#define TRUE 1 ------------------ 1166| 40| } 1167| | 1168| 1.11k| buffer[CM_RED][i] = rgb[0]; ------------------ | | 46| 1.11k|#define CM_RED 0 ------------------ 1169| 1.11k| buffer[CM_GREEN][i] = rgb[1]; ------------------ | | 47| 1.11k|#define CM_GREEN 1 ------------------ 1170| 1.11k| buffer[CM_BLUE][i] = rgb[2]; ------------------ | | 48| 1.11k|#define CM_BLUE 2 ------------------ 1171| 1.11k| } 1172| | 1173| 10| return FALSE; ------------------ | | 44| 10|#define FALSE 0 ------------------ 1174| 50|} gd_gif_in.c:DoExtension: 1177| 21.0k|{ 1178| 21.0k| unsigned char buf[256]; 1179| | 1180| 21.0k| switch (label) { 1181| 17.1k| case 0xf9: /* Graphic Control Extension */ ------------------ | Branch (1181:5): [True: 17.1k, False: 3.91k] ------------------ 1182| 17.1k| memset(buf, 0, 4); /* initialize a few bytes in the case the next function fails */ 1183| 17.1k| (void)GetDataBlock(fd, (unsigned char *)buf, ZeroDataBlockP); 1184| |#if 0 1185| | Gif89.disposal = (buf[0] >> 2) & 0x7; 1186| | Gif89.inputFlag = (buf[0] >> 1) & 0x1; 1187| | Gif89.delayTime = LM_to_uint(buf[1], buf[2]); 1188| |#endif 1189| 17.1k| if ((buf[0] & 0x1) != 0) { ------------------ | Branch (1189:13): [True: 11.2k, False: 5.90k] ------------------ 1190| 11.2k| *Transparent = buf[3]; 1191| 11.2k| } 1192| | 1193| 55.3k| while (GetDataBlock(fd, (unsigned char *)buf, ZeroDataBlockP) > 0) ------------------ | Branch (1193:16): [True: 38.1k, False: 17.1k] ------------------ 1194| 38.1k| ; 1195| | 1196| 17.1k| return FALSE; ------------------ | | 44| 17.1k|#define FALSE 0 ------------------ 1197| | 1198| 3.91k| default: ------------------ | Branch (1198:5): [True: 3.91k, False: 17.1k] ------------------ 1199| 3.91k| break; 1200| 21.0k| } 1201| | 1202| 87.3k| while (GetDataBlock(fd, (unsigned char *)buf, ZeroDataBlockP) > 0) ------------------ | Branch (1202:12): [True: 83.4k, False: 3.91k] ------------------ 1203| 83.4k| ; 1204| | 1205| 3.91k| return FALSE; ------------------ | | 44| 3.91k|#define FALSE 0 ------------------ 1206| 21.0k|} gd_gif_in.c:ReadImage: 1473| 359|{ 1474| 359| unsigned char c; 1475| 359| int xpos = 0, ypos = 0, pass = 0; 1476| 359| int v, i; 1477| 359| LZW_STATIC_DATA sd; 1478| | 1479| | /* Initialize the Compression routines */ 1480| 359| if (!ReadOK(fd, &c, 1)) { ------------------ | | 57| 359|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1480:9): [True: 13, False: 346] ------------------ 1481| 13| return 0; 1482| 13| } 1483| | 1484| 346| if (c > MAX_LWZ_BITS) { ------------------ | | 50| 346|#define MAX_LWZ_BITS 12 ------------------ | Branch (1484:9): [True: 5, False: 341] ------------------ 1485| 5| return 0; 1486| 5| } 1487| | 1488| | /* Stash the color map into the image */ 1489| 87.6k| for (i = 0; (i < gdMaxColors); i++) { ------------------ | | 117| 87.6k|#define gdMaxColors 256 ------------------ | Branch (1489:17): [True: 87.2k, False: 341] ------------------ 1490| 87.2k| im->red[i] = cmap[CM_RED][i]; ------------------ | | 46| 87.2k|#define CM_RED 0 ------------------ 1491| 87.2k| im->green[i] = cmap[CM_GREEN][i]; ------------------ | | 47| 87.2k|#define CM_GREEN 1 ------------------ 1492| 87.2k| im->blue[i] = cmap[CM_BLUE][i]; ------------------ | | 48| 87.2k|#define CM_BLUE 2 ------------------ 1493| 87.2k| im->open[i] = 1; 1494| 87.2k| } 1495| | 1496| | /* Many (perhaps most) of these colors will remain marked open. */ 1497| 341| im->colorsTotal = gdMaxColors; ------------------ | | 117| 341|#define gdMaxColors 256 ------------------ 1498| 341| if (LWZReadByte(fd, &sd, TRUE, c, ZeroDataBlockP) < 0) { ------------------ | | 43| 341|#define TRUE 1 ------------------ | Branch (1498:9): [True: 0, False: 341] ------------------ 1499| 0| return 0; 1500| 0| } 1501| | 1502| | /* 1503| | ** If this is an "uninteresting picture" ignore it. 1504| | ** REMOVED For 1.4 1505| | */ 1506| | /*if (ignore) { */ 1507| | /* while (LWZReadByte(fd, &sd, FALSE, c) >= 0) */ 1508| | /* ; */ 1509| | /* return; */ 1510| | /*} */ 1511| | 1512| 265k| while ((v = LWZReadByte(fd, &sd, FALSE, c, ZeroDataBlockP)) >= 0) { ------------------ | | 44| 265k|#define FALSE 0 ------------------ | Branch (1512:12): [True: 264k, False: 329] ------------------ 1513| 264k| if (colorCount > 0 && v >= colorCount) { ------------------ | Branch (1513:13): [True: 0, False: 264k] | Branch (1513:31): [True: 0, False: 0] ------------------ 1514| 0| return 0; 1515| 0| } 1516| 264k| if (v >= gdMaxColors) { ------------------ | | 117| 264k|#define gdMaxColors 256 ------------------ | Branch (1516:13): [True: 79.3k, False: 185k] ------------------ 1517| 79.3k| v = 0; 1518| 79.3k| } 1519| | 1520| | /* This how we recognize which colors are actually used. */ 1521| 264k| if (im->open[v]) { ------------------ | Branch (1521:13): [True: 2.21k, False: 262k] ------------------ 1522| 2.21k| im->open[v] = 0; 1523| 2.21k| } 1524| | 1525| 264k| gdImageSetPixel(im, xpos, ypos, v); 1526| | 1527| 264k| ++xpos; 1528| 264k| if (xpos == len) { ------------------ | Branch (1528:13): [True: 26.5k, False: 238k] ------------------ 1529| 26.5k| xpos = 0; 1530| 26.5k| if (interlace) { ------------------ | Branch (1530:17): [True: 23.3k, False: 3.19k] ------------------ 1531| 23.3k| switch (pass) { ------------------ | Branch (1531:25): [True: 23.3k, False: 0] ------------------ 1532| 8.46k| case 0: ------------------ | Branch (1532:17): [True: 8.46k, False: 14.8k] ------------------ 1533| 12.9k| case 1: ------------------ | Branch (1533:17): [True: 4.44k, False: 18.8k] ------------------ 1534| 12.9k| ypos += 8; 1535| 12.9k| break; 1536| 5.60k| case 2: ------------------ | Branch (1536:17): [True: 5.60k, False: 17.7k] ------------------ 1537| 5.60k| ypos += 4; 1538| 5.60k| break; 1539| 4.81k| case 3: ------------------ | Branch (1539:17): [True: 4.81k, False: 18.5k] ------------------ 1540| 4.81k| ypos += 2; 1541| 4.81k| break; 1542| 23.3k| } 1543| | 1544| 23.3k| if (ypos >= height) { ------------------ | Branch (1544:21): [True: 108, False: 23.2k] ------------------ 1545| 108| ++pass; 1546| 108| switch (pass) { 1547| 43| case 1: ------------------ | Branch (1547:21): [True: 43, False: 65] ------------------ 1548| 43| ypos = 4; 1549| 43| break; 1550| 36| case 2: ------------------ | Branch (1550:21): [True: 36, False: 72] ------------------ 1551| 36| ypos = 2; 1552| 36| break; 1553| 21| case 3: ------------------ | Branch (1553:21): [True: 21, False: 87] ------------------ 1554| 21| ypos = 1; 1555| 21| break; 1556| 8| default: ------------------ | Branch (1556:21): [True: 8, False: 100] ------------------ 1557| 8| goto fini; 1558| 108| } 1559| 108| } 1560| 23.3k| } else { 1561| 3.19k| ++ypos; 1562| 3.19k| } 1563| 26.5k| } 1564| | 1565| 264k| if (ypos >= height) { ------------------ | Branch (1565:13): [True: 4, False: 264k] ------------------ 1566| 4| break; 1567| 4| } 1568| 264k| } 1569| | 1570| 341|fini: 1571| 341| if (LWZReadByte(fd, &sd, FALSE, c, ZeroDataBlockP) >= 0) { ------------------ | | 44| 341|#define FALSE 0 ------------------ | Branch (1571:9): [True: 22, False: 319] ------------------ 1572| | /* Ignore extra */ 1573| 22| } 1574| 341| return 1; 1575| 341|} gd_gif_in.c:LWZReadByte: 1459| 265k|{ 1460| 265k| int rv; 1461| | 1462| 265k| rv = LWZReadByte_(fd, sd, flag, input_code_size, ZeroDataBlockP); 1463| | 1464| 265k| if (VERBOSE) { ------------------ | | 37| 265k|#define VERBOSE 0 | | ------------------ | | | Branch (37:17): [Folded, False: 265k] | | ------------------ ------------------ 1465| 0| printf("[LWZReadByte(,%d,%d) returning %d]\n", flag, input_code_size, rv); 1466| 0| } 1467| | 1468| 265k| return rv; 1469| 265k|} gd_gif_in.c:LWZReadByte_: 1321| 265k|{ 1322| 265k| int code, incode, i; 1323| | 1324| 265k| if (flag) { ------------------ | Branch (1324:9): [True: 341, False: 265k] ------------------ 1325| 341| sd->set_code_size = input_code_size; 1326| 341| sd->code_size = sd->set_code_size + 1; 1327| 341| sd->clear_code = 1 << sd->set_code_size; 1328| 341| sd->end_code = sd->clear_code + 1; 1329| 341| sd->max_code_size = 2 * sd->clear_code; 1330| 341| sd->max_code = sd->clear_code + 2; 1331| | 1332| 341| GetCode(fd, &sd->scd, 0, TRUE, ZeroDataBlockP); ------------------ | | 43| 341|#define TRUE 1 ------------------ 1333| | 1334| 341| sd->fresh = TRUE; ------------------ | | 43| 341|#define TRUE 1 ------------------ 1335| | 1336| 299k| for (i = 0; i < sd->clear_code; ++i) { ------------------ | Branch (1336:21): [True: 299k, False: 341] ------------------ 1337| 299k| sd->table[0][i] = 0; 1338| 299k| sd->table[1][i] = i; 1339| 299k| } 1340| | 1341| 1.09M| for (; i < (1 << MAX_LWZ_BITS); ++i) { ------------------ | | 50| 1.09M|#define MAX_LWZ_BITS 12 ------------------ | Branch (1341:16): [True: 1.09M, False: 341] ------------------ 1342| 1.09M| sd->table[0][i] = sd->table[1][0] = 0; 1343| 1.09M| } 1344| | 1345| 341| sd->sp = sd->stack; 1346| | 1347| 341| return 0; 1348| | 1349| 265k| } else if (sd->fresh) { ------------------ | Branch (1349:16): [True: 341, False: 265k] ------------------ 1350| 341| sd->fresh = FALSE; ------------------ | | 44| 341|#define FALSE 0 ------------------ 1351| | 1352| 819| do { 1353| 819| sd->firstcode = sd->oldcode = 1354| 819| GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP); ------------------ | | 44| 819|#define FALSE 0 ------------------ 1355| 819| } while (sd->firstcode == sd->clear_code); ------------------ | Branch (1355:18): [True: 478, False: 341] ------------------ 1356| | 1357| 341| return sd->firstcode; 1358| 341| } 1359| | 1360| 265k| if (sd->sp > sd->stack) { ------------------ | Branch (1360:9): [True: 155k, False: 109k] ------------------ 1361| 155k| return *--sd->sp; 1362| 155k| } 1363| | 1364| 109k| while ((code = GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP)) >= 0) { ------------------ | | 44| 109k|#define FALSE 0 ------------------ | Branch (1364:12): [True: 108k, False: 534] ------------------ 1365| 108k| if (code == sd->clear_code) { ------------------ | Branch (1365:13): [True: 2.06k, False: 106k] ------------------ 1366| 877k| for (i = 0; i < sd->clear_code; ++i) { ------------------ | Branch (1366:25): [True: 875k, False: 2.06k] ------------------ 1367| 875k| sd->table[0][i] = 0; 1368| 875k| sd->table[1][i] = i; 1369| 875k| } 1370| | 1371| 7.60M| for (; i < (1 << MAX_LWZ_BITS); ++i) { ------------------ | | 50| 7.60M|#define MAX_LWZ_BITS 12 ------------------ | Branch (1371:20): [True: 7.59M, False: 2.06k] ------------------ 1372| 7.59M| sd->table[0][i] = sd->table[1][i] = 0; 1373| 7.59M| } 1374| | 1375| 2.06k| sd->code_size = sd->set_code_size + 1; 1376| 2.06k| sd->max_code_size = 2 * sd->clear_code; 1377| 2.06k| sd->max_code = sd->clear_code + 2; 1378| 2.06k| sd->sp = sd->stack; 1379| 2.06k| sd->firstcode = sd->oldcode = 1380| 2.06k| GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP); ------------------ | | 44| 2.06k|#define FALSE 0 ------------------ 1381| | 1382| 2.06k| return sd->firstcode; 1383| 106k| } else if (code == sd->end_code) { ------------------ | Branch (1383:20): [True: 346, False: 106k] ------------------ 1384| 346| int count; 1385| 346| unsigned char buf[260]; 1386| | 1387| 346| if (*ZeroDataBlockP) { ------------------ | Branch (1387:17): [True: 4, False: 342] ------------------ 1388| 4| return -2; 1389| 4| } 1390| | 1391| 935| while ((count = GetDataBlock(fd, buf, ZeroDataBlockP)) > 0) ------------------ | Branch (1391:20): [True: 593, False: 342] ------------------ 1392| 593| ; 1393| | 1394| 342| if (count != 0) { ------------------ | Branch (1394:17): [True: 33, False: 309] ------------------ 1395| 33| return -2; 1396| 33| } 1397| 342| } 1398| | 1399| 106k| incode = code; 1400| | 1401| 106k| if (sd->sp == (sd->stack + STACK_SIZE)) { ------------------ | | 83| 106k|#define STACK_SIZE ((1 << (MAX_LWZ_BITS)) * 2) | | ------------------ | | | | 50| 106k|#define MAX_LWZ_BITS 12 | | ------------------ ------------------ | Branch (1401:13): [True: 0, False: 106k] ------------------ 1402| | /* Bad compressed data stream */ 1403| 0| return -1; 1404| 0| } 1405| | 1406| 106k| if (code >= sd->max_code) { ------------------ | Branch (1406:13): [True: 30.5k, False: 76.3k] ------------------ 1407| 30.5k| *sd->sp++ = sd->firstcode; 1408| 30.5k| code = sd->oldcode; 1409| 30.5k| } 1410| | 1411| 240k| while (code >= sd->clear_code) { ------------------ | Branch (1411:16): [True: 133k, False: 106k] ------------------ 1412| 133k| if (sd->sp == (sd->stack + STACK_SIZE)) { ------------------ | | 83| 133k|#define STACK_SIZE ((1 << (MAX_LWZ_BITS)) * 2) | | ------------------ | | | | 50| 133k|#define MAX_LWZ_BITS 12 | | ------------------ ------------------ | Branch (1412:17): [True: 1, False: 133k] ------------------ 1413| | /* Bad compressed data stream */ 1414| 1| return -1; 1415| 1| } 1416| 133k| if (code >= (1 << MAX_LWZ_BITS)) { ------------------ | | 50| 133k|#define MAX_LWZ_BITS 12 ------------------ | Branch (1416:17): [True: 5, False: 133k] ------------------ 1417| | /* Corrupted code */ 1418| 5| return -1; 1419| 5| } 1420| | 1421| 133k| *sd->sp++ = sd->table[1][code]; 1422| | 1423| 133k| if (code == sd->table[0][code]) { ------------------ | Branch (1423:17): [True: 8.19k, False: 125k] ------------------ 1424| | /* Oh well */ 1425| 8.19k| } 1426| | 1427| 133k| code = sd->table[0][code]; 1428| 133k| } 1429| 106k| if (code >= (1 << MAX_LWZ_BITS)) { ------------------ | | 50| 106k|#define MAX_LWZ_BITS 12 ------------------ | Branch (1429:13): [True: 0, False: 106k] ------------------ 1430| | /* Corrupted code */ 1431| 0| return -1; 1432| 0| } 1433| | 1434| 106k| *sd->sp++ = sd->firstcode = sd->table[1][code]; 1435| | 1436| 106k| if ((code = sd->max_code) < (1 << MAX_LWZ_BITS)) { ------------------ | | 50| 106k|#define MAX_LWZ_BITS 12 ------------------ | Branch (1436:13): [True: 106k, False: 647] ------------------ 1437| 106k| sd->table[0][code] = sd->oldcode; 1438| 106k| sd->table[1][code] = sd->firstcode; 1439| 106k| ++sd->max_code; 1440| | 1441| 106k| if ((sd->max_code >= sd->max_code_size) && (sd->max_code_size < (1 << MAX_LWZ_BITS))) { ------------------ | | 50| 1.94k|#define MAX_LWZ_BITS 12 ------------------ | Branch (1441:17): [True: 1.94k, False: 104k] | Branch (1441:56): [True: 1.91k, False: 36] ------------------ 1442| 1.91k| sd->max_code_size *= 2; 1443| 1.91k| ++sd->code_size; 1444| 1.91k| } 1445| 106k| } 1446| | 1447| 106k| sd->oldcode = incode; 1448| | 1449| 106k| if (sd->sp > sd->stack) { ------------------ | Branch (1449:13): [True: 106k, False: 0] ------------------ 1450| 106k| return *--sd->sp; 1451| 106k| } 1452| 106k| } 1453| | 1454| 534| return code; 1455| 109k|} gd_gif_in.c:GetCode: 1307| 112k|{ 1308| 112k| int rv; 1309| | 1310| 112k| rv = GetCode_(fd, scd, code_size, flag, ZeroDataBlockP); 1311| | 1312| 112k| if (VERBOSE) { ------------------ | | 37| 112k|#define VERBOSE 0 | | ------------------ | | | Branch (37:17): [Folded, False: 112k] | | ------------------ ------------------ 1313| 0| printf("[GetCode(,%d,%d) returning %d]\n", code_size, flag, rv); 1314| 0| } 1315| | 1316| 112k| return rv; 1317| 112k|} gd_gif_in.c:GetCode_: 1247| 112k|{ 1248| 112k| int i, j, ret; 1249| 112k| int count; 1250| | 1251| 112k| if (flag) { ------------------ | Branch (1251:9): [True: 341, False: 112k] ------------------ 1252| 341| scd->curbit = 0; 1253| 341| scd->lastbit = 0; 1254| 341| scd->last_byte = 2; 1255| 341| scd->done = FALSE; ------------------ | | 44| 341|#define FALSE 0 ------------------ 1256| 341| return 0; 1257| 341| } 1258| | 1259| 112k| if ((scd->curbit + code_size) >= scd->lastbit) { ------------------ | Branch (1259:9): [True: 3.27k, False: 109k] ------------------ 1260| 3.27k| if (scd->done) { ------------------ | Branch (1260:13): [True: 386, False: 2.88k] ------------------ 1261| 386| if (scd->curbit >= scd->lastbit) { ------------------ | Branch (1261:17): [True: 223, False: 163] ------------------ 1262| | /* Oh well */ 1263| 223| } 1264| 386| return -1; 1265| 386| } 1266| | 1267| 2.88k| scd->buf[0] = scd->buf[scd->last_byte - 2]; 1268| 2.88k| scd->buf[1] = scd->buf[scd->last_byte - 1]; 1269| 2.88k| scd->last_byte = 2; 1270| 2.88k| scd->curbit = (scd->curbit - scd->lastbit) + 16; 1271| 2.88k| scd->lastbit = 16; 1272| | 1273| 3.25k| do { 1274| 3.25k| if (scd->last_byte > (CSD_BUF_SIZE - 255)) { ------------------ | | 85| 3.25k|#define CSD_BUF_SIZE 280 ------------------ | Branch (1274:17): [True: 0, False: 3.25k] ------------------ 1275| 0| return -1; 1276| 0| } 1277| | 1278| 3.25k| if ((count = GetDataBlock(fd, &scd->buf[scd->last_byte], ZeroDataBlockP)) <= 0) { ------------------ | Branch (1278:17): [True: 315, False: 2.94k] ------------------ 1279| 315| scd->done = TRUE; ------------------ | | 43| 315|#define TRUE 1 ------------------ 1280| 315| break; 1281| 315| } 1282| | 1283| 2.94k| scd->last_byte += count; 1284| 2.94k| scd->lastbit += count * 8; 1285| 2.94k| } while ((scd->curbit + code_size) > scd->lastbit); ------------------ | Branch (1285:18): [True: 367, False: 2.57k] ------------------ 1286| 2.88k| } 1287| | 1288| 112k| if ((scd->curbit + code_size) > scd->lastbit) { ------------------ | Branch (1288:9): [True: 219, False: 111k] ------------------ 1289| 219| return -1; 1290| 219| } 1291| | 1292| 111k| if ((scd->curbit + code_size - 1) >= (CSD_BUF_SIZE * 8)) { ------------------ | | 85| 111k|#define CSD_BUF_SIZE 280 ------------------ | Branch (1292:9): [True: 0, False: 111k] ------------------ 1293| 0| ret = -1; 1294| 111k| } else { 1295| 111k| ret = 0; 1296| 1.34M| for (i = scd->curbit, j = 0; j < code_size; ++i, ++j) { ------------------ | Branch (1296:38): [True: 1.23M, False: 111k] ------------------ 1297| 1.23M| ret |= ((scd->buf[i / 8] & (1 << (i % 8))) != 0) << j; 1298| 1.23M| } 1299| 111k| } 1300| | 1301| 111k| scd->curbit += code_size; 1302| | 1303| 111k| return ret; 1304| 112k|} gdGetBuf: 189| 4.85M|int gdGetBuf(void *buf, int size, gdIOCtx *ctx) { return (ctx->getBuf)(ctx, buf, size); } gdNewDynamicCtxEx: 81| 739|{ 82| 739| dpIOCtx *ctx; 83| 739| dynamicPtr *dp; 84| | 85| 739| ctx = (dpIOCtx *)gdMalloc(sizeof(dpIOCtx)); 86| 739| if (ctx == NULL) { ------------------ | Branch (86:9): [True: 0, False: 739] ------------------ 87| 0| return NULL; 88| 0| } 89| | 90| 739| dp = newDynamic(initialSize, data, freeOKFlag); 91| 739| if (!dp) { ------------------ | Branch (91:9): [True: 0, False: 739] ------------------ 92| 0| gdFree(ctx); 93| 0| return NULL; 94| 739| }; 95| | 96| 739| ctx->dp = dp; 97| | 98| 739| ctx->ctx.getC = dynamicGetchar; 99| 739| ctx->ctx.putC = dynamicPutchar; 100| | 101| 739| ctx->ctx.getBuf = dynamicGetbuf; 102| 739| ctx->ctx.putBuf = dynamicPutbuf; 103| | 104| 739| ctx->ctx.seek = dynamicSeek; 105| 739| ctx->ctx.tell = dynamicTell; 106| | 107| 739| ctx->ctx.gd_free = gdFreeDynamicCtx; 108| | 109| 739| return (gdIOCtx *)ctx; 110| 739|} gd_io_dp.c:gdFreeDynamicCtx: 146| 739|{ 147| 739| dynamicPtr *dp; 148| 739| dpIOCtx *dctx; 149| | 150| 739| dctx = (dpIOCtx *)ctx; 151| 739| dp = dctx->dp; 152| | 153| 739| gdFree(ctx); 154| | 155| | /* clean up the data block and return it */ 156| | /* 2.0.21: never free memory we don't own */ 157| 739| if ((dp->data != NULL) && (dp->freeOK)) { ------------------ | Branch (157:9): [True: 739, False: 0] | Branch (157:31): [True: 0, False: 739] ------------------ 158| 0| gdFree(dp->data); 159| 0| dp->data = NULL; 160| 0| } 161| | 162| 739| dp->realSize = 0; 163| 739| dp->logicalSize = 0; 164| | 165| 739| gdFree(dp); 166| 739|} gd_io_dp.c:newDynamic: 224| 739|{ 225| 739| dynamicPtr *dp; 226| | 227| 739| dp = (dynamicPtr *)gdMalloc(sizeof(dynamicPtr)); 228| 739| if (dp == NULL) { ------------------ | Branch (228:9): [True: 0, False: 739] ------------------ 229| 0| return NULL; 230| 0| } 231| | 232| 739| if (!allocDynamic(dp, initialSize, data)) { ------------------ | Branch (232:9): [True: 0, False: 739] ------------------ 233| 0| gdFree(dp); 234| 0| return NULL; 235| 0| } 236| | 237| 739| dp->pos = 0; 238| 739| dp->freeOK = freeOKFlag; 239| | 240| 739| return dp; 241| 739|} gd_io_dp.c:allocDynamic: 325| 739|{ 326| 739| if (data == NULL) { ------------------ | Branch (326:9): [True: 0, False: 739] ------------------ 327| 0| dp->logicalSize = 0; 328| 0| dp->dataGood = FALSE; ------------------ | | 29| 0|#define FALSE 0 ------------------ 329| 0| dp->data = gdMalloc(initialSize); 330| 739| } else { 331| 739| dp->logicalSize = initialSize; 332| 739| dp->dataGood = TRUE; ------------------ | | 28| 739|#define TRUE 1 ------------------ 333| 739| dp->data = data; 334| 739| } 335| | 336| 739| if (dp->data != NULL) { ------------------ | Branch (336:9): [True: 739, False: 0] ------------------ 337| 739| dp->realSize = initialSize; 338| 739| dp->dataGood = TRUE; ------------------ | | 28| 739|#define TRUE 1 ------------------ 339| 739| dp->pos = 0; 340| 739| return TRUE; ------------------ | | 28| 739|#define TRUE 1 ------------------ 341| 739| } else { 342| 0| dp->realSize = 0; 343| 0| return FALSE; ------------------ | | 29| 0|#define FALSE 0 ------------------ 344| 0| } 345| 739|} gd_io_dp.c:dynamicGetbuf: 270| 4.85M|{ 271| 4.85M| int rlen, remain; 272| 4.85M| dpIOCtxPtr dctx; 273| 4.85M| dynamicPtr *dp; 274| | 275| 4.85M| dctx = (dpIOCtxPtr)ctx; 276| 4.85M| dp = dctx->dp; 277| | 278| 4.85M| if (dp->pos < 0 || dp->pos >= dp->realSize) { ------------------ | Branch (278:9): [True: 0, False: 4.85M] | Branch (278:24): [True: 733, False: 4.85M] ------------------ 279| 733| return 0; 280| 733| } 281| | 282| 4.85M| remain = dp->logicalSize - dp->pos; 283| 4.85M| if (remain >= len) { ------------------ | Branch (283:9): [True: 4.85M, False: 37] ------------------ 284| 4.85M| rlen = len; 285| 4.85M| } else { 286| 37| if (remain <= 0) { ------------------ | Branch (286:13): [True: 0, False: 37] ------------------ 287| 0| return 0; 288| 0| } 289| | 290| 37| rlen = remain; 291| 37| } 292| | 293| 4.85M| if (dp->pos + rlen > dp->realSize) { ------------------ | Branch (293:9): [True: 0, False: 4.85M] ------------------ 294| 0| rlen = dp->realSize - dp->pos; 295| 0| } 296| | 297| 4.85M| if (rlen < 0) { ------------------ | Branch (297:9): [True: 0, False: 4.85M] ------------------ 298| 0| return 0; 299| 0| } 300| | 301| 4.85M| memcpy(buf, (void *)((char *)dp->data + dp->pos), rlen); 302| 4.85M| dp->pos += rlen; 303| | 304| 4.85M| return rlen; 305| 4.85M|} overflow2: 23| 1.17k|{ 24| 1.17k| if (a <= 0 || b <= 0) { ------------------ | Branch (24:9): [True: 3, False: 1.16k] | Branch (24:19): [True: 1, False: 1.16k] ------------------ 25| 4| gd_error_ex(GD_WARNING, "one parameter to a memory allocation multiplication is " ------------------ | | 38| 4|#define GD_WARNING LOG_WARNING ------------------ 26| 4| "negative or zero, failing operation gracefully\n"); 27| 4| return 1; 28| 4| } 29| 1.16k| if (a > 100000 / b) { ------------------ | Branch (29:9): [True: 23, False: 1.14k] ------------------ 30| 23| gd_error_ex(GD_WARNING, "product of memory allocation multiplication would exceed " ------------------ | | 38| 23|#define GD_WARNING LOG_WARNING ------------------ 31| 23| "100000, failing operation gracefully\n"); 32| 23| return 1; 33| 23| } 34| 1.14k| return 0; 35| 1.16k|} gdCalloc: 66| 553k|void *gdCalloc(size_t nmemb, size_t size) { return calloc(nmemb, size); } gdMalloc: 68| 1.85k|void *gdMalloc(size_t size) { return malloc(size); } gdFree: 100| 555k|BGD_DECLARE(void) gdFree(void *ptr) { free(ptr); } LLVMFuzzerTestOneInput: 23| 739|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { 24| 739| gdImagePtr im = CREATE_IMAGE(FUZZ_GD_FORMAT)(Size, (void*) Data); ------------------ | | 21| 739|#define CREATE_IMAGE(FORMAT) PASTE(FORMAT) | | ------------------ | | | | 20| 739|#define PASTE(x) gdImageCreateFrom ## x ## Ptr | | ------------------ ------------------ 25| 739| if (im) gdImageDestroy(im); ------------------ | Branch (25:9): [True: 300, False: 439] ------------------ 26| 739| return 0; 27| 739|}