gd_error_ex: 103| 26|{ 104| 26| va_list args; 105| | 106| 26| va_start(args, format); 107| 26| _gd_error_ex(priority, format, args); 108| | va_end(args); 109| 26|} gdImageCreate: 162| 428|{ 163| 428| int i; 164| 428| gdImagePtr im; 165| | 166| 428| if (overflow2(sx, sy)) { ------------------ | Branch (166:9): [True: 23, False: 405] ------------------ 167| 23| return NULL; 168| 23| } 169| | 170| 405| if (overflow2(sizeof(unsigned char *), sy)) { ------------------ | Branch (170:9): [True: 3, False: 402] ------------------ 171| 3| return NULL; 172| 3| } 173| 402| if (overflow2(sizeof(unsigned char), sx)) { ------------------ | Branch (173:9): [True: 0, False: 402] ------------------ 174| 0| return NULL; 175| 0| } 176| | 177| 402| im = (gdImage *)gdCalloc(1, sizeof(gdImage)); 178| 402| if (!im) { ------------------ | Branch (178:9): [True: 0, False: 402] ------------------ 179| 0| return NULL; 180| 0| } 181| | 182| | /* Row-major ever since gd 1.3 */ 183| 402| im->pixels = (unsigned char **)gdMalloc(sizeof(unsigned char *) * sy); 184| 402| if (!im->pixels) { ------------------ | Branch (184:9): [True: 0, False: 402] ------------------ 185| 0| gdFree(im); 186| 0| return NULL; 187| 0| } 188| | 189| 402| im->polyInts = 0; 190| 402| im->polyAllocated = 0; 191| 402| im->brush = 0; 192| 402| im->tile = 0; 193| 402| im->style = 0; 194| 606k| for (i = 0; (i < sy); i++) { ------------------ | Branch (194:17): [True: 606k, False: 402] ------------------ 195| | /* Row-major ever since gd 1.3 */ 196| 606k| im->pixels[i] = (unsigned char *)gdCalloc(sx, sizeof(unsigned char)); 197| 606k| if (!im->pixels[i]) { ------------------ | Branch (197:13): [True: 0, False: 606k] ------------------ 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| 606k| } 206| 402| im->sx = sx; 207| 402| im->sy = sy; 208| 402| im->colorsTotal = 0; 209| 402| im->transparent = (-1); 210| 402| im->interlace = 0; 211| 402| im->thick = 1; 212| 402| im->AA = 0; 213| 103k| for (i = 0; (i < gdMaxColors); i++) { ------------------ | | 117| 103k|#define gdMaxColors 256 ------------------ | Branch (213:17): [True: 102k, False: 402] ------------------ 214| 102k| im->open[i] = 1; 215| 102k| im->red[i] = 0; 216| 102k| im->green[i] = 0; 217| 102k| im->blue[i] = 0; 218| 102k| }; 219| 402| im->trueColor = 0; 220| 402| im->tpixels = 0; 221| 402| im->cx1 = 0; 222| 402| im->cy1 = 0; 223| 402| im->cx2 = im->sx - 1; 224| 402| im->cy2 = im->sy - 1; 225| 402| im->res_x = GD_RESOLUTION; ------------------ | | 8517| 402|#define GD_RESOLUTION 96 /* pixels per inch */ ------------------ 226| 402| im->res_y = GD_RESOLUTION; ------------------ | | 8517| 402|#define GD_RESOLUTION 96 /* pixels per inch */ ------------------ 227| | im->interpolation = NULL; 228| 402| im->interpolation_id = GD_BILINEAR_FIXED; 229| 402| return im; 230| 402|} gdImageDestroy: 340| 402|{ 341| 402| int i; 342| 402| if (im->pixels) { ------------------ | Branch (342:9): [True: 402, False: 0] ------------------ 343| 606k| for (i = 0; (i < im->sy); i++) { ------------------ | Branch (343:21): [True: 606k, False: 402] ------------------ 344| 606k| gdFree(im->pixels[i]); 345| 606k| } 346| 402| gdFree(im->pixels); 347| 402| } 348| 402| if (im->tpixels) { ------------------ | Branch (348:9): [True: 0, False: 402] ------------------ 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| 402| if (im->polyInts) { ------------------ | Branch (354:9): [True: 0, False: 402] ------------------ 355| 0| gdFree(im->polyInts); 356| 0| } 357| 402| if (im->style) { ------------------ | Branch (357:9): [True: 0, False: 402] ------------------ 358| 0| gdFree(im->style); 359| 0| } 360| 402| gdFree(im); 361| 402|} gdImageColorTransparent: 644| 16|{ 645| | // Reset ::transparent 646| 16| if (color == -1) { ------------------ | Branch (646:9): [True: 0, False: 16] ------------------ 647| 0| im->transparent = -1; 648| 0| return; 649| 0| } 650| 16| if (color < -1) { ------------------ | Branch (650:9): [True: 0, False: 16] ------------------ 651| 0| return; 652| 0| } 653| | 654| 16| if (im->trueColor) { ------------------ | Branch (654:9): [True: 0, False: 16] ------------------ 655| 0| im->transparent = color; 656| 0| return; 657| 0| } 658| | 659| | // Palette Image 660| 16| if (color >= gdMaxColors) { ------------------ | | 117| 16|#define gdMaxColors 256 ------------------ | Branch (660:9): [True: 0, False: 16] ------------------ 661| 0| return; 662| 0| } 663| 16| if (im->transparent != -1) { ------------------ | Branch (663:9): [True: 0, False: 16] ------------------ 664| 0| im->alpha[im->transparent] = gdAlphaOpaque; ------------------ | | 141| 0|#define gdAlphaOpaque 0 ------------------ 665| 0| } 666| 16| im->alpha[color] = gdAlphaTransparent; ------------------ | | 142| 16|#define gdAlphaTransparent 127 ------------------ 667| 16| im->transparent = color; 668| 16|} gdImageSetPixel: 966| 266k|{ 967| 266k| int p; 968| 266k| switch (color) { 969| 0| case gdStyled: ------------------ | | 616| 0|#define gdStyled (-2) ------------------ | Branch (969:5): [True: 0, False: 266k] ------------------ 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: 266k] ------------------ 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: 266k] ------------------ 993| 0| gdImageBrushApply(im, x, y); 994| 0| break; 995| 0| case gdTiled: ------------------ | | 619| 0|#define gdTiled (-5) ------------------ | Branch (995:5): [True: 0, False: 266k] ------------------ 996| 0| gdImageTileApply(im, x, y); 997| 0| break; 998| 0| case gdAntiAliased: ------------------ | | 625| 0|#define gdAntiAliased (-7) ------------------ | Branch (998:5): [True: 0, False: 266k] ------------------ 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| 266k| default: ------------------ | Branch (1003:5): [True: 266k, False: 0] ------------------ 1004| 266k| if (gdImageBoundsSafeMacro(im, x, y)) { ------------------ | | 60| 266k| (!((((y) < (im)->cy1) || ((y) > (im)->cy2)) || (((x) < (im)->cx1) || ((x) > (im)->cx2)))) | | ------------------ | | | Branch (60:9): [True: 0, False: 266k] | | | Branch (60:30): [True: 0, False: 266k] | | | Branch (60:53): [True: 0, False: 266k] | | | Branch (60:74): [True: 0, False: 266k] | | ------------------ ------------------ 1005| 266k| if (im->trueColor) { ------------------ | Branch (1005:17): [True: 0, False: 266k] ------------------ 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| 266k| } else { 1023| 266k| im->pixels[y][x] = color; 1024| 266k| } 1025| 266k| } 1026| 266k| break; 1027| 266k| } 1028| 266k|} gd.c:_gd_error_ex: 88| 26|{ 89| 26| if (gd_error_method) { ------------------ | Branch (89:9): [True: 26, False: 0] ------------------ 90| 26| gd_error_method(priority, format, args); 91| 26| } 92| 26|} gd.c:gd_stderr_error: 63| 26|{ 64| 26| switch (priority) { ------------------ | Branch (64:13): [True: 26, False: 0] ------------------ 65| 0| case GD_ERROR: ------------------ | | 37| 0|#define GD_ERROR LOG_ERR ------------------ | Branch (65:5): [True: 0, False: 26] ------------------ 66| 0| fputs("GD Error: ", stderr); 67| 0| break; 68| 26| case GD_WARNING: ------------------ | | 38| 26|#define GD_WARNING LOG_WARNING ------------------ | Branch (68:5): [True: 26, False: 0] ------------------ 69| 26| fputs("GD Warning: ", stderr); 70| 26| break; 71| 0| case GD_NOTICE: ------------------ | | 39| 0|#define GD_NOTICE LOG_NOTICE ------------------ | Branch (71:5): [True: 0, False: 26] ------------------ 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: 26] ------------------ 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: 26] ------------------ 78| 0| fputs("GD Debug: ", stderr); 79| 0| break; 80| 26| } 81| 26| vfprintf(stderr, format, args); 82| | fflush(stderr); 83| 26|} gdImageCreateFromGifPtr: 968| 775|{ 969| 775| gdImagePtr im; 970| 775| gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); 971| 775| if (!in) { ------------------ | Branch (971:9): [True: 0, False: 775] ------------------ 972| 0| return 0; 973| 0| } 974| 775| im = gdImageCreateFromGifCtx(in); 975| 775| in->gd_free(in); 976| 775| return im; 977| 775|} gdImageCreateFromGifCtx: 980| 775|{ 981| 775| int BitPixel; 982| |#if 0 983| | int ColorResolution; 984| | int Background; 985| | int AspectRatio; 986| |#endif 987| 775| int Transparent = (-1); 988| 775| unsigned char buf[16]; 989| 775| unsigned char c; 990| 775| unsigned char ColorMap[3][MAXCOLORMAPSIZE]; 991| 775| unsigned char localColorMap[3][MAXCOLORMAPSIZE]; 992| 775| int imw, imh, screen_width, screen_height; 993| 775| int useGlobalColormap; 994| 775| int bitPixel, i; 995| | /*1.4//int imageCount = 0; */ 996| | /* 2.0.28: threadsafe storage */ 997| 775| int ZeroDataBlock = FALSE; ------------------ | | 44| 775|#define FALSE 0 ------------------ 998| 775| int haveGlobalColormap; 999| | 1000| 775| gdImagePtr im = 0; 1001| | 1002| 775| memset(ColorMap, 0, 3 * MAXCOLORMAPSIZE); ------------------ | | 41| 775|#define MAXCOLORMAPSIZE 256 ------------------ 1003| 775| memset(localColorMap, 0, 3 * MAXCOLORMAPSIZE); ------------------ | | 41| 775|#define MAXCOLORMAPSIZE 256 ------------------ 1004| | 1005| 775| if (!ReadOK(fd, buf, 6)) { ------------------ | | 57| 775|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1005:9): [True: 4, False: 771] ------------------ 1006| 4| return 0; 1007| 4| } 1008| | 1009| 771| if (strncmp((char *)buf, "GIF", 3) != 0) { ------------------ | Branch (1009:9): [True: 33, False: 738] ------------------ 1010| 33| return 0; 1011| 33| } 1012| | 1013| 738| if (memcmp((char *)buf + 3, "87a", 3) == 0) { ------------------ | Branch (1013:9): [True: 249, False: 489] ------------------ 1014| | /* GIF87a */ 1015| 489| } else if (memcmp((char *)buf + 3, "89a", 3) == 0) { ------------------ | Branch (1015:16): [True: 456, False: 33] ------------------ 1016| | /* GIF89a */ 1017| 456| } else { 1018| 33| return 0; 1019| 33| } 1020| | 1021| 705| if (!ReadOK(fd, buf, 7)) { ------------------ | | 57| 705|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1021:9): [True: 6, False: 699] ------------------ 1022| 6| return 0; 1023| 6| } 1024| | 1025| 699| 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| 699| screen_width = imw = LM_to_uint(buf[0], buf[1]); ------------------ | | 59| 699|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1032| 699| screen_height = imh = LM_to_uint(buf[2], buf[3]); ------------------ | | 59| 699|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1033| | 1034| 699| haveGlobalColormap = BitSet(buf[4], LOCALCOLORMAP); /* Global Colormap */ ------------------ | | 55| 699|#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) ------------------ 1035| 699| if (haveGlobalColormap) { ------------------ | Branch (1035:9): [True: 24, False: 675] ------------------ 1036| 24| if (ReadColorMap(fd, BitPixel, ColorMap)) { ------------------ | Branch (1036:13): [True: 21, False: 3] ------------------ 1037| 21| return 0; 1038| 21| } 1039| 24| } 1040| | 1041| 4.70M| for (;;) { 1042| 4.70M| int top, left; 1043| 4.70M| int width, height; 1044| | 1045| 4.70M| if (!ReadOK(fd, &c, 1)) { ------------------ | | 57| 4.70M|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1045:13): [True: 200, False: 4.70M] ------------------ 1046| 200| return 0; 1047| 200| } 1048| | 1049| 4.70M| if (c == ';') { /* GIF terminator */ ------------------ | Branch (1049:13): [True: 3, False: 4.70M] ------------------ 1050| 3| goto terminated; 1051| 3| } 1052| | 1053| 4.70M| if (c == '!') { /* Extension */ ------------------ | Branch (1053:13): [True: 21.6k, False: 4.68M] ------------------ 1054| 21.6k| if (!ReadOK(fd, &c, 1)) { ------------------ | | 57| 21.6k|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1054:17): [True: 2, False: 21.6k] ------------------ 1055| 2| return 0; 1056| 2| } 1057| | 1058| 21.6k| DoExtension(fd, c, &Transparent, &ZeroDataBlock); 1059| 21.6k| continue; 1060| 21.6k| } 1061| | 1062| 4.68M| if (c != ',') { /* Not a valid start character */ ------------------ | Branch (1062:13): [True: 4.68M, False: 473] ------------------ 1063| 4.68M| continue; 1064| 4.68M| } 1065| | 1066| | /*1.4//++imageCount; */ 1067| | 1068| 473| if (!ReadOK(fd, buf, 9)) { ------------------ | | 57| 473|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1068:13): [True: 5, False: 468] ------------------ 1069| 5| return 0; 1070| 5| } 1071| | 1072| 468| useGlobalColormap = !BitSet(buf[8], LOCALCOLORMAP); ------------------ | | 55| 468|#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) ------------------ 1073| | 1074| 468| bitPixel = 1 << ((buf[8] & 0x07) + 1); 1075| 468| left = LM_to_uint(buf[0], buf[1]); ------------------ | | 59| 468|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1076| 468| top = LM_to_uint(buf[2], buf[3]); ------------------ | | 59| 468|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1077| 468| width = LM_to_uint(buf[4], buf[5]); ------------------ | | 59| 468|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1078| 468| height = LM_to_uint(buf[6], buf[7]); ------------------ | | 59| 468|#define LM_to_uint(a, b) (((b) << 8) | (a)) ------------------ 1079| | 1080| 468| if (((left + width) > screen_width) || ((top + height) > screen_height)) { ------------------ | Branch (1080:13): [True: 21, False: 447] | Branch (1080:48): [True: 19, False: 428] ------------------ 1081| 40| if (VERBOSE) { ------------------ | | 37| 40|#define VERBOSE 0 | | ------------------ | | | Branch (37:17): [Folded, False: 40] | | ------------------ ------------------ 1082| 0| printf("Frame is not confined to screen dimension.\n"); 1083| 0| } 1084| 40| return 0; 1085| 40| } 1086| | 1087| 428| if (!(im = gdImageCreate(width, height))) { ------------------ | Branch (1087:13): [True: 26, False: 402] ------------------ 1088| 26| return 0; 1089| 26| } 1090| | 1091| 402| im->interlace = BitSet(buf[8], INTERLACE); ------------------ | | 55| 402|#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) ------------------ 1092| 402| if (!useGlobalColormap) { ------------------ | Branch (1092:13): [True: 21, False: 381] ------------------ 1093| 21| if (ReadColorMap(fd, bitPixel, localColorMap)) { ------------------ | Branch (1093:17): [True: 18, False: 3] ------------------ 1094| 18| gdImageDestroy(im); 1095| 18| return 0; 1096| 18| } 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| 3| if (!ReadImage(im, fd, width, height, localColorMap, 0, BitSet(buf[8], INTERLACE), ------------------ | | 55| 3|#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) ------------------ | Branch (1103:17): [True: 1, False: 2] ------------------ 1104| 3| &ZeroDataBlock)) { 1105| 1| gdImageDestroy(im); 1106| 1| return 0; 1107| 1| } 1108| 381| } else { 1109| 381| if (!haveGlobalColormap) { ------------------ | Branch (1109:17): [True: 380, False: 1] ------------------ 1110| | // Still a valid gif, apply simple default palette as per spec 1111| 380| ColorMap[CM_RED][1] = 0xff; ------------------ | | 46| 380|#define CM_RED 0 ------------------ 1112| 380| ColorMap[CM_GREEN][1] = 0xff; ------------------ | | 47| 380|#define CM_GREEN 1 ------------------ 1113| 380| ColorMap[CM_BLUE][1] = 0xff; ------------------ | | 48| 380|#define CM_BLUE 2 ------------------ 1114| 380| } 1115| | 1116| | /* Keep legacy tolerance here as above; strict validation is used by 1117| | * the animated GIF iterator. 1118| | */ 1119| 381| if (!ReadImage(im, fd, width, height, ColorMap, 0, BitSet(buf[8], INTERLACE), ------------------ | | 55| 381|#define BitSet(byte, bit) (((byte) & (bit)) == (bit)) ------------------ | Branch (1119:17): [True: 26, False: 355] ------------------ 1120| 381| &ZeroDataBlock)) { 1121| 26| gdImageDestroy(im); 1122| 26| return 0; 1123| 26| } 1124| 381| } 1125| | 1126| 357| if (Transparent != (-1)) { ------------------ | Branch (1126:13): [True: 16, False: 341] ------------------ 1127| 16| gdImageColorTransparent(im, Transparent); 1128| 16| } 1129| | 1130| 357| goto terminated; 1131| 402| } 1132| | 1133| 360|terminated: 1134| | /* Terminator before any image was declared! */ 1135| 360| if (!im) { ------------------ | Branch (1135:9): [True: 3, False: 357] ------------------ 1136| 3| return 0; 1137| 3| } 1138| | 1139| | /* Check for open colors at the end, so 1140| | * we can reduce colorsTotal and ultimately 1141| | * BitsPerPixel */ 1142| 75.0k| for (i = im->colorsTotal - 1; i >= 0; i--) { ------------------ | Branch (1142:35): [True: 75.0k, False: 43] ------------------ 1143| 75.0k| if (im->open[i]) { ------------------ | Branch (1143:13): [True: 74.7k, False: 314] ------------------ 1144| 74.7k| im->colorsTotal--; 1145| 74.7k| } else { 1146| 314| break; 1147| 314| } 1148| 75.0k| } 1149| | 1150| 357| if (!im->colorsTotal) { ------------------ | Branch (1150:9): [True: 43, False: 314] ------------------ 1151| 43| gdImageDestroy(im); 1152| 43| return 0; 1153| 43| } 1154| | 1155| 314| return im; 1156| 357|} gd_gif_in.c:GetDataBlock: 1226| 169k|{ 1227| 169k| int rv, i; 1228| | 1229| 169k| rv = GetDataBlock_(fd, buf, ZeroDataBlockP); 1230| | 1231| 169k| if (VERBOSE) { ------------------ | | 37| 169k|#define VERBOSE 0 | | ------------------ | | | Branch (37:17): [Folded, False: 169k] | | ------------------ ------------------ 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| 169k| return rv; 1243| 169k|} gd_gif_in.c:GetDataBlock_: 1209| 169k|{ 1210| 169k| unsigned char count; 1211| | 1212| 169k| if (!ReadOK(fd, &count, 1)) { ------------------ | | 57| 169k|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1212:9): [True: 446, False: 168k] ------------------ 1213| 446| return -1; 1214| 446| } 1215| | 1216| 168k| *ZeroDataBlockP = count == 0; 1217| | 1218| 168k| if ((count != 0) && (!ReadOK(fd, buf, count))) { ------------------ | | 57| 144k|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1218:9): [True: 144k, False: 23.8k] | Branch (1218:25): [True: 82, False: 144k] ------------------ 1219| 82| return -1; 1220| 82| } 1221| | 1222| 168k| return count; 1223| 168k|} gd_gif_in.c:ReadColorMap: 1159| 45|{ 1160| 45| int i; 1161| 45| unsigned char rgb[3]; 1162| | 1163| 509| for (i = 0; i < number; ++i) { ------------------ | Branch (1163:17): [True: 503, False: 6] ------------------ 1164| 503| if (!ReadOK(fd, rgb, sizeof(rgb))) { ------------------ | | 57| 503|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1164:13): [True: 39, False: 464] ------------------ 1165| 39| return TRUE; ------------------ | | 43| 39|#define TRUE 1 ------------------ 1166| 39| } 1167| | 1168| 464| buffer[CM_RED][i] = rgb[0]; ------------------ | | 46| 464|#define CM_RED 0 ------------------ 1169| 464| buffer[CM_GREEN][i] = rgb[1]; ------------------ | | 47| 464|#define CM_GREEN 1 ------------------ 1170| 464| buffer[CM_BLUE][i] = rgb[2]; ------------------ | | 48| 464|#define CM_BLUE 2 ------------------ 1171| 464| } 1172| | 1173| 6| return FALSE; ------------------ | | 44| 6|#define FALSE 0 ------------------ 1174| 45|} gd_gif_in.c:DoExtension: 1177| 21.6k|{ 1178| 21.6k| unsigned char buf[256]; 1179| | 1180| 21.6k| switch (label) { 1181| 17.5k| case 0xf9: /* Graphic Control Extension */ ------------------ | Branch (1181:5): [True: 17.5k, False: 4.05k] ------------------ 1182| 17.5k| memset(buf, 0, 4); /* initialize a few bytes in the case the next function fails */ 1183| 17.5k| (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.5k| if ((buf[0] & 0x1) != 0) { ------------------ | Branch (1189:13): [True: 11.8k, False: 5.76k] ------------------ 1190| 11.8k| *Transparent = buf[3]; 1191| 11.8k| } 1192| | 1193| 57.7k| while (GetDataBlock(fd, (unsigned char *)buf, ZeroDataBlockP) > 0) ------------------ | Branch (1193:16): [True: 40.1k, False: 17.5k] ------------------ 1194| 40.1k| ; 1195| | 1196| 17.5k| return FALSE; ------------------ | | 44| 17.5k|#define FALSE 0 ------------------ 1197| | 1198| 4.05k| default: ------------------ | Branch (1198:5): [True: 4.05k, False: 17.5k] ------------------ 1199| 4.05k| break; 1200| 21.6k| } 1201| | 1202| 90.0k| while (GetDataBlock(fd, (unsigned char *)buf, ZeroDataBlockP) > 0) ------------------ | Branch (1202:12): [True: 85.9k, False: 4.05k] ------------------ 1203| 85.9k| ; 1204| | 1205| 4.05k| return FALSE; ------------------ | | 44| 4.05k|#define FALSE 0 ------------------ 1206| 21.6k|} gd_gif_in.c:ReadImage: 1473| 384|{ 1474| 384| unsigned char c; 1475| 384| int xpos = 0, ypos = 0, pass = 0; 1476| 384| int v, i; 1477| 384| LZW_STATIC_DATA sd; 1478| | 1479| | /* Initialize the Compression routines */ 1480| 384| if (!ReadOK(fd, &c, 1)) { ------------------ | | 57| 384|#define ReadOK(file, buffer, len) (gdGetBuf(buffer, len, file) == len) ------------------ | Branch (1480:9): [True: 20, False: 364] ------------------ 1481| 20| return 0; 1482| 20| } 1483| | 1484| 364| if (c > MAX_LWZ_BITS) { ------------------ | | 50| 364|#define MAX_LWZ_BITS 12 ------------------ | Branch (1484:9): [True: 7, False: 357] ------------------ 1485| 7| return 0; 1486| 7| } 1487| | 1488| | /* Stash the color map into the image */ 1489| 91.7k| for (i = 0; (i < gdMaxColors); i++) { ------------------ | | 117| 91.7k|#define gdMaxColors 256 ------------------ | Branch (1489:17): [True: 91.3k, False: 357] ------------------ 1490| 91.3k| im->red[i] = cmap[CM_RED][i]; ------------------ | | 46| 91.3k|#define CM_RED 0 ------------------ 1491| 91.3k| im->green[i] = cmap[CM_GREEN][i]; ------------------ | | 47| 91.3k|#define CM_GREEN 1 ------------------ 1492| 91.3k| im->blue[i] = cmap[CM_BLUE][i]; ------------------ | | 48| 91.3k|#define CM_BLUE 2 ------------------ 1493| 91.3k| im->open[i] = 1; 1494| 91.3k| } 1495| | 1496| | /* Many (perhaps most) of these colors will remain marked open. */ 1497| 357| im->colorsTotal = gdMaxColors; ------------------ | | 117| 357|#define gdMaxColors 256 ------------------ 1498| 357| if (LWZReadByte(fd, &sd, TRUE, c, ZeroDataBlockP) < 0) { ------------------ | | 43| 357|#define TRUE 1 ------------------ | Branch (1498:9): [True: 0, False: 357] ------------------ 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| 266k| while ((v = LWZReadByte(fd, &sd, FALSE, c, ZeroDataBlockP)) >= 0) { ------------------ | | 44| 266k|#define FALSE 0 ------------------ | Branch (1512:12): [True: 266k, False: 344] ------------------ 1513| 266k| if (colorCount > 0 && v >= colorCount) { ------------------ | Branch (1513:13): [True: 0, False: 266k] | Branch (1513:31): [True: 0, False: 0] ------------------ 1514| 0| return 0; 1515| 0| } 1516| 266k| if (v >= gdMaxColors) { ------------------ | | 117| 266k|#define gdMaxColors 256 ------------------ | Branch (1516:13): [True: 80.5k, False: 186k] ------------------ 1517| 80.5k| v = 0; 1518| 80.5k| } 1519| | 1520| | /* This how we recognize which colors are actually used. */ 1521| 266k| if (im->open[v]) { ------------------ | Branch (1521:13): [True: 2.18k, False: 264k] ------------------ 1522| 2.18k| im->open[v] = 0; 1523| 2.18k| } 1524| | 1525| 266k| gdImageSetPixel(im, xpos, ypos, v); 1526| | 1527| 266k| ++xpos; 1528| 266k| if (xpos == len) { ------------------ | Branch (1528:13): [True: 29.5k, False: 237k] ------------------ 1529| 29.5k| xpos = 0; 1530| 29.5k| if (interlace) { ------------------ | Branch (1530:17): [True: 24.5k, False: 5.00k] ------------------ 1531| 24.5k| switch (pass) { ------------------ | Branch (1531:25): [True: 24.5k, False: 0] ------------------ 1532| 9.59k| case 0: ------------------ | Branch (1532:17): [True: 9.59k, False: 14.9k] ------------------ 1533| 13.7k| case 1: ------------------ | Branch (1533:17): [True: 4.12k, False: 20.4k] ------------------ 1534| 13.7k| ypos += 8; 1535| 13.7k| break; 1536| 5.74k| case 2: ------------------ | Branch (1536:17): [True: 5.74k, False: 18.8k] ------------------ 1537| 5.74k| ypos += 4; 1538| 5.74k| break; 1539| 5.11k| case 3: ------------------ | Branch (1539:17): [True: 5.11k, False: 19.4k] ------------------ 1540| 5.11k| ypos += 2; 1541| 5.11k| break; 1542| 24.5k| } 1543| | 1544| 24.5k| if (ypos >= height) { ------------------ | Branch (1544:21): [True: 130, False: 24.4k] ------------------ 1545| 130| ++pass; 1546| 130| switch (pass) { 1547| 48| case 1: ------------------ | Branch (1547:21): [True: 48, False: 82] ------------------ 1548| 48| ypos = 4; 1549| 48| break; 1550| 44| case 2: ------------------ | Branch (1550:21): [True: 44, False: 86] ------------------ 1551| 44| ypos = 2; 1552| 44| break; 1553| 30| case 3: ------------------ | Branch (1553:21): [True: 30, False: 100] ------------------ 1554| 30| ypos = 1; 1555| 30| break; 1556| 8| default: ------------------ | Branch (1556:21): [True: 8, False: 122] ------------------ 1557| 8| goto fini; 1558| 130| } 1559| 130| } 1560| 24.5k| } else { 1561| 5.00k| ++ypos; 1562| 5.00k| } 1563| 29.5k| } 1564| | 1565| 266k| if (ypos >= height) { ------------------ | Branch (1565:13): [True: 5, False: 266k] ------------------ 1566| 5| break; 1567| 5| } 1568| 266k| } 1569| | 1570| 357|fini: 1571| 357| if (LWZReadByte(fd, &sd, FALSE, c, ZeroDataBlockP) >= 0) { ------------------ | | 44| 357|#define FALSE 0 ------------------ | Branch (1571:9): [True: 21, False: 336] ------------------ 1572| | /* Ignore extra */ 1573| 21| } 1574| 357| return 1; 1575| 357|} gd_gif_in.c:LWZReadByte: 1459| 267k|{ 1460| 267k| int rv; 1461| | 1462| 267k| rv = LWZReadByte_(fd, sd, flag, input_code_size, ZeroDataBlockP); 1463| | 1464| 267k| if (VERBOSE) { ------------------ | | 37| 267k|#define VERBOSE 0 | | ------------------ | | | Branch (37:17): [Folded, False: 267k] | | ------------------ ------------------ 1465| 0| printf("[LWZReadByte(,%d,%d) returning %d]\n", flag, input_code_size, rv); 1466| 0| } 1467| | 1468| 267k| return rv; 1469| 267k|} gd_gif_in.c:LWZReadByte_: 1321| 267k|{ 1322| 267k| int code, incode, i; 1323| | 1324| 267k| if (flag) { ------------------ | Branch (1324:9): [True: 357, False: 267k] ------------------ 1325| 357| sd->set_code_size = input_code_size; 1326| 357| sd->code_size = sd->set_code_size + 1; 1327| 357| sd->clear_code = 1 << sd->set_code_size; 1328| 357| sd->end_code = sd->clear_code + 1; 1329| 357| sd->max_code_size = 2 * sd->clear_code; 1330| 357| sd->max_code = sd->clear_code + 2; 1331| | 1332| 357| GetCode(fd, &sd->scd, 0, TRUE, ZeroDataBlockP); ------------------ | | 43| 357|#define TRUE 1 ------------------ 1333| | 1334| 357| sd->fresh = TRUE; ------------------ | | 43| 357|#define TRUE 1 ------------------ 1335| | 1336| 317k| for (i = 0; i < sd->clear_code; ++i) { ------------------ | Branch (1336:21): [True: 317k, False: 357] ------------------ 1337| 317k| sd->table[0][i] = 0; 1338| 317k| sd->table[1][i] = i; 1339| 317k| } 1340| | 1341| 1.14M| for (; i < (1 << MAX_LWZ_BITS); ++i) { ------------------ | | 50| 1.14M|#define MAX_LWZ_BITS 12 ------------------ | Branch (1341:16): [True: 1.14M, False: 357] ------------------ 1342| 1.14M| sd->table[0][i] = sd->table[1][0] = 0; 1343| 1.14M| } 1344| | 1345| 357| sd->sp = sd->stack; 1346| | 1347| 357| return 0; 1348| | 1349| 267k| } else if (sd->fresh) { ------------------ | Branch (1349:16): [True: 357, False: 266k] ------------------ 1350| 357| sd->fresh = FALSE; ------------------ | | 44| 357|#define FALSE 0 ------------------ 1351| | 1352| 827| do { 1353| 827| sd->firstcode = sd->oldcode = 1354| 827| GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP); ------------------ | | 44| 827|#define FALSE 0 ------------------ 1355| 827| } while (sd->firstcode == sd->clear_code); ------------------ | Branch (1355:18): [True: 470, False: 357] ------------------ 1356| | 1357| 357| return sd->firstcode; 1358| 357| } 1359| | 1360| 266k| if (sd->sp > sd->stack) { ------------------ | Branch (1360:9): [True: 156k, False: 110k] ------------------ 1361| 156k| return *--sd->sp; 1362| 156k| } 1363| | 1364| 110k| while ((code = GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP)) >= 0) { ------------------ | | 44| 110k|#define FALSE 0 ------------------ | Branch (1364:12): [True: 110k, False: 561] ------------------ 1365| 110k| if (code == sd->clear_code) { ------------------ | Branch (1365:13): [True: 2.23k, False: 108k] ------------------ 1366| 888k| for (i = 0; i < sd->clear_code; ++i) { ------------------ | Branch (1366:25): [True: 886k, False: 2.23k] ------------------ 1367| 886k| sd->table[0][i] = 0; 1368| 886k| sd->table[1][i] = i; 1369| 886k| } 1370| | 1371| 8.25M| for (; i < (1 << MAX_LWZ_BITS); ++i) { ------------------ | | 50| 8.25M|#define MAX_LWZ_BITS 12 ------------------ | Branch (1371:20): [True: 8.25M, False: 2.23k] ------------------ 1372| 8.25M| sd->table[0][i] = sd->table[1][i] = 0; 1373| 8.25M| } 1374| | 1375| 2.23k| sd->code_size = sd->set_code_size + 1; 1376| 2.23k| sd->max_code_size = 2 * sd->clear_code; 1377| 2.23k| sd->max_code = sd->clear_code + 2; 1378| 2.23k| sd->sp = sd->stack; 1379| 2.23k| sd->firstcode = sd->oldcode = 1380| 2.23k| GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP); ------------------ | | 44| 2.23k|#define FALSE 0 ------------------ 1381| | 1382| 2.23k| return sd->firstcode; 1383| 108k| } else if (code == sd->end_code) { ------------------ | Branch (1383:20): [True: 236, False: 107k] ------------------ 1384| 236| int count; 1385| 236| unsigned char buf[260]; 1386| | 1387| 236| if (*ZeroDataBlockP) { ------------------ | Branch (1387:17): [True: 3, False: 233] ------------------ 1388| 3| return -2; 1389| 3| } 1390| | 1391| 481| while ((count = GetDataBlock(fd, buf, ZeroDataBlockP)) > 0) ------------------ | Branch (1391:20): [True: 248, False: 233] ------------------ 1392| 248| ; 1393| | 1394| 233| if (count != 0) { ------------------ | Branch (1394:17): [True: 36, False: 197] ------------------ 1395| 36| return -2; 1396| 36| } 1397| 233| } 1398| | 1399| 107k| incode = code; 1400| | 1401| 107k| if (sd->sp == (sd->stack + STACK_SIZE)) { ------------------ | | 83| 107k|#define STACK_SIZE ((1 << (MAX_LWZ_BITS)) * 2) | | ------------------ | | | | 50| 107k|#define MAX_LWZ_BITS 12 | | ------------------ ------------------ | Branch (1401:13): [True: 0, False: 107k] ------------------ 1402| | /* Bad compressed data stream */ 1403| 0| return -1; 1404| 0| } 1405| | 1406| 107k| if (code >= sd->max_code) { ------------------ | Branch (1406:13): [True: 29.5k, False: 78.3k] ------------------ 1407| 29.5k| *sd->sp++ = sd->firstcode; 1408| 29.5k| code = sd->oldcode; 1409| 29.5k| } 1410| | 1411| 242k| while (code >= sd->clear_code) { ------------------ | Branch (1411:16): [True: 134k, False: 107k] ------------------ 1412| 134k| if (sd->sp == (sd->stack + STACK_SIZE)) { ------------------ | | 83| 134k|#define STACK_SIZE ((1 << (MAX_LWZ_BITS)) * 2) | | ------------------ | | | | 50| 134k|#define MAX_LWZ_BITS 12 | | ------------------ ------------------ | Branch (1412:17): [True: 1, False: 134k] ------------------ 1413| | /* Bad compressed data stream */ 1414| 1| return -1; 1415| 1| } 1416| 134k| if (code >= (1 << MAX_LWZ_BITS)) { ------------------ | | 50| 134k|#define MAX_LWZ_BITS 12 ------------------ | Branch (1416:17): [True: 5, False: 134k] ------------------ 1417| | /* Corrupted code */ 1418| 5| return -1; 1419| 5| } 1420| | 1421| 134k| *sd->sp++ = sd->table[1][code]; 1422| | 1423| 134k| if (code == sd->table[0][code]) { ------------------ | Branch (1423:17): [True: 8.19k, False: 126k] ------------------ 1424| | /* Oh well */ 1425| 8.19k| } 1426| | 1427| 134k| code = sd->table[0][code]; 1428| 134k| } 1429| 107k| if (code >= (1 << MAX_LWZ_BITS)) { ------------------ | | 50| 107k|#define MAX_LWZ_BITS 12 ------------------ | Branch (1429:13): [True: 0, False: 107k] ------------------ 1430| | /* Corrupted code */ 1431| 0| return -1; 1432| 0| } 1433| | 1434| 107k| *sd->sp++ = sd->firstcode = sd->table[1][code]; 1435| | 1436| 107k| if ((code = sd->max_code) < (1 << MAX_LWZ_BITS)) { ------------------ | | 50| 107k|#define MAX_LWZ_BITS 12 ------------------ | Branch (1436:13): [True: 107k, False: 822] ------------------ 1437| 107k| sd->table[0][code] = sd->oldcode; 1438| 107k| sd->table[1][code] = sd->firstcode; 1439| 107k| ++sd->max_code; 1440| | 1441| 107k| if ((sd->max_code >= sd->max_code_size) && (sd->max_code_size < (1 << MAX_LWZ_BITS))) { ------------------ | | 50| 1.53k|#define MAX_LWZ_BITS 12 ------------------ | Branch (1441:17): [True: 1.53k, False: 105k] | Branch (1441:56): [True: 1.50k, False: 37] ------------------ 1442| 1.50k| sd->max_code_size *= 2; 1443| 1.50k| ++sd->code_size; 1444| 1.50k| } 1445| 107k| } 1446| | 1447| 107k| sd->oldcode = incode; 1448| | 1449| 107k| if (sd->sp > sd->stack) { ------------------ | Branch (1449:13): [True: 107k, False: 0] ------------------ 1450| 107k| return *--sd->sp; 1451| 107k| } 1452| 107k| } 1453| | 1454| 561| return code; 1455| 110k|} gd_gif_in.c:GetCode: 1307| 114k|{ 1308| 114k| int rv; 1309| | 1310| 114k| rv = GetCode_(fd, scd, code_size, flag, ZeroDataBlockP); 1311| | 1312| 114k| if (VERBOSE) { ------------------ | | 37| 114k|#define VERBOSE 0 | | ------------------ | | | Branch (37:17): [Folded, False: 114k] | | ------------------ ------------------ 1313| 0| printf("[GetCode(,%d,%d) returning %d]\n", code_size, flag, rv); 1314| 0| } 1315| | 1316| 114k| return rv; 1317| 114k|} gd_gif_in.c:GetCode_: 1247| 114k|{ 1248| 114k| int i, j, ret; 1249| 114k| int count; 1250| | 1251| 114k| if (flag) { ------------------ | Branch (1251:9): [True: 357, False: 113k] ------------------ 1252| 357| scd->curbit = 0; 1253| 357| scd->lastbit = 0; 1254| 357| scd->last_byte = 2; 1255| 357| scd->done = FALSE; ------------------ | | 44| 357|#define FALSE 0 ------------------ 1256| 357| return 0; 1257| 357| } 1258| | 1259| 113k| if ((scd->curbit + code_size) >= scd->lastbit) { ------------------ | Branch (1259:9): [True: 3.21k, False: 110k] ------------------ 1260| 3.21k| if (scd->done) { ------------------ | Branch (1260:13): [True: 411, False: 2.80k] ------------------ 1261| 411| if (scd->curbit >= scd->lastbit) { ------------------ | Branch (1261:17): [True: 244, False: 167] ------------------ 1262| | /* Oh well */ 1263| 244| } 1264| 411| return -1; 1265| 411| } 1266| | 1267| 2.80k| scd->buf[0] = scd->buf[scd->last_byte - 2]; 1268| 2.80k| scd->buf[1] = scd->buf[scd->last_byte - 1]; 1269| 2.80k| scd->last_byte = 2; 1270| 2.80k| scd->curbit = (scd->curbit - scd->lastbit) + 16; 1271| 2.80k| scd->lastbit = 16; 1272| | 1273| 3.23k| do { 1274| 3.23k| if (scd->last_byte > (CSD_BUF_SIZE - 255)) { ------------------ | | 85| 3.23k|#define CSD_BUF_SIZE 280 ------------------ | Branch (1274:17): [True: 0, False: 3.23k] ------------------ 1275| 0| return -1; 1276| 0| } 1277| | 1278| 3.23k| if ((count = GetDataBlock(fd, &scd->buf[scd->last_byte], ZeroDataBlockP)) <= 0) { ------------------ | Branch (1278:17): [True: 331, False: 2.89k] ------------------ 1279| 331| scd->done = TRUE; ------------------ | | 43| 331|#define TRUE 1 ------------------ 1280| 331| break; 1281| 331| } 1282| | 1283| 2.89k| scd->last_byte += count; 1284| 2.89k| scd->lastbit += count * 8; 1285| 2.89k| } while ((scd->curbit + code_size) > scd->lastbit); ------------------ | Branch (1285:18): [True: 425, False: 2.47k] ------------------ 1286| 2.80k| } 1287| | 1288| 113k| if ((scd->curbit + code_size) > scd->lastbit) { ------------------ | Branch (1288:9): [True: 224, False: 113k] ------------------ 1289| 224| return -1; 1290| 224| } 1291| | 1292| 113k| if ((scd->curbit + code_size - 1) >= (CSD_BUF_SIZE * 8)) { ------------------ | | 85| 113k|#define CSD_BUF_SIZE 280 ------------------ | Branch (1292:9): [True: 0, False: 113k] ------------------ 1293| 0| ret = -1; 1294| 113k| } else { 1295| 113k| ret = 0; 1296| 1.36M| for (i = scd->curbit, j = 0; j < code_size; ++i, ++j) { ------------------ | Branch (1296:38): [True: 1.25M, False: 113k] ------------------ 1297| 1.25M| ret |= ((scd->buf[i / 8] & (1 << (i % 8))) != 0) << j; 1298| 1.25M| } 1299| 113k| } 1300| | 1301| 113k| scd->curbit += code_size; 1302| | 1303| 113k| return ret; 1304| 113k|} gdGetBuf: 189| 5.04M|int gdGetBuf(void *buf, int size, gdIOCtx *ctx) { return (ctx->getBuf)(ctx, buf, size); } gdNewDynamicCtxEx: 81| 775|{ 82| 775| dpIOCtx *ctx; 83| 775| dynamicPtr *dp; 84| | 85| 775| ctx = (dpIOCtx *)gdMalloc(sizeof(dpIOCtx)); 86| 775| if (ctx == NULL) { ------------------ | Branch (86:9): [True: 0, False: 775] ------------------ 87| 0| return NULL; 88| 0| } 89| | 90| 775| dp = newDynamic(initialSize, data, freeOKFlag); 91| 775| if (!dp) { ------------------ | Branch (91:9): [True: 0, False: 775] ------------------ 92| 0| gdFree(ctx); 93| 0| return NULL; 94| 775| }; 95| | 96| 775| ctx->dp = dp; 97| | 98| 775| ctx->ctx.getC = dynamicGetchar; 99| 775| ctx->ctx.putC = dynamicPutchar; 100| | 101| 775| ctx->ctx.getBuf = dynamicGetbuf; 102| 775| ctx->ctx.putBuf = dynamicPutbuf; 103| | 104| 775| ctx->ctx.seek = dynamicSeek; 105| 775| ctx->ctx.tell = dynamicTell; 106| | 107| 775| ctx->ctx.gd_free = gdFreeDynamicCtx; 108| | 109| 775| return (gdIOCtx *)ctx; 110| 775|} gd_io_dp.c:gdFreeDynamicCtx: 146| 775|{ 147| 775| dynamicPtr *dp; 148| 775| dpIOCtx *dctx; 149| | 150| 775| dctx = (dpIOCtx *)ctx; 151| 775| dp = dctx->dp; 152| | 153| 775| gdFree(ctx); 154| | 155| | /* clean up the data block and return it */ 156| | /* 2.0.21: never free memory we don't own */ 157| 775| if ((dp->data != NULL) && (dp->freeOK)) { ------------------ | Branch (157:9): [True: 775, False: 0] | Branch (157:31): [True: 0, False: 775] ------------------ 158| 0| gdFree(dp->data); 159| 0| dp->data = NULL; 160| 0| } 161| | 162| 775| dp->realSize = 0; 163| 775| dp->logicalSize = 0; 164| | 165| 775| gdFree(dp); 166| 775|} gd_io_dp.c:newDynamic: 224| 775|{ 225| 775| dynamicPtr *dp; 226| | 227| 775| dp = (dynamicPtr *)gdMalloc(sizeof(dynamicPtr)); 228| 775| if (dp == NULL) { ------------------ | Branch (228:9): [True: 0, False: 775] ------------------ 229| 0| return NULL; 230| 0| } 231| | 232| 775| if (!allocDynamic(dp, initialSize, data)) { ------------------ | Branch (232:9): [True: 0, False: 775] ------------------ 233| 0| gdFree(dp); 234| 0| return NULL; 235| 0| } 236| | 237| 775| dp->pos = 0; 238| 775| dp->freeOK = freeOKFlag; 239| | 240| 775| return dp; 241| 775|} gd_io_dp.c:allocDynamic: 325| 775|{ 326| 775| if (data == NULL) { ------------------ | Branch (326:9): [True: 0, False: 775] ------------------ 327| 0| dp->logicalSize = 0; 328| 0| dp->dataGood = FALSE; ------------------ | | 29| 0|#define FALSE 0 ------------------ 329| 0| dp->data = gdMalloc(initialSize); 330| 775| } else { 331| 775| dp->logicalSize = initialSize; 332| 775| dp->dataGood = TRUE; ------------------ | | 28| 775|#define TRUE 1 ------------------ 333| 775| dp->data = data; 334| 775| } 335| | 336| 775| if (dp->data != NULL) { ------------------ | Branch (336:9): [True: 775, False: 0] ------------------ 337| 775| dp->realSize = initialSize; 338| 775| dp->dataGood = TRUE; ------------------ | | 28| 775|#define TRUE 1 ------------------ 339| 775| dp->pos = 0; 340| 775| return TRUE; ------------------ | | 28| 775|#define TRUE 1 ------------------ 341| 775| } else { 342| 0| dp->realSize = 0; 343| 0| return FALSE; ------------------ | | 29| 0|#define FALSE 0 ------------------ 344| 0| } 345| 775|} gd_io_dp.c:dynamicGetbuf: 270| 5.04M|{ 271| 5.04M| int rlen, remain; 272| 5.04M| dpIOCtxPtr dctx; 273| 5.04M| dynamicPtr *dp; 274| | 275| 5.04M| dctx = (dpIOCtxPtr)ctx; 276| 5.04M| dp = dctx->dp; 277| | 278| 5.04M| if (dp->pos < 0 || dp->pos >= dp->realSize) { ------------------ | Branch (278:9): [True: 0, False: 5.04M] | Branch (278:24): [True: 767, False: 5.04M] ------------------ 279| 767| return 0; 280| 767| } 281| | 282| 5.04M| remain = dp->logicalSize - dp->pos; 283| 5.04M| if (remain >= len) { ------------------ | Branch (283:9): [True: 5.04M, False: 37] ------------------ 284| 5.04M| rlen = len; 285| 5.04M| } 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| 5.04M| if (dp->pos + rlen > dp->realSize) { ------------------ | Branch (293:9): [True: 0, False: 5.04M] ------------------ 294| 0| rlen = dp->realSize - dp->pos; 295| 0| } 296| | 297| 5.04M| if (rlen < 0) { ------------------ | Branch (297:9): [True: 0, False: 5.04M] ------------------ 298| 0| return 0; 299| 0| } 300| | 301| 5.04M| memcpy(buf, (void *)((char *)dp->data + dp->pos), rlen); 302| 5.04M| dp->pos += rlen; 303| | 304| 5.04M| return rlen; 305| 5.04M|} overflow2: 23| 1.23k|{ 24| 1.23k| if (a <= 0 || b <= 0) { ------------------ | Branch (24:9): [True: 1, False: 1.23k] | Branch (24:19): [True: 1, False: 1.23k] ------------------ 25| 2| gd_error_ex(GD_WARNING, "one parameter to a memory allocation multiplication is " ------------------ | | 38| 2|#define GD_WARNING LOG_WARNING ------------------ 26| 2| "negative or zero, failing operation gracefully\n"); 27| 2| return 1; 28| 2| } 29| 1.23k| if (a > 100000 / b) { ------------------ | Branch (29:9): [True: 24, False: 1.20k] ------------------ 30| 24| gd_error_ex(GD_WARNING, "product of memory allocation multiplication would exceed " ------------------ | | 38| 24|#define GD_WARNING LOG_WARNING ------------------ 31| 24| "100000, failing operation gracefully\n"); 32| 24| return 1; 33| 24| } 34| 1.20k| return 0; 35| 1.23k|} gdCalloc: 66| 606k|void *gdCalloc(size_t nmemb, size_t size) { return calloc(nmemb, size); } gdMalloc: 68| 1.95k|void *gdMalloc(size_t size) { return malloc(size); } gdFree: 100| 608k|BGD_DECLARE(void) gdFree(void *ptr) { free(ptr); } LLVMFuzzerTestOneInput: 23| 775|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { 24| 775| gdImagePtr im = CREATE_IMAGE(FUZZ_GD_FORMAT)(Size, (void*) Data); ------------------ | | 21| 775|#define CREATE_IMAGE(FORMAT) PASTE(FORMAT) | | ------------------ | | | | 20| 775|#define PASTE(x) gdImageCreateFrom ## x ## Ptr | | ------------------ ------------------ 25| 775| if (im) gdImageDestroy(im); ------------------ | Branch (25:9): [True: 314, False: 461] ------------------ 26| 775| return 0; 27| 775|}