int ask_yn(const char * string, int def) { int c; const char *defstr; const char *short_yes = _("yY"); const char *short_no = _("nN"); #ifdef HAVE_TERMIOS_H struct termios termios, tmp; tcgetattr (0, &termios); tmp = termios; tmp.c_lflag &= ~(ICANON | ECHO); tmp.c_cc[VMIN] = 1; tmp.c_cc[VTIME] = 0; tcsetattr (0, TCSANOW, &tmp); #endif if (def == 1) defstr = _(_("<y>")); else if (def == 0) defstr = _(_("<n>")); else defstr = _(" (y/n)"); printf("%s%s? ", string, defstr); while (1) { fflush (stdout); if ((c = read_a_char()) == EOF) break; if (c == 3) { #ifdef HAVE_TERMIOS_H tcsetattr (0, TCSANOW, &termios); #endif if (e2fsck_global_ctx && e2fsck_global_ctx->flags & E2F_FLAG_SETJMP_OK) { puts("\n"); longjmp(e2fsck_global_ctx->abort_loc, 1); } puts(_("cancelled!\n")); return 0; } if (strchr(short_yes, (char) c)) { def = 1; break; } else if (strchr(short_no, (char) c)) { def = 0; break; } else if ((c == ' ' || c == '\n') && (def != -1)) break; } if (def) puts(_("yes\n")); else puts (_("no\n")); #ifdef HAVE_TERMIOS_H tcsetattr (0, TCSANOW, &termios); #endif return def; }
int tessTesselate( TESStesselator *tess, int windingRule, int elementType, int polySize, int vertexSize, const TESSreal* normal ) { TESSmesh *mesh; int rc = 1; if (tess->vertices != NULL) { tess->alloc.memfree( tess->alloc.userData, tess->vertices ); tess->vertices = 0; } if (tess->elements != NULL) { tess->alloc.memfree( tess->alloc.userData, tess->elements ); tess->elements = 0; } if (tess->vertexIndices != NULL) { tess->alloc.memfree( tess->alloc.userData, tess->vertexIndices ); tess->vertexIndices = 0; } tess->vertexIndexCounter = 0; if (normal) { tess->normal[0] = normal[0]; tess->normal[1] = normal[1]; tess->normal[2] = normal[2]; } tess->windingRule = windingRule; if (vertexSize < 2) vertexSize = 2; if (vertexSize > 3) vertexSize = 3; if (setjmp(tess->env) != 0) { /* come back here if out of memory */ return 0; } if (!tess->mesh) { return 0; } /* Determine the polygon normal and project vertices onto the plane * of the polygon. */ tessProjectPolygon( tess ); /* tessComputeInterior( tess ) computes the planar arrangement specified * by the given contours, and further subdivides this arrangement * into regions. Each region is marked "inside" if it belongs * to the polygon, according to the rule given by tess->windingRule. * Each interior region is guaranteed be monotone. */ if ( !tessComputeInterior( tess ) ) { longjmp(tess->env,1); /* could've used a label */ } mesh = tess->mesh; /* If the user wants only the boundary contours, we throw away all edges * except those which separate the interior from the exterior. * Otherwise we tessellate all the regions marked "inside". */ if (elementType == TESS_BOUNDARY_CONTOURS) { rc = tessMeshSetWindingNumber( mesh, 1, TRUE ); } else { rc = tessMeshTessellateInterior( mesh ); } if (rc == 0) longjmp(tess->env,1); /* could've used a label */ tessMeshCheckMesh( mesh ); if (elementType == TESS_BOUNDARY_CONTOURS) { OutputContours( tess, mesh, vertexSize ); /* output contours */ } else { OutputPolymesh( tess, mesh, elementType, polySize, vertexSize ); /* output polygons */ } tessMeshDeleteMesh( &tess->alloc, mesh ); tess->mesh = NULL; if (tess->outOfMemory) return 0; return 1; }
/* ARGSUSED */ static void onintr(int sig) { longjmp(jbuf, 1); }
void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int) { if (m_frameBufferCache.isEmpty()) return; // Initialize the framebuffer if needed. ImageFrame& buffer = m_frameBufferCache[0]; if (buffer.status() == ImageFrame::FrameEmpty) { png_structp png = m_reader->pngPtr(); if (!buffer.setSize(size().width(), size().height())) { longjmp(JMPBUF(png), 1); return; } unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3; if (PNG_INTERLACE_ADAM7 == png_get_interlace_type(png, m_reader->infoPtr())) { m_reader->createInterlaceBuffer(colorChannels * size().width() * size().height()); if (!m_reader->interlaceBuffer()) { longjmp(JMPBUF(png), 1); return; } } #if USE(QCMSLIB) if (m_reader->colorTransform()) { m_reader->createRowBuffer(colorChannels * size().width()); if (!m_reader->rowBuffer()) { longjmp(JMPBUF(png), 1); return; } } #endif buffer.setStatus(ImageFrame::FramePartial); buffer.setHasAlpha(false); // For PNGs, the frame always fills the entire image. buffer.setOriginalFrameRect(IntRect(IntPoint(), size())); } /* libpng comments (here to explain what follows). * * this function is called for every row in the image. If the * image is interlacing, and you turned on the interlace handler, * this function will be called for every row in every pass. * Some of these rows will not be changed from the previous pass. * When the row is not changed, the new_row variable will be NULL. * The rows and passes are called in order, so you don't really * need the row_num and pass, but I'm supplying them because it * may make your life easier. */ // Nothing to do if the row is unchanged, or the row is outside // the image bounds: libpng may send extra rows, ignore them to // make our lives easier. if (!rowBuffer) return; int y = rowIndex; if (y < 0 || y >= size().height()) return; /* libpng comments (continued). * * For the non-NULL rows of interlaced images, you must call * png_progressive_combine_row() passing in the row and the * old row. You can call this function for NULL rows (it will * just return) and for non-interlaced images (it just does the * memcpy for you) if it will make the code easier. Thus, you * can just do this for all cases: * * png_progressive_combine_row(png_ptr, old_row, new_row); * * where old_row is what was displayed for previous rows. Note * that the first pass (pass == 0 really) will completely cover * the old row, so the rows do not have to be initialized. After * the first pass (and only for interlaced images), you will have * to pass the current row, and the function will combine the * old row and the new row. */ bool hasAlpha = m_reader->hasAlpha(); png_bytep row = rowBuffer; if (png_bytep interlaceBuffer = m_reader->interlaceBuffer()) { unsigned colorChannels = hasAlpha ? 4 : 3; row = interlaceBuffer + (rowIndex * colorChannels * size().width()); png_progressive_combine_row(m_reader->pngPtr(), row, rowBuffer); } #if USE(QCMSLIB) if (qcms_transform* transform = m_reader->colorTransform()) { qcms_transform_data(transform, row, m_reader->rowBuffer(), size().width()); row = m_reader->rowBuffer(); } #endif // Write the decoded row pixels to the frame buffer. The repetitive // form of the row write loops is for speed. ImageFrame::PixelData* address = buffer.getAddr(0, y); unsigned alphaMask = 255; int width = size().width(); png_bytep pixel = row; if (hasAlpha) { if (buffer.premultiplyAlpha()) { for (int x = 0; x < width; ++x, pixel += 4) { buffer.setRGBAPremultiply(address++, pixel[0], pixel[1], pixel[2], pixel[3]); alphaMask &= pixel[3]; } } else { for (int x = 0; x < width; ++x, pixel += 4) { buffer.setRGBARaw(address++, pixel[0], pixel[1], pixel[2], pixel[3]); alphaMask &= pixel[3]; } } } else { for (int x = 0; x < width; ++x, pixel += 3) { buffer.setRGBARaw(address++, pixel[0], pixel[1], pixel[2], 255); } } if (alphaMask != 255 && !buffer.hasAlpha()) buffer.setHasAlpha(true); buffer.setPixelsChanged(true); }
void oob(int signo __unused) { struct sgttyb sb; int atmark, n, out, rcvd; char waste[BUFSIZ], mark; out = O_RDWR; rcvd = 0; while (recv(rem, &mark, 1, MSG_OOB) < 0) { switch (errno) { case EWOULDBLOCK: /* * Urgent data not here yet. It may not be possible * to send it yet if we are blocked for output and * our input buffer is full. */ if (rcvcnt < (int)sizeof(rcvbuf)) { n = read(rem, rcvbuf + rcvcnt, sizeof(rcvbuf) - rcvcnt); if (n <= 0) return; rcvd += n; } else { n = read(rem, waste, sizeof(waste)); if (n <= 0) return; } continue; default: return; } } if (mark & TIOCPKT_WINDOW) { /* Let server know about window size changes */ (void)kill(ppid, SIGUSR1); } if (!eight && (mark & TIOCPKT_NOSTOP)) { (void)ioctl(0, TIOCGETP, (char *)&sb); sb.sg_flags &= ~CBREAK; sb.sg_flags |= RAW; (void)ioctl(0, TIOCSETN, (char *)&sb); notc.t_stopc = -1; notc.t_startc = -1; (void)ioctl(0, TIOCSETC, (char *)¬c); } if (!eight && (mark & TIOCPKT_DOSTOP)) { (void)ioctl(0, TIOCGETP, (char *)&sb); sb.sg_flags &= ~RAW; sb.sg_flags |= CBREAK; (void)ioctl(0, TIOCSETN, (char *)&sb); notc.t_stopc = deftc.t_stopc; notc.t_startc = deftc.t_startc; (void)ioctl(0, TIOCSETC, (char *)¬c); } if (mark & TIOCPKT_FLUSHWRITE) { (void)ioctl(1, TIOCFLUSH, (char *)&out); for (;;) { if (ioctl(rem, SIOCATMARK, &atmark) < 0) { warn("ioctl"); break; } if (atmark) break; n = read(rem, waste, sizeof (waste)); if (n <= 0) break; } /* * Don't want any pending data to be output, so clear the recv * buffer. If we were hanging on a write when interrupted, * don't want it to restart. If we were reading, restart * anyway. */ rcvcnt = 0; longjmp(rcvtop, 1); } /* oob does not do FLUSHREAD (alas!) */ /* * If we filled the receive buffer while a read was pending, longjmp * to the top to restart appropriately. Don't abort a pending write, * however, or we won't know how much was written. */ if (rcvd && rcvstate == READING) longjmp(rcvtop, 1); }
static void ctrlc(int sig) { signal(sig, SIG_IGN); longjmp(jmpbuf, 1); }
/* This only gets called if IServerGameDLL::GetUserMessageInfo() triggers it */ void Detour_Error(const tchar *pMsg, ...) { /* Jump back to setjmp() in CacheUserMessages() */ longjmp(usermsg_end, 1); }
char * getNextSection(struct _CMCIConnection * con) { char * xmlb = NULL; char * workptr = NULL; char * curptr = NULL; int xmlblen = 0; int tagval = 0; int retcode = 0; int toval = 0; /* * free that old buffer */ if(con->asynRCntl.escanInfo.section != NULL) { free(con->asynRCntl.escanInfo.section); con->asynRCntl.escanInfo.section = NULL ; } if((retcode = pthread_mutex_lock(&(con->asynRCntl.escanlock))) != 0){ printf(" getNextSection pthread lock return code %d\n",retcode) ; } /* * If we have no more new data from the server , we * unlock and sleep then check till we see that we have * received new data */ while(con->asynRCntl.escanInfo.prevtotl == con->asynRCntl.escanInfo.recdtotl){ if((retcode = pthread_mutex_unlock(&(con->asynRCntl.escanlock))) != 0){ printf(" getNextSection pthread lock return code %d\n",retcode) ; } /* ******************************************* * ******************************************* * timeout toval keeps us from hanging forever * ******************************************* * ******************************************* */ usleep(1000) ; toval++ ; if(toval>5000) longjmp (save_env, 1); if(con->asynRCntl.escanInfo.prevtotl != con->asynRCntl.escanInfo.recdtotl){ /* * we got more data , exit this loop */ if((retcode = pthread_mutex_lock(&(con->asynRCntl.escanlock))) != 0){ printf(" getNextSection pthread lock return code %d\n",retcode) ; } break; } } if((con->asynRCntl.xfer_state == XFER_DATA_RECVD) || (con->asynRCntl.xfer_state == XFER_COMPLETE) ) { workptr = LASTPTR(&(con->asynRCntl.escanInfo)) ; curptr = CURPTR(&(con->asynRCntl.escanInfo)); con->asynRCntl.escanInfo.ssecoff = con->asynRCntl.escanInfo.curoff ; toval = 0; while(workptr > curptr) { if(*workptr == '>'){ tagval = checkTag(workptr , con->asynRCntl.eMethodType) ; if(tagval == 0){ con->asynRCntl.escanInfo.curoff = con->asynRCntl.escanInfo.curoff + (workptr - curptr) + 1 ; xmlblen = ((workptr - curptr) + 5) ; xmlb = malloc(xmlblen + 64) ; con->asynRCntl.escanInfo.section = xmlb ; con->asynRCntl.escanInfo.sectlen = xmlblen + 5 ; memset(xmlb , 0x0cc , xmlblen + 5) ; if(xmlb != NULL){ memcpy(xmlb , SSECPTR(&con->asynRCntl.escanInfo) , xmlblen) ; strcpy((xmlb+(xmlblen - 4)) , "<EC>") ; con->asynRCntl.escanInfo.getnew = 0 ; } else { /* getNextSection xmlb is NULL !!! This is bad */ } con->asynRCntl.escanInfo.prevtotl = con->asynRCntl.escanInfo.recdtotl ; if((retcode = pthread_mutex_unlock(&(con->asynRCntl.escanlock))) != 0){ printf(" getNextSection pthread lock return code %d\n",retcode) ; } return(xmlb) ; } else { /* * backup before this tag */ workptr = workptr - tagval ; if(workptr <= curptr){ if (con->asynRCntl.escanInfo.prevtotl != con->asynRCntl.escanInfo.recdtotl){ pthread_mutex_unlock(&(con->asynRCntl.escanlock)); usleep(1000) ; toval++ ; if(toval > 5000) longjmp (save_env, 2); pthread_mutex_lock(&(con->asynRCntl.escanlock)); workptr = LASTPTR(&(con->asynRCntl.escanInfo)) ; curptr = CURPTR(&(con->asynRCntl.escanInfo)); } } continue; } } else { workptr-- ; if(workptr <= curptr){ if (con->asynRCntl.escanInfo.prevtotl != con->asynRCntl.escanInfo.recdtotl){ workptr = LASTPTR(&(con->asynRCntl.escanInfo)) ; curptr = CURPTR(&(con->asynRCntl.escanInfo)); } } } } } if((retcode = pthread_mutex_unlock(&(con->asynRCntl.escanlock))) != 0){ printf(" getNextSection pthread unlock return code %d\n",retcode) ; } return(NULL) ; }
static void user_error_fn (png_structp png_ptr, png_const_charp error_msg) { longjmp (png_ptr->jmp_buf_local, 1); }
void GOL_sysabort(UCHAR termcode) { GOL_abortcode = termcode; longjmp(setjmp_env, 1); }
static void PNGAPI error_function(png_structp png, png_const_charp error) { if (error != NULL) fprintf(stderr, "libpng error: %s\n", error); longjmp(png_jmpbuf(png), 1); }
void exit(int value) { exit_value = value; longjmp(exit_jmp, 1); }
int main(void) { acInit(); gfxInitDefault(); gfxSetDoubleBuffering(GFX_TOP, false); gfxSetDoubleBuffering(GFX_BOTTOM, false); if(setjmp(exitJmp)) goto exit; preRenderKeyboard(); clearScreen(); drawString(10, 10, "Initing FS..."); gfxFlushBuffers(); gfxSwapBuffers(); fsInit(); clearScreen(); drawString(10, 10, "Initing SOC..."); gfxFlushBuffers(); gfxSwapBuffers(); SOC_Initialize((u32 *)memalign(0x1000, 0x100000), 0x100000); u32 wifiStatus = 0; ACU_GetWifiStatus(NULL, &wifiStatus); if(!wifiStatus) { hang("No WiFi! Is your wireless slider on?"); } clearScreen(); drawString(10, 10, "Reading settings..."); gfxFlushBuffers(); gfxSwapBuffers(); if(!readSettings()) { hang("Could not read 3DSController.ini!"); } clearScreen(); drawString(10, 10, "Connecting to %s on port %d...", settings.IPString, settings.port); gfxFlushBuffers(); gfxSwapBuffers(); openSocket(settings.port); sendConnectionRequest(); clearScreen(); gfxFlushBuffers(); gfxSwapBuffers(); disableBacklight(); while(aptMainLoop()) { hidScanInput(); irrstScanInput(); u32 kHeld = hidKeysHeld(); circlePosition circlePad; circlePosition cStick; hidCstickRead(&cStick); hidCircleRead(&circlePad); touchPosition touch; touchRead(&touch); clearScreen(); if((kHeld & KEY_L) && (kHeld & KEY_R) && (kHeld & KEY_X)) { if(keyboardToggle) { keyboardActive = !keyboardActive; keyboardToggle = false; if(keyboardActive) enableBacklight(); } } else keyboardToggle = true; if(keyboardActive) { drawKeyboard(); if(touch.px >= 1 && touch.px <= 312 && touch.py >= 78 && touch.py <= 208) { int x = (int)((float)touch.px * 12.0f / 320.0f); int y = (int)((float)(touch.py - 78) * 12.0f / 320.0f); int width = 24; int height = 24; if(keyboardChars[x + y * 12] == ' ') { while(keyboardChars[(x - 1) + y * 12] == ' ') x--; width = (int)(5.0f * 320.0f / 12.0f) - 1; } else if(keyboardChars[x + y * 12] == '\13') { while(keyboardChars[(x - 1) + y * 12] == '\13') x--; while(keyboardChars[x + (y - 1) * 12] == '\13') y--; width = (int)(2.0f * 320.0f / 12.0f) - 1; height = (int)(3.0f * 320.0f / 12.0f) - 1; } if(keyboardChars[x + y * 12]) drawBox((int)((float)x * 320.0f / 12.0f) + 1, (int)(78.0f + (float)y * 320.0f / 12.0f) + 1, width, height, 31, 31, 0); } } sendKeys(kHeld, circlePad, touch, cStick); //receiveBuffer(sizeof(struct packet)); if((kHeld & KEY_START) && (kHeld & KEY_SELECT)) longjmp(exitJmp, 1); gfxFlushBuffers(); gspWaitForVBlank(); gfxSwapBuffers(); } exit: enableBacklight(); SOC_Shutdown(); svcCloseHandle(fileHandle); fsExit(); gfxExit(); acExit(); return 0; }
// Handles exit on errors. void ErrorExit(j_common_ptr cinfo) { struct InputSource* inputSource = (struct InputSource*)(cinfo->client_data); longjmp(inputSource->mErrorManager.mSetJumpBuffer, 1); }
static void handleError(j_common_ptr common) { jmp_buf* jumpBufferPtr = static_cast<jmp_buf*>(common->client_data); longjmp(*jumpBufferPtr, -1); }
// PNG function for error handling static void png_cpexcept_error(png_structp png_ptr, png_const_charp msg) { os::Printer::log("PNG fatal error", msg, ELL_ERROR); longjmp(png_jmpbuf(png_ptr), 1); }
void check(CONTEXT * pContext) { #ifdef _M_IX86 ok(pContext->ContextFlags == CONTEXT_FULL, "ContextFlags=0x%lx\n", pContext->ContextFlags); /* Random data segments */ ok((pContext->SegGs & NTC_SEGMENT_BITS) == (continueContext.SegGs & NTC_SEGMENT_BITS), "SegGs=0x%lx / 0x%lx\n", pContext->SegGs, continueContext.SegGs); ok((pContext->SegFs & NTC_SEGMENT_BITS) == (continueContext.SegFs & NTC_SEGMENT_BITS), "SegFs=0x%lx / 0x%lx\n", pContext->SegFs, continueContext.SegFs); ok((pContext->SegEs & NTC_SEGMENT_BITS) == (continueContext.SegEs & NTC_SEGMENT_BITS), "SegEs=0x%lx / 0x%lx\n", pContext->SegEs, continueContext.SegEs); ok((pContext->SegDs & NTC_SEGMENT_BITS) == (continueContext.SegDs & NTC_SEGMENT_BITS), "SegDs=0x%lx / 0x%lx\n", pContext->SegDs, continueContext.SegDs); /* Integer registers */ ok(pContext->Edi == continueContext.Edi, "Edi: 0x%lx != 0x%lx\n", pContext->Edi, continueContext.Edi); ok(pContext->Esi == continueContext.Esi, "Esi: 0x%lx != 0x%lx\n", pContext->Esi, continueContext.Esi); ok(pContext->Ebx == continueContext.Ebx, "Ebx: 0x%lx != 0x%lx\n", pContext->Ebx, continueContext.Ebx); ok(pContext->Edx == continueContext.Edx, "Edx: 0x%lx != 0x%lx\n", pContext->Edx, continueContext.Edx); ok(pContext->Ecx == continueContext.Ecx, "Ecx: 0x%lx != 0x%lx\n", pContext->Ecx, continueContext.Ecx); ok(pContext->Eax == continueContext.Eax, "Eax: 0x%lx != 0x%lx\n", pContext->Eax, continueContext.Eax); /* Control registers and segments */ ok(pContext->Ebp == continueContext.Ebp, "Ebp: 0x%lx != 0x%lx\n", pContext->Ebp, continueContext.Ebp); ok(pContext->Eip == continueContext.Eip, "Eip: 0x%lx != 0x%lx\n", pContext->Eip, continueContext.Eip); ok(pContext->Esp == continueContext.Esp, "Esp: 0x%lx != 0x%lx\n", pContext->Esp, continueContext.Esp); ok((pContext->SegCs & NTC_SEGMENT_BITS) == (continueContext.SegCs & NTC_SEGMENT_BITS), "SegCs: 0x%lx != 0x%lx\n", pContext->SegCs, continueContext.SegCs); ok((pContext->EFlags & NTC_EFLAGS_BITS) == (continueContext.EFlags & NTC_EFLAGS_BITS), "EFlags: 0x%lx != 0x%lx\n", pContext->EFlags, continueContext.EFlags); ok((pContext->SegSs & NTC_SEGMENT_BITS) == (continueContext.SegSs & NTC_SEGMENT_BITS), "SegSs: 0x%lx != 0x%lx\n", pContext->SegSs, continueContext.SegSs); #endif /* Return where we came from */ longjmp(jmpbuf, 1); }
static void error_exit( j_common_ptr cinfo ) { writer< Device, jpeg_tag >* mgr = reinterpret_cast< writer< Device, jpeg_tag >* >( cinfo->client_data ); longjmp( mgr->_mark, 1 ); }
// Override the standard error method in the IJG JPEG decoder code. void error_exit(j_common_ptr cinfo) { // Return control to the setjmp point. decoder_error_mgr *err = (decoder_error_mgr *) cinfo->err; longjmp(err->setjmp_buffer, -1); }
static void cld_handler(int n) { longjmp(jbuf, 1); }
void PNGImageDecoder::headerAvailable() { png_structp png = m_reader->pngPtr(); png_infop info = m_reader->infoPtr(); png_uint_32 width = png_get_image_width(png, info); png_uint_32 height = png_get_image_height(png, info); // Protect against large PNGs. See http://bugzil.la/251381 for more details. const unsigned long maxPNGSize = 1000000UL; if (width > maxPNGSize || height > maxPNGSize) { longjmp(JMPBUF(png), 1); return; } // Set the image size now that the image header is available. if (!setSize(width, height)) { longjmp(JMPBUF(png), 1); return; } int bitDepth, colorType, interlaceType, compressionType, filterType, channels; png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceType, &compressionType, &filterType); // The options we set here match what Mozilla does. // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA. if (colorType == PNG_COLOR_TYPE_PALETTE || (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8)) png_set_expand(png); png_bytep trns = 0; int trnsCount = 0; if (png_get_valid(png, info, PNG_INFO_tRNS)) { png_get_tRNS(png, info, &trns, &trnsCount, 0); png_set_expand(png); } if (bitDepth == 16) png_set_strip_16(png); if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png); #if USE(QCMSLIB) if ((colorType & PNG_COLOR_MASK_COLOR) && !m_ignoreGammaAndColorProfile) { // We only support color profiles for color PALETTE and RGB[A] PNG. Supporting // color profiles for gray-scale images is slightly tricky, at least using the // CoreGraphics ICC library, because we expand gray-scale images to RGB but we // do not similarly transform the color profile. We'd either need to transform // the color profile or we'd need to decode into a gray-scale image buffer and // hand that to CoreGraphics. bool sRGB = false; ColorProfile colorProfile; getColorProfile(png, info, colorProfile, sRGB); bool imageHasAlpha = (colorType & PNG_COLOR_MASK_ALPHA) || trnsCount; m_reader->createColorTransform(colorProfile, imageHasAlpha, sRGB); m_hasColorProfile = !!m_reader->colorTransform(); } #endif if (!m_hasColorProfile) { // Deal with gamma and keep it under our control. const double inverseGamma = 0.45455; const double defaultGamma = 2.2; double gamma; if (!m_ignoreGammaAndColorProfile && png_get_gAMA(png, info, &gamma)) { const double maxGamma = 21474.83; if ((gamma <= 0.0) || (gamma > maxGamma)) { gamma = inverseGamma; png_set_gAMA(png, info, gamma); } png_set_gamma(png, defaultGamma, gamma); } else { png_set_gamma(png, defaultGamma, inverseGamma); } } // Tell libpng to send us rows for interlaced pngs. if (interlaceType == PNG_INTERLACE_ADAM7) png_set_interlace_handling(png); // Update our info now. png_read_update_info(png, info); channels = png_get_channels(png, info); ASSERT(channels == 3 || channels == 4); m_reader->setHasAlpha(channels == 4); if (m_reader->decodingSizeOnly()) { // If we only needed the size, halt the reader. #if PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 5) // '0' argument to png_process_data_pause means: Do not cache unprocessed data. m_reader->setReadOffset(m_reader->currentBufferSize() - png_process_data_pause(png, 0)); #else m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size); png->buffer_size = 0; #endif } }
/*ARGSUSED*/ static void * mdb_umem_handler(size_t nbytes, size_t align, uint_t flags) { #ifdef _KMDB /* * kmdb has a fixed, dedicated VA range in which to play. This range * won't change size while the debugger is running, regardless of how * long we wait. As a result, the only sensible course of action is * to fail the request. If we're here, however, the request was made * with UM_SLEEP. The caller is thus not expecting a NULL back. We'll * have to fail the current dcmd set. */ if (mdb.m_depth > 0) { warn("failed to allocate %lu bytes -- recovering\n", (ulong_t)nbytes); kmdb_print_stack(); longjmp(mdb.m_frame->f_pcb, MDB_ERR_NOMEM); } #else /* * mdb, on the other hand, can afford to wait, as someone may actually * free something. */ if (errno == EAGAIN) { void *ptr = NULL; char buf[64]; (void) mdb_iob_snprintf(buf, sizeof (buf), "[ sleeping for %lu bytes of free memory ... ]", (ulong_t)nbytes); (void) mdb_iob_puts(mdb.m_err, buf); (void) mdb_iob_flush(mdb.m_err); do { (void) poll(NULL, 0, 1000); if (align != 0) ptr = memalign(align, nbytes); else ptr = malloc(nbytes); } while (ptr == NULL && errno == EAGAIN); if (ptr != NULL) return (ptr); (void) memset(buf, '\b', strlen(buf)); (void) mdb_iob_puts(mdb.m_err, buf); (void) mdb_iob_flush(mdb.m_err); (void) memset(buf, ' ', strlen(buf)); (void) mdb_iob_puts(mdb.m_err, buf); (void) mdb_iob_flush(mdb.m_err); (void) memset(buf, '\b', strlen(buf)); (void) mdb_iob_puts(mdb.m_err, buf); (void) mdb_iob_flush(mdb.m_err); } #endif die("failed to allocate %lu bytes -- terminating\n", (ulong_t)nbytes); /*NOTREACHED*/ return (NULL); }
void jpegErrorExit(j_common_ptr compressData) { JPEGCompressErrorMgr *err = static_cast<JPEGCompressErrorMgr*>(compressData->err); longjmp(err->m_setjmpBuffer, -1); }
static void sig_alrm(int signo){ longjmp(env_alrm,1); }
void Host_Abort (void) { longjmp (host_abort, 1); }
static void my_error_exit(j_common_ptr cinfo) { my_error_ptr myerr = (my_error_ptr) cinfo->err; (*cinfo->err->format_message)(cinfo, emsg); longjmp(myerr->setjmp_buffer, 1); }
static void interrupt(int sig) { longjmp(jmpbuf, 1); }
/* * Exit error handler for libjpeg */ static void user_error_exit(j_common_ptr p_jpeg) { jpeg_sys_t *p_sys = (jpeg_sys_t *)p_jpeg->err; p_sys->err.output_message(p_jpeg); longjmp(p_sys->setjmp_buffer, 1); }
void PNGImageDecoder::headerAvailable() { png_structp png = m_reader->pngPtr(); png_infop info = m_reader->infoPtr(); png_uint_32 width = png->width; png_uint_32 height = png->height; // Protect against large images. if (png->width > cMaxPNGSize || png->height > cMaxPNGSize) { longjmp(png->jmpbuf, 1); return; } // We can fill in the size now that the header is available. Avoid memory // corruption issues by neutering setFailed() during this call; if we don't // do this, failures will cause |m_reader| to be deleted, and our jmpbuf // will cease to exist. Note that we'll still properly set the failure flag // in this case as soon as we longjmp(). m_doNothingOnFailure = true; bool result = setSize(width, height); m_doNothingOnFailure = false; if (!result) { longjmp(png->jmpbuf, 1); return; } int bitDepth, colorType, interlaceType, compressionType, filterType, channels; png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceType, &compressionType, &filterType); // The options we set here match what Mozilla does. // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA. if (colorType == PNG_COLOR_TYPE_PALETTE || (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8)) png_set_expand(png); png_bytep trns = 0; int trnsCount = 0; if (png_get_valid(png, info, PNG_INFO_tRNS)) { png_get_tRNS(png, info, &trns, &trnsCount, 0); png_set_expand(png); } if (bitDepth == 16) png_set_strip_16(png); if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png); // Deal with gamma and keep it under our control. double gamma; if (png_get_gAMA(png, info, &gamma)) { if ((gamma <= 0.0) || (gamma > cMaxGamma)) { gamma = cInverseGamma; png_set_gAMA(png, info, gamma); } png_set_gamma(png, cDefaultGamma, gamma); } else png_set_gamma(png, cDefaultGamma, cInverseGamma); // Tell libpng to send us rows for interlaced pngs. if (interlaceType == PNG_INTERLACE_ADAM7) png_set_interlace_handling(png); // Update our info now. png_read_update_info(png, info); channels = png_get_channels(png, info); ASSERT(channels == 3 || channels == 4); m_reader->setHasAlpha(channels == 4); if (m_reader->decodingSizeOnly()) { // If we only needed the size, halt the reader. m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size); png->buffer_size = 0; } }
int call_longjmp (jmp_buf *buf) { longjmps++; longjmp (*buf, 1); }