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