pic_value pic_apply(pic_state *pic, struct pic_proc *proc, pic_value argv) { struct pic_code *pc, c; int ai = pic_gc_arena_preserve(pic); jmp_buf jmp; size_t argc, i; struct pic_code boot[2]; #if PIC_DIRECT_THREADED_VM static void *oplabels[] = { &&L_OP_POP, &&L_OP_PUSHNIL, &&L_OP_PUSHTRUE, &&L_OP_PUSHFALSE, &&L_OP_PUSHFLOAT, &&L_OP_PUSHINT, &&L_OP_PUSHCHAR, &&L_OP_PUSHCONST, &&L_OP_GREF, &&L_OP_GSET, &&L_OP_LREF, &&L_OP_LSET, &&L_OP_CREF, &&L_OP_CSET, &&L_OP_JMP, &&L_OP_JMPIF, &&L_OP_CALL, &&L_OP_TAILCALL, &&L_OP_RET, &&L_OP_LAMBDA, &&L_OP_CONS, &&L_OP_CAR, &&L_OP_CDR, &&L_OP_NILP, &&L_OP_ADD, &&L_OP_SUB, &&L_OP_MUL, &&L_OP_DIV, &&L_OP_EQ, &&L_OP_LT, &&L_OP_LE, &&L_OP_STOP }; #endif if (setjmp(jmp) == 0) { pic->jmp = &jmp; } else { goto L_RAISE; } argc = pic_length(pic, argv) + 1; #if VM_DEBUG puts("== booting VM..."); printf(" proc = "); pic_debug(pic, pic_obj_value(proc)); puts(""); printf(" argv = "); pic_debug(pic, argv); puts(""); printf(" irep = "); print_irep(pic, proc->u.irep); puts("\nLet's go!"); #endif PUSH(pic_obj_value(proc)); for (i = 1; i < argc; ++i) { PUSH(pic_car(pic, argv)); argv = pic_cdr(pic, argv); } /* boot! */ boot[0].insn = OP_CALL; boot[0].u.i = argc; boot[1].insn = OP_STOP; pc = boot; c = *pc; goto L_CALL; VM_LOOP { CASE(OP_POP) { POPN(1); NEXT; } CASE(OP_PUSHNIL) { PUSH(pic_nil_value()); NEXT; } CASE(OP_PUSHTRUE) { PUSH(pic_true_value()); NEXT; } CASE(OP_PUSHFALSE) { PUSH(pic_false_value()); NEXT; } CASE(OP_PUSHFLOAT) { PUSH(pic_float_value(c.u.f)); NEXT; } CASE(OP_PUSHINT) { PUSH(pic_int_value(c.u.i)); NEXT; } CASE(OP_PUSHCHAR) { PUSH(pic_char_value(c.u.c)); NEXT; } CASE(OP_PUSHCONST) { PUSH(pic->pool[c.u.i]); NEXT; } CASE(OP_GREF) { PUSH(pic->globals[c.u.i]); NEXT; } CASE(OP_GSET) { pic->globals[c.u.i] = POP(); NEXT; } CASE(OP_LREF) { PUSH(pic->ci->fp[c.u.i]); NEXT; } CASE(OP_LSET) { pic->ci->fp[c.u.i] = POP(); NEXT; } CASE(OP_CREF) { int depth = c.u.r.depth; struct pic_env *env; env = pic->ci->env; while (depth--) { env = env->up; } PUSH(env->values[c.u.r.idx]); NEXT; } CASE(OP_CSET) { int depth = c.u.r.depth; struct pic_env *env; env = pic->ci->env; while (depth--) { env = env->up; } env->values[c.u.r.idx] = POP(); NEXT; } CASE(OP_JMP) { pc += c.u.i; JUMP; } CASE(OP_JMPIF) { pic_value v; v = POP(); if (! pic_false_p(v)) { pc += c.u.i; JUMP; } NEXT; } CASE(OP_CALL) { pic_value x, v; pic_callinfo *ci; struct pic_proc *proc; L_CALL: x = pic->sp[-c.u.i]; if (! pic_proc_p(x)) { pic->errmsg = "invalid application"; goto L_RAISE; } proc = pic_proc_ptr(x); ci = PUSHCI(); ci->argc = c.u.i; ci->pc = pc; ci->fp = pic->sp - c.u.i; ci->env = NULL; if (pic_proc_cfunc_p(x)) { v = proc->u.cfunc(pic); pic->sp = ci->fp; POPCI(); PUSH(v); pic_gc_arena_restore(pic, ai); NEXT; } else { int i; pic_value rest; if (ci->argc != proc->u.irep->argc) { if (! (proc->u.irep->varg && ci->argc >= proc->u.irep->argc)) { pic->errmsg = "wrong number of arguments"; goto L_RAISE; } } /* prepare rest args */ if (proc->u.irep->varg) { rest = pic_nil_value(); for (i = 0; i < ci->argc - proc->u.irep->argc; ++i) { pic_gc_protect(pic, v = POP()); rest = pic_cons(pic, v, rest); } PUSH(rest); } /* prepare env */ if (proc->u.irep->cv_num == 0) { ci->env = proc->env; } else { ci->env = (struct pic_env *)pic_obj_alloc(pic, sizeof(struct pic_env), PIC_TT_ENV); ci->env->up = proc->env; ci->env->valuec = proc->u.irep->cv_num; ci->env->values = (pic_value *)pic_calloc(pic, ci->env->valuec, sizeof(pic_value)); for (i = 0; i < ci->env->valuec; ++i) { ci->env->values[i] = ci->fp[proc->u.irep->cv_tbl[i]]; } } pc = proc->u.irep->code; pic_gc_arena_restore(pic, ai); JUMP; } } CASE(OP_TAILCALL) { int argc; pic_value *argv; argc = c.u.i; argv = pic->sp - argc; for (i = 0; i < argc; ++i) { pic->ci->fp[i] = argv[i]; } pic->sp = pic->ci->fp + argc; pc = POPCI()->pc; /* c is not changed */ goto L_CALL; } CASE(OP_RET) { pic_value v; pic_callinfo *ci; if (pic->errmsg) { L_RAISE: goto L_STOP; } else { v = POP(); ci = POPCI(); pc = ci->pc; pic->sp = ci->fp; PUSH(v); } NEXT; } CASE(OP_LAMBDA) { struct pic_proc *proc; proc = pic_proc_new(pic, pic->irep[c.u.i], pic->ci->env); PUSH(pic_obj_value(proc)); pic_gc_arena_restore(pic, ai); NEXT; } CASE(OP_CONS) { pic_value a, b; pic_gc_protect(pic, b = POP()); pic_gc_protect(pic, a = POP()); PUSH(pic_cons(pic, a, b)); pic_gc_arena_restore(pic, ai); NEXT; } CASE(OP_CAR) { pic_value p; p = POP(); PUSH(pic_car(pic, p)); NEXT; } CASE(OP_CDR) { pic_value p; p = POP(); PUSH(pic_cdr(pic, p)); NEXT; } CASE(OP_NILP) { pic_value p; p = POP(); PUSH(pic_bool_value(pic_nil_p(p))); NEXT; } #define DEFINE_ARITH_OP(opcode, op) \ CASE(opcode) { \ pic_value a, b; \ b = POP(); \ a = POP(); \ if (pic_int_p(a) && pic_int_p(b)) { \ double f = (double)pic_int(a) op (double)pic_int(b); \ if (INT_MIN <= f && f <= INT_MAX) { \ PUSH(pic_int_value((int)f)); \ } \ else { \ PUSH(pic_float_value(f)); \ } \ } \ else if (pic_float_p(a) && pic_float_p(b)) { \ PUSH(pic_float_value(pic_float(a) op pic_float(b))); \ } \ else if (pic_int_p(a) && pic_float_p(b)) { \ PUSH(pic_float_value(pic_int(a) op pic_float(b))); \ } \ else if (pic_float_p(a) && pic_int_p(b)) { \ PUSH(pic_float_value(pic_float(a) op pic_int(b))); \ } \ else { \ pic->errmsg = #op " got non-number operands"; \ goto L_RAISE; \ } \ NEXT; \ } DEFINE_ARITH_OP(OP_ADD, +); DEFINE_ARITH_OP(OP_SUB, -); DEFINE_ARITH_OP(OP_MUL, *); /* special care for (int / int) division */ CASE(OP_DIV) { pic_value a, b; b = POP(); a = POP(); if (pic_int_p(a) && pic_int_p(b)) { PUSH(pic_float_value((double)pic_int(a) / pic_int(b))); } else if (pic_float_p(a) && pic_float_p(b)) { PUSH(pic_float_value(pic_float(a) / pic_float(b))); } else if (pic_int_p(a) && pic_float_p(b)) { PUSH(pic_float_value(pic_int(a) / pic_float(b))); } else if (pic_float_p(a) && pic_int_p(b)) { PUSH(pic_float_value(pic_float(a) / pic_int(b))); } else { pic->errmsg = "/ got non-number operands"; goto L_RAISE; } NEXT; } #define DEFINE_COMP_OP(opcode, op) \ CASE(opcode) { \ pic_value a, b; \ b = POP(); \ a = POP(); \ if (pic_int_p(a) && pic_int_p(b)) { \ PUSH(pic_bool_value(pic_int(a) op pic_int(b))); \ } \ else if (pic_float_p(a) && pic_float_p(b)) { \ PUSH(pic_bool_value(pic_float(a) op pic_float(b))); \ } \ else if (pic_int_p(a) && pic_int_p(b)) { \ PUSH(pic_bool_value(pic_int(a) op pic_float(b))); \ } \ else if (pic_float_p(a) && pic_int_p(b)) { \ PUSH(pic_bool_value(pic_float(a) op pic_int(b))); \ } \ else { \ pic->errmsg = #op " got non-number operands"; \ goto L_RAISE; \ } \ NEXT; \ } DEFINE_COMP_OP(OP_EQ, ==); DEFINE_COMP_OP(OP_LT, <); DEFINE_COMP_OP(OP_LE, <=); CASE(OP_STOP) { pic_value val; L_STOP: val = POP(); pic->jmp = NULL; if (pic->errmsg) { return pic_undef_value(); } #if VM_DEBUG puts("**VM END STATE**"); printf("stbase\t= %p\nsp\t= %p\n", pic->stbase, pic->sp); printf("cibase\t= %p\nci\t= %p\n", pic->cibase, pic->ci); if (pic->stbase < pic->sp) { pic_value *sp; printf("* stack trace:"); for (sp = pic->stbase; pic->sp != sp; ++sp) { pic_debug(pic, *sp); puts(""); } } if (pic->stbase > pic->sp) { puts("*** stack underflow!"); } #endif pic_gc_protect(pic, val); return val; } } VM_LOOP_END; }
static vpx_codec_err_t vp8_decode(vpx_codec_alg_priv_t *ctx, const uint8_t *data, unsigned int data_sz, void *user_priv, long deadline) { vpx_codec_err_t res = VPX_CODEC_OK; unsigned int resolution_change = 0; unsigned int w, h; if (!ctx->fragments.enabled && (data == NULL && data_sz == 0)) { return 0; } /* Update the input fragment data */ if(update_fragments(ctx, data, data_sz, &res) <= 0) return res; /* Determine the stream parameters. Note that we rely on peek_si to * validate that we have a buffer that does not wrap around the top * of the heap. */ w = ctx->si.w; h = ctx->si.h; res = vp8_peek_si_internal(ctx->fragments.ptrs[0], ctx->fragments.sizes[0], &ctx->si, ctx->decrypt_cb, ctx->decrypt_state); if((res == VPX_CODEC_UNSUP_BITSTREAM) && !ctx->si.is_kf) { /* the peek function returns an error for non keyframes, however for * this case, it is not an error */ res = VPX_CODEC_OK; } if(!ctx->decoder_init && !ctx->si.is_kf) res = VPX_CODEC_UNSUP_BITSTREAM; if ((ctx->si.h != h) || (ctx->si.w != w)) resolution_change = 1; /* Initialize the decoder instance on the first frame*/ if (!res && !ctx->decoder_init) { VP8D_CONFIG oxcf; oxcf.Width = ctx->si.w; oxcf.Height = ctx->si.h; oxcf.Version = 9; oxcf.postprocess = 0; oxcf.max_threads = ctx->cfg.threads; oxcf.error_concealment = (ctx->base.init_flags & VPX_CODEC_USE_ERROR_CONCEALMENT); /* If postprocessing was enabled by the application and a * configuration has not been provided, default it. */ if (!ctx->postproc_cfg_set && (ctx->base.init_flags & VPX_CODEC_USE_POSTPROC)) { ctx->postproc_cfg.post_proc_flag = VP8_DEBLOCK | VP8_DEMACROBLOCK | VP8_MFQE; ctx->postproc_cfg.deblocking_level = 4; ctx->postproc_cfg.noise_level = 0; } res = vp8_create_decoder_instances(&ctx->yv12_frame_buffers, &oxcf); ctx->decoder_init = 1; } /* Set these even if already initialized. The caller may have changed the * decrypt config between frames. */ if (ctx->decoder_init) { ctx->yv12_frame_buffers.pbi[0]->decrypt_cb = ctx->decrypt_cb; ctx->yv12_frame_buffers.pbi[0]->decrypt_state = ctx->decrypt_state; } if (!res) { VP8D_COMP *pbi = ctx->yv12_frame_buffers.pbi[0]; if (resolution_change) { VP8_COMMON *const pc = & pbi->common; MACROBLOCKD *const xd = & pbi->mb; #if CONFIG_MULTITHREAD int i; #endif pc->Width = ctx->si.w; pc->Height = ctx->si.h; { int prev_mb_rows = pc->mb_rows; if (setjmp(pbi->common.error.jmp)) { pbi->common.error.setjmp = 0; vp8_clear_system_state(); /* same return value as used in vp8dx_receive_compressed_data */ return -1; } pbi->common.error.setjmp = 1; if (pc->Width <= 0) { pc->Width = w; vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, "Invalid frame width"); } if (pc->Height <= 0) { pc->Height = h; vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, "Invalid frame height"); } if (vp8_alloc_frame_buffers(pc, pc->Width, pc->Height)) vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR, "Failed to allocate frame buffers"); xd->pre = pc->yv12_fb[pc->lst_fb_idx]; xd->dst = pc->yv12_fb[pc->new_fb_idx]; #if CONFIG_MULTITHREAD for (i = 0; i < pbi->allocated_decoding_thread_count; i++) { pbi->mb_row_di[i].mbd.dst = pc->yv12_fb[pc->new_fb_idx]; vp8_build_block_doffsets(&pbi->mb_row_di[i].mbd); } #endif vp8_build_block_doffsets(&pbi->mb); /* allocate memory for last frame MODE_INFO array */ #if CONFIG_ERROR_CONCEALMENT if (pbi->ec_enabled) { /* old prev_mip was released by vp8_de_alloc_frame_buffers() * called in vp8_alloc_frame_buffers() */ pc->prev_mip = vpx_calloc( (pc->mb_cols + 1) * (pc->mb_rows + 1), sizeof(MODE_INFO)); if (!pc->prev_mip) { vp8_de_alloc_frame_buffers(pc); vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR, "Failed to allocate" "last frame MODE_INFO array"); } pc->prev_mi = pc->prev_mip + pc->mode_info_stride + 1; if (vp8_alloc_overlap_lists(pbi)) vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR, "Failed to allocate overlap lists " "for error concealment"); } #endif #if CONFIG_MULTITHREAD if (pbi->b_multithreaded_rd) vp8mt_alloc_temp_buffers(pbi, pc->Width, prev_mb_rows); #else (void)prev_mb_rows; #endif } pbi->common.error.setjmp = 0; /* required to get past the first get_free_fb() call */ pbi->common.fb_idx_ref_cnt[0] = 0; } /* update the pbi fragment data */ pbi->fragments = ctx->fragments; ctx->user_priv = user_priv; if (vp8dx_receive_compressed_data(pbi, data_sz, data, deadline)) { res = update_error_state(ctx, &pbi->common.error); } /* get ready for the next series of fragments */ ctx->fragments.count = 0; } return res; }
void Congrd1(ASL_fg *asl, int i, real *X, real *G, fint *nerror) { Jmp_buf err_jmp0; cde *d; cgrad *gr, *gr1; int i0, ij, j, *vmi, xksave; real *Adjoints, *vscale; size_t L; if (nerror && *nerror >= 0) { err_jmp = &err_jmp0; ij = setjmp(err_jmp0.jb); if ((*nerror = ij)) return; } errno = 0; /* in case f77 set errno opening files */ if (!asl->i.x_known) x0_check_ASL(asl,X); if ((!asl->i.ncxval || asl->i.ncxval[i] != asl->i.nxval) && (!(x0kind & ASL_have_conval) || i < n_conjac[0] || i >= n_conjac[1])) { xksave = asl->i.x_known; asl->i.x_known = 1; con1ival((ASL*)asl,i,X,nerror); asl->i.x_known = xksave; if (nerror && *nerror) return; } if (asl->i.Derrs) deriv_errchk_ASL((ASL*)asl, nerror, i, 1); if (!(x0kind & ASL_have_funnel)) { if (f_b) funnelset_ASL(asl, f_b); if (f_c) funnelset_ASL(asl, f_c); x0kind |= ASL_have_funnel; } Adjoints = adjoints; d = &con_de[i]; gr1 = asl->i.Cgrad0[i]; for(gr = gr1; gr; gr = gr->next) Adjoints[gr->varno] = gr->coef; if ((L = d->zaplen)) { memset(adjoints_nv1, 0, L); derprop(d->d); } vmi = 0; if (asl->i.vmap) vmi = get_vminv_ASL((ASL*)asl); if ((vscale = asl->i.vscale)) { if (vmi) for(gr = gr1; gr; gr = gr->next) { i0 = gr->varno; Adjoints[i0] *= vscale[vmi[i0]]; } else for(gr = gr1; gr; gr = gr->next) { i0 = gr->varno; Adjoints[i0] *= vscale[i0]; } } gr = gr1; i0 = 0; switch(asl->i.congrd_mode) { case 1: for(; gr; gr = gr->next) G[i0++] = Adjoints[gr->varno]; break; case 2: for(; gr; gr = gr->next) G[gr->goff] = Adjoints[gr->varno]; break; default: if (vmi) { for(; gr; gr = gr->next) { i = vmi[j = gr->varno]; while(i0 < i) G[i0++] = 0; G[i] = Adjoints[j]; i0 = i + 1; } } else for(; gr; gr = gr->next) { i = gr->varno; while(i0 < i) G[i0++] = 0; G[i] = Adjoints[i]; i0 = i + 1; } i = n_var; while(i0 < i) G[i0++] = 0; } err_jmp = 0; }
void Screendump(const char* destFile, const int width, const int height) { std::string fname = join_path(GetPiUserDir("screenshots").c_str(), destFile, 0); // pad rows to 4 bytes, which is the default row alignment for OpenGL const int stride = (3*width + 3) & ~3; std::vector<png_byte> pixel_data(stride * height); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); glPixelStorei(GL_PACK_ALIGNMENT, 4); // never trust defaults glReadBuffer(GL_FRONT); glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, &pixel_data[0]); glFinish(); png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0); if (!png_ptr) { fprintf(stderr, "Couldn't create png_write_struct\n"); return; } png_infop info_ptr = png_create_info_struct(png_ptr); if (!info_ptr) { png_destroy_write_struct(&png_ptr, 0); fprintf(stderr, "Couldn't create png_info_struct\n"); return; } //http://www.libpng.org/pub/png/libpng-1.2.5-manual.html#section-3.1 if (setjmp(png_jmpbuf(png_ptr))) { png_destroy_write_struct(&png_ptr, &info_ptr); fprintf(stderr, "Couldn't set png jump buffer\n"); return; } FILE *out = fopen(fname.c_str(), "wb"); if (!out) { png_destroy_write_struct(&png_ptr, &info_ptr); fprintf(stderr, "Couldn't open %s for writing\n", fname.c_str()); return; } png_init_io(png_ptr, out); png_set_filter(png_ptr, 0, PNG_FILTER_NONE); png_set_IHDR(png_ptr, info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); png_bytepp rows = new png_bytep[height]; for (int i = 0; i < height; ++i) { rows[i] = reinterpret_cast<png_bytep>(&pixel_data[(height-i-1) * stride]); } png_set_rows(png_ptr, info_ptr, rows); png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0); png_destroy_write_struct(&png_ptr, &info_ptr); delete[] rows; fclose(out); printf("Screenshot %s saved\n", fname.c_str()); }
static gint32 load_image (char *filename) { GPixelRgn pixel_rgn; TileDrawable *drawable; gint32 image_ID; gint32 layer_ID; struct jpeg_decompress_struct cinfo; struct my_error_mgr jerr; FILE *infile; guchar *buf; guchar **rowbuf; char *name; int image_type; int layer_type; int tile_height; int scanlines; int i, start, end; int m; int depth = 8; /* We set up the normal JPEG error routines. */ cinfo.err = jpeg_std_error (&jerr.pub); jerr.pub.error_exit = my_error_exit; if ((infile = fopen (filename, "rb")) == NULL) { g_warning ("can't open \"%s\"\n", filename); gimp_quit (); } if( strrchr(filename,'.') && strcmp( strrchr(filename, '.'), ".jp4") == 0 ) depth = 16; name = malloc (strlen (filename) + 12); sprintf (name, "%s %s:", _("Loading"), filename); gimp_progress_init (name); free (name); image_ID = -1; /* Establish the setjmp return context for my_error_exit to use. */ if (setjmp (jerr.setjmp_buffer)) { /* If we get here, the JPEG code has signaled an error. * We need to clean up the JPEG object, close the input file, and return. */ jpeg_destroy_decompress (&cinfo); if (infile) fclose (infile); if (image_ID != -1) gimp_image_delete (image_ID); gimp_quit (); } /* Now we can initialize the JPEG decompression object. */ jpeg_create_decompress (&cinfo); /* Step 2: specify data source (eg, a file) */ jpeg_stdio_src (&cinfo, infile); setup_read_icc_profile(&cinfo); for (m = 0; m < 16; m++) jpeg_save_markers(&cinfo, JPEG_APP0 + m, 0xFFFF); /* Step 3: read file parameters with jpeg_read_header() */ (void) jpeg_read_header (&cinfo, TRUE); /* We can ignore the return value from jpeg_read_header since * (a) suspension is not possible with the stdio data source, and * (b) we passed TRUE to reject a tables-only JPEG file as an error. * See libjpeg.doc for more info. */ /* Step 4: set parameters for decompression */ /* In this example, we don't need to change any of the defaults set by * jpeg_read_header(), so we do nothing here. */ prepareColour( &cinfo ); /* Step 5: Start decompressor */ jpeg_start_decompress (&cinfo); /* We may need to do some setup of our own at this point before reading * the data. After jpeg_start_decompress() we have the correct scaled * output image dimensions available, as well as the output colormap * if we asked for color quantization. * In this example, we need to make an output work buffer of the right size. */ /* temporary buffer */ tile_height = gimp_tile_height (); buf = g_new (guchar, tile_height * cinfo.output_width * cinfo.output_components); rowbuf = g_new (guchar*, tile_height); for (i = 0; i < tile_height; i++) rowbuf[i] = buf + cinfo.output_width * cinfo.output_components * i; /* Create a new image of the proper size and associate the filename with it. */ if(depth == 8) { switch (cinfo.output_components) { case 1: image_type = GRAY; layer_type = GRAY_IMAGE; break; case 3: image_type = RGB; layer_type = RGB_IMAGE; break; case 4: image_type = RGB; layer_type = RGBA_IMAGE; break; default: gimp_quit (); } } else { switch (cinfo.output_components) { case 1: image_type = U16_GRAY; layer_type = U16_GRAY_IMAGE; break; case 3: image_type = U16_RGB; layer_type = U16_RGB_IMAGE; break; case 4: image_type = U16_RGB; layer_type = U16_RGBA_IMAGE; break; default: gimp_quit (); } } image_ID = gimp_image_new (cinfo.output_width / (depth/8), cinfo.output_height, image_type); gimp_image_set_filename (image_ID, filename); layer_ID = gimp_layer_new (image_ID, _("Background"), cinfo.output_width / (depth/8), cinfo.output_height, layer_type, 100, NORMAL_MODE); gimp_image_add_layer (image_ID, layer_ID, 0); drawable = gimp_drawable_get (layer_ID); gimp_pixel_rgn_init (&pixel_rgn, drawable, 0, 0, drawable->width, drawable->height, TRUE, FALSE); /* Step 6: while (scan lines remain to be read) */ /* jpeg_read_scanlines(...); */ /* Here we use the library's state variable cinfo.output_scanline as the * loop counter, so that we don't have to keep track ourselves. */ while (cinfo.output_scanline < cinfo.output_height) { start = cinfo.output_scanline; end = cinfo.output_scanline + tile_height; end = MIN (end,CAST(int) cinfo.output_height); scanlines = end - start; for (i = 0; i < scanlines; i++) jpeg_read_scanlines (&cinfo, (JSAMPARRAY) &rowbuf[i], 1); /* for (i = start; i < end; i++) gimp_pixel_rgn_set_row (&pixel_rgn, tilerow[i - start], 0, i, drawable->width); */ if(cinfo.out_color_space == JCS_CMYK) for(i = 0; i < scanlines*drawable->width*cinfo.output_components; ++i) buf[i] = 255 - buf[i]; if(depth == 16 && 0) for(i = 0; i < scanlines*drawable->width*cinfo.output_components; ++i) { unsigned char c = buf[2*i]; buf[2*i] = buf[2*i+1]; buf[2*i+1] = c; } gimp_pixel_rgn_set_rect (&pixel_rgn, buf, 0, start, drawable->width, scanlines); gimp_progress_update ((double) cinfo.output_scanline / (double) cinfo.output_height); } // Step 6a: read icc profile { LPBYTE Buffer = NULL; size_t Len = 0; cmsHPROFILE hProfile=NULL; if (read_icc_profile(&cinfo, &Buffer, &Len)) { printf ("%s:%d %s() embedded profile found\n",__FILE__,__LINE__,__func__); } else if (read_icc_profile2(&cinfo, &Buffer, &Len)) { printf ("%s:%d %s() default profile selected\n",__FILE__,__LINE__,__func__); } if(Buffer && Len) { hProfile = cmsOpenProfileFromMem(Buffer, Len); if (hProfile) { gimp_image_set_icc_profile_by_mem (image_ID, Len, Buffer, ICC_IMAGE_PROFILE); cmsCloseProfile (hProfile); free(Buffer); printf ("%s:%d %s() set profile\n",__FILE__,__LINE__,__func__); } } } /* Step 7: Finish decompression */ jpeg_finish_decompress (&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* Step 8: Release JPEG decompression object */ /* This is an important step since it will release a good deal of memory. */ jpeg_destroy_decompress (&cinfo); /* free up the temporary buffers */ g_free (rowbuf); g_free (buf); /* After finish_decompress, we can close the input file. * Here we postpone it until after no more JPEG errors are possible, * so as to simplify the setjmp error logic above. (Actually, I don't * think that jpeg_destroy can do an error exit, but why assume anything...) */ fclose (infile); /* At this point you may want to check to see whether any corrupt-data * warnings occurred (test whether jerr.num_warnings is nonzero). */ /* Tell the GIMP to display the image. */ gimp_drawable_flush (drawable); return image_ID; }
void Coro_setup(Coro *self, void *arg) { setjmp(buf); buf[8] = (int)Coro_stack(self) + (int)Coro_stackSize(self) - 16; buf[9] = (int)Coro_Start; }
// load in the image data IImage* CImageLoaderPng::loadImage(io::IReadFile* file) const { #ifdef _IRR_COMPILE_WITH_LIBPNG_ if (!file) return 0; video::IImage* image = 0; //Used to point to image rows u8** RowPointers = 0; png_byte buffer[8]; // Read the first few bytes of the PNG file if( file->read(buffer, 8) != 8 ) { os::Printer::log("LOAD PNG: can't read file\n", file->getFileName(), ELL_ERROR); return 0; } // Check if it really is a PNG file if( png_sig_cmp(buffer, 0, 8) ) { os::Printer::log("LOAD PNG: not really a png\n", file->getFileName(), ELL_ERROR); return 0; } // Allocate the png read struct png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, (png_error_ptr)png_cpexcept_error, (png_error_ptr)png_cpexcept_warn); if (!png_ptr) { os::Printer::log("LOAD PNG: Internal PNG create read struct failure\n", file->getFileName(), ELL_ERROR); return 0; } // Allocate the png info struct png_infop info_ptr = png_create_info_struct(png_ptr); if (!info_ptr) { os::Printer::log("LOAD PNG: Internal PNG create info struct failure\n", file->getFileName(), ELL_ERROR); png_destroy_read_struct(&png_ptr, NULL, NULL); return 0; } // for proper error handling if (setjmp(png_jmpbuf(png_ptr))) { png_destroy_read_struct(&png_ptr, &info_ptr, NULL); if (RowPointers) delete [] RowPointers; return 0; } // changed by zola so we don't need to have public FILE pointers png_set_read_fn(png_ptr, file, user_read_data_fcn); png_set_sig_bytes(png_ptr, 8); // Tell png that we read the signature png_read_info(png_ptr, info_ptr); // Read the info section of the png file u32 Width; u32 Height; s32 BitDepth; s32 ColorType; { // Use temporary variables to avoid passing casted pointers png_uint_32 w,h; // Extract info png_get_IHDR(png_ptr, info_ptr, &w, &h, &BitDepth, &ColorType, NULL, NULL, NULL); Width=w; Height=h; } // Convert palette color to true color if (ColorType==PNG_COLOR_TYPE_PALETTE) png_set_palette_to_rgb(png_ptr); // Convert low bit colors to 8 bit colors if (BitDepth < 8) { if (ColorType==PNG_COLOR_TYPE_GRAY || ColorType==PNG_COLOR_TYPE_GRAY_ALPHA) png_set_expand_gray_1_2_4_to_8(png_ptr); else png_set_packing(png_ptr); } if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr); // Convert high bit colors to 8 bit colors if (BitDepth == 16) png_set_strip_16(png_ptr); // Convert gray color to true color if (ColorType==PNG_COLOR_TYPE_GRAY || ColorType==PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png_ptr); int intent; const double screen_gamma = 2.2; if (png_get_sRGB(png_ptr, info_ptr, &intent)) png_set_gamma(png_ptr, screen_gamma, 0.45455); else { double image_gamma; if (png_get_gAMA(png_ptr, info_ptr, &image_gamma)) png_set_gamma(png_ptr, screen_gamma, image_gamma); else png_set_gamma(png_ptr, screen_gamma, 0.45455); } // Update the changes in between, as we need to get the new color type // for proper processing of the RGBA type png_read_update_info(png_ptr, info_ptr); { // Use temporary variables to avoid passing casted pointers png_uint_32 w,h; // Extract info png_get_IHDR(png_ptr, info_ptr, &w, &h, &BitDepth, &ColorType, NULL, NULL, NULL); Width=w; Height=h; } // Convert RGBA to BGRA if (ColorType==PNG_COLOR_TYPE_RGB_ALPHA) { #ifdef __BIG_ENDIAN__ png_set_swap_alpha(png_ptr); #else png_set_bgr(png_ptr); #endif } // Create the image structure to be filled by png data if (ColorType==PNG_COLOR_TYPE_RGB_ALPHA) image = new CImage(ECF_A8R8G8B8, core::dimension2d<u32>(Width, Height)); else image = new CImage(ECF_R8G8B8, core::dimension2d<u32>(Width, Height)); if (!image) { os::Printer::log("LOAD PNG: Internal PNG create image struct failure\n", file->getFileName(), ELL_ERROR); png_destroy_read_struct(&png_ptr, NULL, NULL); return 0; } // Create array of pointers to rows in image data RowPointers = new png_bytep[Height]; if (!RowPointers) { os::Printer::log("LOAD PNG: Internal PNG create row pointers failure\n", file->getFileName(), ELL_ERROR); png_destroy_read_struct(&png_ptr, NULL, NULL); delete image; return 0; } // Fill array of pointers to rows in image data unsigned char* data = (unsigned char*)image->lock(); for (u32 i=0; i<Height; ++i) { RowPointers[i]=data; data += image->getPitch(); } // for proper error handling if (setjmp(png_jmpbuf(png_ptr))) { png_destroy_read_struct(&png_ptr, &info_ptr, NULL); delete [] RowPointers; image->unlock(); delete [] image; return 0; } // Read data using the library function that handles all transformations including interlacing png_read_image(png_ptr, RowPointers); png_read_end(png_ptr, NULL); delete [] RowPointers; image->unlock(); png_destroy_read_struct(&png_ptr,&info_ptr, 0); // Clean up memory return image; #else return 0; #endif // _IRR_COMPILE_WITH_LIBPNG_ }
void display_loop(){ // mcuf_serial_mode(); mode = setjmp(newmode_jmpbuf); #ifdef JOYSTICK_SUPPORT // in case we get here via mode jump, we (re)enable joystick queries waitForFire = 1; #endif oldOldmode = oldMode; #ifdef JOYSTICK_SUPPORT waitForFire = 1; #endif for(;;){ #ifndef MENU_SUPPORT clear_screen(0); #endif oldMode = mode; switch(mode++) { #ifdef ANIMATION_SCROLLTEXT case 1: scrolltext(scrolltext_text); #ifdef RANDOM_SUPPORT { char a[28]; sprintf(a,"</# counter == %lu ", (unsigned long)percnt_get(&g_reset_counter, &g_reset_counter_idx)); scrolltext(a); } #endif #endif #ifdef ANIMATION_TIME #ifndef ANIMATION_SCROLLTEXT case 1: #endif time_anim(); break; #else #ifdef ANIMATION_SCROLLTEXT break; #endif #endif #ifdef ANIMATION_SPIRAL # ifndef SPIRAL_DELAY # define SPIRAL_DELAY 5 # endif case 2: spiral(SPIRAL_DELAY); break; #endif #ifdef ANIMATION_JOERN1 case 3: joern1(); break; #endif #ifdef ANIMATION_SNAKE case 4: snake_animation(); break; #endif #ifdef ANIMATION_CHECKERBOARD case 5: checkerboard(20); break; #endif #ifdef ANIMATION_FIRE case 6: fire(); break; #endif #ifdef ANIMATION_TIME case 7: time_anim(); break; #endif #ifdef ANIMATION_MATRIX case 8: matrix(); break; #endif #ifdef ANIMATION_RANDOM_BRIGHT case 9: random_bright(30); break; #endif #ifdef ANIMATION_STONEFLY case 10: stonefly(); break; #endif #ifdef ANIMATION_GAMEOFLIFE case 11: gameoflife(); break; #endif #ifdef ANIMATION_FLYINGDOTS case 12: flyingdots(); break; #endif #ifdef ANIMATION_BREAKOUT case 13: breakout_demo(); break; #endif #ifdef ANIMATION_MHERWEG case 14: mherweg(); break; #endif #ifdef ANIMATION_MOIRE case 15: moire(); break; #endif #ifdef ANIMATION_TIME case 16: time_anim(); break; #endif #ifdef ANIMATION_LTN_ANT case 17: ltn_ant(); break; #endif #ifdef ANIMATION_LABORLOGO case 18: laborlogo(); break; #endif #ifdef ANIMATION_AMPHIBIAN case 19: amphibian(); break; #endif #ifdef ANIMATION_LOGO_OOS case 20: logo_OutOfSpec(); break; #endif #ifdef ANIMATION_FAIRYDUST case 21: fairydust(); break; #endif #ifdef ANIMATION_PLASMA case 22: plasma(); break; #endif #ifdef ANIMATION_PSYCHEDELIC case 23: psychedelic(); break; #endif #ifdef ANIMATION_BLACKHOLE case 24: blackhole(); break; #endif #ifdef ANIMATION_SQUARES case 25: squares(); break; #endif #ifdef ANIMATION_DNA case 26: dna(); break; #endif #ifdef ANIMATION_TESTS case 31: test_level(1, false); break; case 32: test_level(2, false); break; case 33: test_level(3, false); break; case 35: test_palette(false); test_palette2(false); break; #endif #ifdef SMALLANIMATION_ROWWALK case 36: rowwalk(SMALLANIMATION_ROWWALK_COUNT,SMALLANIMATION_ROWWALK_SPEED); break; #endif #ifdef SMALLANIMATION_COLWALK case 37: colwalk(SMALLANIMATION_COLWALK_COUNT,SMALLANIMATION_COLWALK_SPEED); break; #endif #ifdef SMALLANIMATION_COLBOUNCE case 38: colbounce(SMALLANIMATION_COLBOUNCE_COUNT,SMALLANIMATION_COLBOUNCE_SPEED); break; #endif #ifdef SMALLANIMATION_ROWBOUNCE case 39: rowbounce(SMALLANIMATION_ROWBOUNCE_COUNT,SMALLANIMATION_ROWBOUNCE_SPEED); break; #endif #ifdef MENU_SUPPORT case 0xFDu: mode = 1; break; case 0xFEu: menu(); mode = oldOldmode; break; #else case 0xFDu: #ifdef JOYSTICK_SUPPORT if (JOYISFIRE) mode = 0xFEu; else #endif mode = 1; break; case 0xFEu: #ifdef JOYSTICK_SUPPORT waitForFire = 0; // avoid circular jumps while (JOYISFIRE); // wait until user released the fire button #endif wait(25); // wait for button to settle # ifdef GAME_TETRIS tetris(); # endif # ifdef GAME_BASTET tetris_bastet(); # endif # ifdef GAME_TETRIS_FP tetris_fp(); # endif # ifdef GAME_SPACE_INVADERS borg_invaders(); # endif # ifdef GAME_SNAKE snake_game(); # endif # ifdef GAME_BREAKOUT borg_breakout(0); # endif #ifdef JOYSTICK_SUPPORT while (JOYISFIRE); // avoid an unwanted restart of the game loop #endif wait(25); // wait for button to settle mode = oldOldmode; // restore old animation mode #ifdef JOYSTICK_SUPPORT waitForFire = 1; // reenable joystick query of the wait() function #endif break; #endif #ifdef ANIMATION_OFF case 0xFFu: off(); break; #endif default: if (reverseMode) { if (reverseMode-- == (mode - 1)) { mode -= 2; } else { reverseMode = 0; } } break; } } }
static gboolean writepng( FILE *f, GrxContext *grc ) { png_structp png_ptr; png_infop info_ptr; png_uint_32 height; png_uint_32 width; png_byte *png_pixels = NULL; png_byte **row_pointers = NULL; png_byte *pix_ptr = NULL; int x, y; unsigned char r, g, b; GrxColor *pColors = NULL; /* Create and initialize the png_struct */ png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING,NULL,NULL,NULL ); if( png_ptr == NULL ) return FALSE; /* Allocate/initialize the image information data */ info_ptr = png_create_info_struct( png_ptr ); if( info_ptr == NULL ){ png_destroy_write_struct( &png_ptr,(png_infopp)NULL ); return FALSE; } /* Set error handling */ if( setjmp( png_jmpbuf(png_ptr) ) ){ /* If we get here, we had a problem reading the file */ png_destroy_write_struct( &png_ptr,&info_ptr ); return FALSE; } /* set up the output control we are using standard C streams */ png_init_io( png_ptr,f ); /* Set the image information */ width = grx_get_width(); height = grx_get_height(); png_set_IHDR( png_ptr,info_ptr,width,height,8,PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE ); /* No gamma correction by now */ /* png_set_gAMA(png_ptr, info_ptr, gamma); */ /* No comments by now */ /* text_ptr[0].key = "Title"; text_ptr[0].text = "Mona Lisa"; text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE; text_ptr[1].key = "Author"; text_ptr[1].text = "Leonardo DaVinci"; text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE; text_ptr[2].key = "Description"; text_ptr[2].text = "<long text>"; text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt; png_set_text(png_ptr, info_ptr, text_ptr, 3); */ /* Write the file header information */ png_write_info( png_ptr,info_ptr ); png_pixels = (png_byte *) malloc( width * 3 * sizeof(png_byte) ); if( png_pixels == NULL ){ png_destroy_write_struct( &png_ptr,&info_ptr ); return FALSE; } row_pointers = (png_byte **) malloc( 1 * sizeof(png_bytep) ); if( row_pointers == NULL ){ png_destroy_write_struct( &png_ptr,&info_ptr ); free( png_pixels ); return FALSE; } pColors = malloc( width * sizeof(GrxColor) ); if( pColors == NULL ){ png_destroy_write_struct( &png_ptr,&info_ptr ); free( row_pointers ); free( png_pixels ); return FALSE; } row_pointers[0] = png_pixels; for( y=0; y<height; y++ ){ pix_ptr = png_pixels; memcpy( pColors,grx_get_scanline( 0,width-1,y,NULL ),sizeof(GrxColor)*width ); for( x=0; x<width; x++ ){ grx_color_query( pColors[x],&r,&g,&b ); *pix_ptr++ = r; *pix_ptr++ = g; *pix_ptr++ = b; } png_write_rows( png_ptr,&row_pointers[0],1 ); } /* It is REQUIRED to call this to finish writing the rest of the file */ png_write_end( png_ptr,info_ptr ); /* clean up after the write, and free any memory allocated */ png_destroy_write_struct( &png_ptr,&info_ptr ); free( pColors ); free( row_pointers ); free( png_pixels ); return TRUE; }
void obj2grd_ASL(ASL *a, int i, real *X, real *G, fint *nerror) { ASL_fgh *asl; Jmp_buf err_jmp0; cde *d; fint ne0; int ij, j, *vmi, xksave, *z; ograd *gr, **gr0; real *Adjoints, *vscale; size_t L; static char who[] = "obj2grd"; NNOBJ_chk(a, i, who); asl = (ASL_fgh*)a; if (!want_derivs) No_derivs_ASL(who); ne0 = -1; if (nerror && (ne0 = *nerror) >= 0) { err_jmp = &err_jmp0; ij = setjmp(err_jmp0.jb); if ((*nerror = ij)) goto done; } errno = 0; /* in case f77 set errno opening files */ if (!asl->i.x_known) x2_check(X); if (!asl->i.noxval || asl->i.noxval[i] != asl->i.nxval) { xksave = asl->i.x_known; asl->i.x_known = 1; obj2val_ASL(a, i, X, nerror); asl->i.x_known = xksave; if (ne0 >= 0 && *nerror) goto done; } if (asl->i.Derrs) deriv_errchk_ASL(a, nerror, -(i+1), 1); if (f_b) funnelset(asl, f_b); if (f_o) funnelset(asl, f_o); Adjoints = adjoints; d = obj_de + i; gr0 = Ograd + i; for(gr = *gr0; gr; gr = gr->next) Adjoints[gr->varno] = gr->coef; if ((L = d->zaplen)) { memset(adjoints_nv1, 0, L); derprop(d->d); } if (zerograds) { /* sparse gradients */ z = zerograds[i]; while((i = *z++) >= 0) G[i] = 0; } vmi = 0; if (a->i.vmap) vmi = get_vminv_ASL(a); gr = *gr0; if ((vscale = asl->i.vscale)) { if (vmi) for(; gr; gr = gr->next) { j = vmi[i = gr->varno]; G[j] = vscale[j] * Adjoints[i]; } else for(; gr; gr = gr->next) { i = gr->varno; G[i] = vscale[i] * Adjoints[i]; } } else if (vmi) for(; gr; gr = gr->next) { i = gr->varno; G[vmi[i]] = Adjoints[i]; } else for(; gr; gr = gr->next) { i = gr->varno; G[i] = Adjoints[i]; } done: err_jmp = 0; }
real obj2val_ASL(ASL *a, int i, real *X, fint *nerror) { ASL_fgh *asl; Jmp_buf err_jmp0; cde *d; expr *e1; int ij, j1, kv, *vmi; ograd *gr, **gr0; real f, *vscale; NNOBJ_chk(a, i, "obj2val"); asl = (ASL_fgh*)a; if (nerror && *nerror >= 0) { err_jmp = &err_jmp0; ij = setjmp(err_jmp0.jb); if ((*nerror = ij)) { f = 0.; goto done; } } want_deriv = want_derivs; errno = 0; /* in case f77 set errno opening files */ x2_check(X); if (!asl->i.noxval) asl->i.noxval = (int*)M1zapalloc(n_obj*sizeof(int)); co_index = -(i + 1); if (!(x0kind & ASL_have_objcom)) { if (ncom0 > combc) comeval(asl, combc, ncom0); x0kind |= ASL_have_objcom; } d = obj_de + i; if (d->n_com1) com1eval(asl, d->com11, d->n_com1); gr0 = Ograd + i; e1 = d->e; f = (*e1->op)(e1 C_ASL); asl->i.noxval[i] = asl->i.nxval; kv = 0; vmi = 0; if ((vscale = asl->i.vscale)) kv = 2; if (asl->i.vmap) { vmi = get_vminv_ASL(a); ++kv; } gr = *gr0; switch(kv) { case 3: for(; gr; gr = gr->next) { j1 = vmi[gr->varno]; f += X[j1] * vscale[j1] * gr->coef; } break; case 2: for(; gr; gr = gr->next) { j1 = gr->varno; f += X[j1] * vscale[j1] * gr->coef; } break; case 1: for(; gr; gr = gr->next) f += X[vmi[gr->varno]] * gr->coef; break; case 0: for(; gr; gr = gr->next) f += X[gr->varno] * gr->coef; } done: err_jmp = 0; return f; }
void process_queue(void) { struct pkg_list *rundown; struct pkginfo *volatile pkg; volatile enum action action_todo; jmp_buf ejbuf; enum istobes istobe= itb_normal; if (abort_processing) return; clear_istobes(); switch (cipaction->arg_int) { case act_triggers: case act_configure: case act_install: istobe= itb_installnew; break; case act_remove: case act_purge: istobe= itb_remove; break; default: internerr("unknown action '%d'", cipaction->arg_int); } for (rundown = queue.head; rundown; rundown = rundown->next) { ensure_package_clientdata(rundown->pkg); if (rundown->pkg->clientdata->istobe == istobe) { /* Erase the queue entry - this is a second copy! */ switch (cipaction->arg_int) { case act_triggers: case act_configure: case act_remove: case act_purge: printf(_("Package %s listed more than once, only processing once.\n"), pkg_name(rundown->pkg, pnaw_nonambig)); break; case act_install: printf(_("More than one copy of package %s has been unpacked\n" " in this run ! Only configuring it once.\n"), pkg_name(rundown->pkg, pnaw_nonambig)); break; default: internerr("unknown action '%d'", cipaction->arg_int); } rundown->pkg = NULL; } else { rundown->pkg->clientdata->istobe= istobe; } } while (!pkg_queue_is_empty(&queue)) { pkg = pkg_queue_pop(&queue); if (!pkg) continue; /* Duplicate, which we removed earlier. */ action_todo = cipaction->arg_int; if (sincenothing++ > queue.length * 2 + 2) { if (progress_bytrigproc && progress_bytrigproc->trigpend_head) { enqueue_package(pkg); pkg = progress_bytrigproc; action_todo = act_configure; } else { dependtry++; sincenothing = 0; assert(dependtry <= 4); } } assert(pkg->status <= stat_installed); if (setjmp(ejbuf)) { /* Give up on it from the point of view of other packages, i.e. reset * istobe. */ pkg->clientdata->istobe= itb_normal; pop_error_context(ehflag_bombout); if (abort_processing) return; continue; } push_error_context_jump(&ejbuf, print_error_perpackage, pkg_name(pkg, pnaw_nonambig)); switch (action_todo) { case act_triggers: if (!pkg->trigpend_head) ohshit(_("package %.250s is not ready for trigger processing\n" " (current status `%.250s' with no pending triggers)"), pkg_name(pkg, pnaw_nonambig), statusinfos[pkg->status].name); /* Fall through. */ case act_install: /* Don't try to configure pkgs that we've just disappeared. */ if (pkg->status == stat_notinstalled) break; /* Fall through. */ case act_configure: /* Do whatever is most needed. */ if (pkg->trigpend_head) trigproc(pkg); else deferred_configure(pkg); break; case act_remove: case act_purge: deferred_remove(pkg); break; default: internerr("unknown action '%d'", cipaction->arg_int); } m_output(stdout, _("<standard output>")); m_output(stderr, _("<standard error>")); pop_error_context(ehflag_normaltidy); } assert(!queue.length); }
int ReadPNG(FILE* in_file, WebPPicture* const pic, int keep_alpha, Metadata* const metadata) { volatile png_structp png; volatile png_infop info = NULL; volatile png_infop end_info = NULL; int color_type, bit_depth, interlaced; int has_alpha; int num_passes; int p; int ok = 0; png_uint_32 width, height, y; int stride; uint8_t* volatile rgb = NULL; png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0); if (png == NULL) { goto End; } png_set_error_fn(png, 0, error_function, NULL); if (setjmp(png_jmpbuf(png))) { Error: MetadataFree(metadata); goto End; } info = png_create_info_struct(png); if (info == NULL) goto Error; end_info = png_create_info_struct(png); if (end_info == NULL) goto Error; png_init_io(png, in_file); png_read_info(png, info); if (!png_get_IHDR(png, info, &width, &height, &bit_depth, &color_type, &interlaced, NULL, NULL)) goto Error; png_set_strip_16(png); png_set_packing(png); if (color_type == PNG_COLOR_TYPE_PALETTE) { png_set_palette_to_rgb(png); } if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) { if (bit_depth < 8) { png_set_expand_gray_1_2_4_to_8(png); } png_set_gray_to_rgb(png); } if (png_get_valid(png, info, PNG_INFO_tRNS)) { png_set_tRNS_to_alpha(png); has_alpha = 1; } else { has_alpha = !!(color_type & PNG_COLOR_MASK_ALPHA); } if (!keep_alpha) { png_set_strip_alpha(png); has_alpha = 0; } num_passes = png_set_interlace_handling(png); png_read_update_info(png, info); stride = (has_alpha ? 4 : 3) * width * sizeof(*rgb); rgb = (uint8_t*)malloc(stride * height); if (rgb == NULL) goto Error; for (p = 0; p < num_passes; ++p) { for (y = 0; y < height; ++y) { png_bytep row = (png_bytep)(rgb + y * stride); png_read_rows(png, &row, NULL, 1); } } png_read_end(png, end_info); if (metadata != NULL && !ExtractMetadataFromPNG(png, info, end_info, metadata)) { fprintf(stderr, "Error extracting PNG metadata!\n"); goto Error; } pic->width = width; pic->height = height; pic->use_argb = 1; ok = has_alpha ? WebPPictureImportRGBA(pic, rgb, stride) : WebPPictureImportRGB(pic, rgb, stride); if (!ok) { goto Error; } End: if (png != NULL) { png_destroy_read_struct((png_structpp)&png, (png_infopp)&info, (png_infopp)&end_info); } free(rgb); return ok; }
void runops(PARROT_INTERP, size_t offs) { ASSERT_ARGS(runops) volatile size_t offset = offs; const int old_runloop_id = interp->current_runloop_id; int our_runloop_level = interp->current_runloop_level; int our_runloop_id = old_runloop_id; /* It is OK if the runloop ID overflows; we only ever test it for equality, so the chance of collision is slight. */ interp->current_runloop_id = our_runloop_id; #if RUNLOOP_TRACE fprintf(stderr, "[entering loop %d, level %d]\n", interp->current_runloop_id, our_runloop_level); #endif /* * STACKED_EXCEPTIONS are necessary to catch exceptions in reentered * run loops, e.g. if a delegate method throws an exception */ #if ! STACKED_EXCEPTIONS if (!interp->current_runloop) #endif { new_runloop_jump_point(interp); our_runloop_id = interp->current_runloop_id; our_runloop_level = interp->current_runloop_level; reenter: interp->current_runloop->handler_start = NULL; switch (setjmp(interp->current_runloop->resume)) { case 1: /* an exception was handled */ if (STACKED_EXCEPTIONS) free_runloop_jump_point(interp); interp->current_runloop_level = our_runloop_level - 1; interp->current_runloop_id = old_runloop_id; #if RUNLOOP_TRACE fprintf(stderr, "[handled exception; back to loop %d, level %d]\n", interp->current_runloop_id, interp->current_runloop_level); #endif return; case 2: /* Reenter the runloop from a exception thrown from C * with a pir handler */ free_runloops_until(interp, our_runloop_id); PARROT_ASSERT(interp->current_runloop->handler_start); offset = interp->current_runloop->handler_start - interp->code->base.data; /* Prevent incorrect reuse */ goto reenter; case 3: /* Reenter the runloop when finished the handling of a * exception */ free_runloops_until(interp, our_runloop_id); offset = interp->current_runloop->handler_start - interp->code->base.data; goto reenter; default: break; } } runops_int(interp, offset); interp->current_runloop->handler_start = NULL; /* Remove the current runloop marker (put it on the free list). */ if (STACKED_EXCEPTIONS || interp->current_runloop) free_runloop_jump_point(interp); #if RUNLOOP_TRACE fprintf(stderr, "[exiting loop %d, level %d]\n", our_runloop_id, our_runloop_level); #endif }
bool PNG::Encode (ImageBuffer *imageBuffer, ByteArray *bytes) { png_structp png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, user_error_fn, user_warning_fn); if (!png_ptr) { return false; } png_infop info_ptr = png_create_info_struct (png_ptr); if (!info_ptr) { return false; } if (setjmp (png_jmpbuf (png_ptr))) { png_destroy_write_struct (&png_ptr, &info_ptr); return false; } QuickVec<uint8> out_buffer; png_set_write_fn (png_ptr, &out_buffer, user_write_data, user_flush_data); int w = imageBuffer->width; int h = imageBuffer->height; int bit_depth = 8; //int color_type = (inSurface->Format () & pfHasAlpha) ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB; int color_type = PNG_COLOR_TYPE_RGB_ALPHA; png_set_IHDR (png_ptr, info_ptr, w, h, bit_depth, color_type, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); png_write_info (png_ptr, info_ptr); bool do_alpha = (color_type == PNG_COLOR_TYPE_RGBA); unsigned char* imageData = imageBuffer->data->Bytes(); int stride = w * imageBuffer->bpp; { QuickVec<uint8> row_data (w * 4); png_bytep row = &row_data[0]; for (int y = 0; y < h; y++) { uint8 *buf = &row_data[0]; const uint8 *src = (const uint8 *)(imageData + (stride * y)); for (int x = 0; x < w; x++) { buf[0] = src[0]; buf[1] = src[1]; buf[2] = src[2]; src += 3; buf += 3; if (do_alpha) { *buf++ = *src; } src++; } png_write_rows (png_ptr, &row, 1); } } png_write_end (png_ptr, NULL); *bytes = ByteArray (out_buffer); return true; }
int png_pixel_plot(struct zint_symbol *symbol, int image_height, int image_width, char *pixelbuf, int rotate_angle) { struct mainprog_info_type wpng_info; struct mainprog_info_type *graphic; uint8_t outdata[image_width * 3]; png_structp png_ptr; png_infop info_ptr; graphic = &wpng_info; uint8_t *image_data; int i, row, column, errn; int fgred, fggrn, fgblu, bgred, bggrn, bgblu; switch(rotate_angle) { case 0: case 180: graphic->width = image_width; graphic->height = image_height; break; case 90: case 270: graphic->width = image_height; graphic->height = image_width; break; } /* sort out colour options */ to_upper((uint8_t*)symbol->fgcolour); to_upper((uint8_t*)symbol->bgcolour); if(strlen(symbol->fgcolour) != 6) { strcpy(symbol->errtxt, "Malformed foreground colour target"); return ZERROR_INVALID_OPTION; } if(strlen(symbol->bgcolour) != 6) { strcpy(symbol->errtxt, "Malformed background colour target"); return ZERROR_INVALID_OPTION; } errn = is_sane(SSET, (uint8_t*)symbol->fgcolour, strlen(symbol->fgcolour)); if (errn == ZERROR_INVALID_DATA) { strcpy(symbol->errtxt, "Malformed foreground colour target"); return ZERROR_INVALID_OPTION; } errn = is_sane(SSET, (uint8_t*)symbol->bgcolour, strlen(symbol->bgcolour)); if (errn == ZERROR_INVALID_DATA) { strcpy(symbol->errtxt, "Malformed background colour target"); return ZERROR_INVALID_OPTION; } fgred = (16 * ctoi(symbol->fgcolour[0])) + ctoi(symbol->fgcolour[1]); fggrn = (16 * ctoi(symbol->fgcolour[2])) + ctoi(symbol->fgcolour[3]); fgblu = (16 * ctoi(symbol->fgcolour[4])) + ctoi(symbol->fgcolour[5]); bgred = (16 * ctoi(symbol->bgcolour[0])) + ctoi(symbol->bgcolour[1]); bggrn = (16 * ctoi(symbol->bgcolour[2])) + ctoi(symbol->bgcolour[3]); bgblu = (16 * ctoi(symbol->bgcolour[4])) + ctoi(symbol->bgcolour[5]); /* Open output file in binary mode */ if((symbol->output_options & BARCODE_STDOUT) != 0) { graphic->outfile = stdout; } else { if (!(graphic->outfile = fopen(symbol->outfile, "wb"))) { strcpy(symbol->errtxt, "Can't open output file"); return ZERROR_FILE_ACCESS; } } /* Set up error handling routine as proc() above */ png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, graphic, writepng_error_handler, NULL); if (!png_ptr) { strcpy(symbol->errtxt, "Out of memory"); return ZERROR_MEMORY; } info_ptr = png_create_info_struct(png_ptr); if (!info_ptr) { png_destroy_write_struct(&png_ptr, NULL); strcpy(symbol->errtxt, "Out of memory"); return ZERROR_MEMORY; } /* catch jumping here */ if (setjmp(graphic->jmpbuf)) { png_destroy_write_struct(&png_ptr, &info_ptr); strcpy(symbol->errtxt, "libpng error occurred"); return ZERROR_MEMORY; } /* open output file with libpng */ png_init_io(png_ptr, graphic->outfile); /* set compression */ png_set_compression_level(png_ptr, Z_BEST_COMPRESSION); /* set Header block */ png_set_IHDR(png_ptr, info_ptr, graphic->width, graphic->height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); /* write all chunks up to (but not including) first IDAT */ png_write_info(png_ptr, info_ptr); /* set up the transformations: for now, just pack low-bit-depth pixels into bytes (one, two or four pixels per byte) */ png_set_packing(png_ptr); /* Pixel Plotting */ switch(rotate_angle) { case 0: /* Plot the right way up */ for(row = 0; row < image_height; row++) { for(column = 0; column < image_width; column++) { i = column * 3; switch(*(pixelbuf + (image_width * row) + column)) { case '1': outdata[i] = fgred; outdata[i + 1] = fggrn; outdata[i + 2] = fgblu; break; default: outdata[i] = bgred; outdata[i + 1] = bggrn; outdata[i + 2] = bgblu; break; } } /* write row contents to file */ image_data = outdata; png_write_row(png_ptr, image_data); } break; case 90: /* Plot 90 degrees clockwise */ for(row = 0; row < image_width; row++) { for(column = 0; column < image_height; column++) { i = column * 3; switch(*(pixelbuf + (image_width * (image_height - column - 1)) + row)) { case '1': outdata[i] = fgred; outdata[i + 1] = fggrn; outdata[i + 2] = fgblu; break; default: outdata[i] = bgred; outdata[i + 1] = bggrn; outdata[i + 2] = bgblu; break; } } /* write row contents to file */ image_data = outdata; png_write_row(png_ptr, image_data); } break; case 180: /* Plot upside down */ for(row = 0; row < image_height; row++) { for(column = 0; column < image_width; column++) { i = column * 3; switch(*(pixelbuf + (image_width * (image_height - row - 1)) + (image_width - column - 1))) { case '1': outdata[i] = fgred; outdata[i + 1] = fggrn; outdata[i + 2] = fgblu; break; default: outdata[i] = bgred; outdata[i + 1] = bggrn; outdata[i + 2] = bgblu; break; } } /* write row contents to file */ image_data = outdata; png_write_row(png_ptr, image_data); } break; case 270: /* Plot 90 degrees anti-clockwise */ for(row = 0; row < image_width; row++) { for(column = 0; column < image_height; column++) { i = column * 3; switch(*(pixelbuf + (image_width * column) + (image_width - row - 1))) { case '1': outdata[i] = fgred; outdata[i + 1] = fggrn; outdata[i + 2] = fgblu; break; default: outdata[i] = bgred; outdata[i + 1] = bggrn; outdata[i + 2] = bgblu; break; } } /* write row contents to file */ image_data = outdata; png_write_row(png_ptr, image_data); } break; } /* End the file */ png_write_end(png_ptr, NULL); /* make sure we have disengaged */ if (png_ptr && info_ptr) png_destroy_write_struct(&png_ptr, &info_ptr); if(symbol->output_options & BARCODE_STDOUT) { fflush(wpng_info.outfile); } else { fclose(wpng_info.outfile); } return 0; }
bool PNG::Decode (Resource *resource, ImageBuffer *imageBuffer) { unsigned char png_sig[PNG_SIG_SIZE]; png_structp png_ptr; png_infop info_ptr; png_uint_32 width, height; int bit_depth, color_type, interlace_type; FILE_HANDLE *file = NULL; if (resource->path) { file = lime::fopen (resource->path, "rb"); if (!file) return false; int read = lime::fread (png_sig, PNG_SIG_SIZE, 1, file); if (png_sig_cmp (png_sig, 0, PNG_SIG_SIZE)) { lime::fclose (file); return false; } } else { memcpy (png_sig, resource->data->Bytes (), PNG_SIG_SIZE); if (png_sig_cmp (png_sig, 0, PNG_SIG_SIZE)) { return false; } } if ((png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)) == NULL) { if (file) lime::fclose (file); return false; } if ((info_ptr = png_create_info_struct (png_ptr)) == NULL) { png_destroy_read_struct (&png_ptr, (png_infopp)NULL, (png_infopp)NULL); if (file) lime::fclose (file); return false; } // sets the point which libpng will jump back to in the case of an error if (setjmp (png_jmpbuf (png_ptr))) { png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp)NULL); if (file) lime::fclose (file); return false; } if (file) { if (file->isFile ()) { png_init_io (png_ptr, file->getFile ()); png_set_sig_bytes (png_ptr, PNG_SIG_SIZE); } else { ByteArray data = ByteArray (resource->path); ReadBuffer buffer (data.Bytes (), data.Size ()); png_set_read_fn (png_ptr, &buffer, user_read_data_fn); } } else { ReadBuffer buffer (resource->data->Bytes (), resource->data->Size ()); png_set_read_fn (png_ptr, &buffer, user_read_data_fn); } png_read_info (png_ptr, info_ptr); png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL); //bool has_alpha = (color_type == PNG_COLOR_TYPE_GRAY_ALPHA || color_type == PNG_COLOR_TYPE_RGB_ALPHA || png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS)); png_set_expand (png_ptr); png_set_filler (png_ptr, 0xff, PNG_FILLER_AFTER); //png_set_gray_1_2_4_to_8 (png_ptr); png_set_palette_to_rgb (png_ptr); png_set_gray_to_rgb (png_ptr); if (bit_depth < 8) { png_set_packing (png_ptr); } else if (bit_depth == 16) { png_set_scale_16 (png_ptr); } //png_set_bgr (png_ptr); int bpp = 4; const unsigned int stride = width * bpp; imageBuffer->Resize (width, height, bpp); unsigned char *bytes = imageBuffer->data->Bytes (); int number_of_passes = png_set_interlace_handling (png_ptr); for (int pass = 0; pass < number_of_passes; pass++) { for (int i = 0; i < height; i++) { png_bytep anAddr = (png_bytep)(bytes + i * stride); png_read_rows (png_ptr, (png_bytepp) &anAddr, NULL, 1); } } png_read_end (png_ptr, NULL); png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp)NULL); if (file) lime::fclose (file); return true; }
/**************************************************************************** * DecodeBlock: the whole thing **************************************************************************** * This function must be fed with a complete compressed frame. ****************************************************************************/ static picture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block ) { decoder_sys_t *p_sys = p_dec->p_sys; block_t *p_block; picture_t *p_pic = 0; png_uint_32 i_width, i_height; int i_color_type, i_interlace_type, i_compression_type, i_filter_type; int i_bit_depth, i; png_structp p_png; png_infop p_info, p_end_info; png_bytep *volatile p_row_pointers = NULL; if( !pp_block || !*pp_block ) return NULL; p_block = *pp_block; p_sys->b_error = false; if( p_block->i_flags & BLOCK_FLAG_CORRUPTED ) { block_Release( p_block ); *pp_block = NULL; return NULL; } p_png = png_create_read_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 ); if( p_png == NULL ) { block_Release( p_block ); *pp_block = NULL; return NULL; } p_info = png_create_info_struct( p_png ); if( p_info == NULL ) { png_destroy_read_struct( &p_png, NULL, NULL ); block_Release( p_block ); *pp_block = NULL; return NULL; } p_end_info = png_create_info_struct( p_png ); if( p_end_info == NULL ) { png_destroy_read_struct( &p_png, &p_info, NULL ); block_Release( p_block ); *pp_block = NULL; return NULL; } /* libpng longjmp's there in case of error */ if( setjmp( png_jmpbuf( p_png ) ) ) goto error; png_set_read_fn( p_png, (void *)p_block, user_read ); png_set_error_fn( p_png, (void *)p_dec, user_error, user_warning ); png_read_info( p_png, p_info ); if( p_sys->b_error ) goto error; png_get_IHDR( p_png, p_info, &i_width, &i_height, &i_bit_depth, &i_color_type, &i_interlace_type, &i_compression_type, &i_filter_type); if( p_sys->b_error ) goto error; /* Set output properties */ p_dec->fmt_out.i_codec = VLC_CODEC_RGBA; p_dec->fmt_out.video.i_visible_width = p_dec->fmt_out.video.i_width = i_width; p_dec->fmt_out.video.i_visible_height = p_dec->fmt_out.video.i_height = i_height; p_dec->fmt_out.video.i_sar_num = 1; p_dec->fmt_out.video.i_sar_den = 1; p_dec->fmt_out.video.i_rmask = 0x000000ff; p_dec->fmt_out.video.i_gmask = 0x0000ff00; p_dec->fmt_out.video.i_bmask = 0x00ff0000; if( i_color_type == PNG_COLOR_TYPE_PALETTE ) png_set_palette_to_rgb( p_png ); if( i_color_type == PNG_COLOR_TYPE_GRAY || i_color_type == PNG_COLOR_TYPE_GRAY_ALPHA ) png_set_gray_to_rgb( p_png ); /* Strip to 8 bits per channel */ if( i_bit_depth == 16 ) png_set_strip_16( p_png ); if( png_get_valid( p_png, p_info, PNG_INFO_tRNS ) ) { png_set_tRNS_to_alpha( p_png ); } else if( !(i_color_type & PNG_COLOR_MASK_ALPHA) ) { p_dec->fmt_out.i_codec = VLC_CODEC_RGB24; } /* Get a new picture */ p_pic = decoder_NewPicture( p_dec ); if( !p_pic ) goto error; /* Decode picture */ p_row_pointers = malloc( sizeof(png_bytep) * i_height ); if( !p_row_pointers ) goto error; for( i = 0; i < (int)i_height; i++ ) p_row_pointers[i] = p_pic->p->p_pixels + p_pic->p->i_pitch * i; png_read_image( p_png, p_row_pointers ); if( p_sys->b_error ) goto error; png_read_end( p_png, p_end_info ); if( p_sys->b_error ) goto error; png_destroy_read_struct( &p_png, &p_info, &p_end_info ); free( p_row_pointers ); p_pic->date = p_block->i_pts > VLC_TS_INVALID ? p_block->i_pts : p_block->i_dts; block_Release( p_block ); *pp_block = NULL; return p_pic; error: free( p_row_pointers ); png_destroy_read_struct( &p_png, &p_info, &p_end_info ); block_Release( p_block ); *pp_block = NULL; return NULL; }
int int_png_load(const char *name, unsigned char **buffer, int* xp, int* yp, int* bpp, bool alpha) { static const png_color_16 my_background = {0, 0, 0, 0, 0}; png_structp png_ptr; png_infop info_ptr; png_uint_32 width, height; unsigned int i; int bit_depth, color_type, interlace_type, number_passes, pass, int_bpp; png_byte * fbptr; FILE * fh; if(!(fh=fopen(name,"rb"))) return(FH_ERROR_FILE); png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if(png_ptr == NULL) { fclose(fh); return(FH_ERROR_FORMAT); } info_ptr = png_create_info_struct(png_ptr); if(info_ptr == NULL) { png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL); fclose(fh); return(FH_ERROR_FORMAT); } if (setjmp(png_jmpbuf(png_ptr))) { png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); fclose(fh); return(FH_ERROR_FORMAT); } png_init_io(png_ptr,fh); png_read_info(png_ptr, info_ptr); png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL); if (alpha) { *bpp = png_get_channels(png_ptr, info_ptr); if ((*bpp != 4) || !(color_type & PNG_COLOR_MASK_ALPHA)) { png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); fclose(fh); return fh_png_load(name, buffer, xp, yp); } // 24bit PNGs with alpha-channel int_bpp = 4; // png_set_swap_alpha(png_ptr); if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr); }else // All other PNGs { if (color_type == PNG_COLOR_TYPE_PALETTE) { png_set_palette_to_rgb(png_ptr); png_set_background(png_ptr, (png_color_16*)&my_background, PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); /* other possibility for png_set_background: use png_get_bKGD */ } if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) { png_set_gray_to_rgb(png_ptr); png_set_background(png_ptr, (png_color_16*)&my_background, PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); } /* this test does not trigger for 8bit-paletted PNGs with newer libpng (1.2.36 at least), but the data delivered is with alpha channel anyway, so always strip alpha for now */ #if PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR <= 2 && PNG_LIBPNG_VER_RELEASE < 36 if (color_type & PNG_COLOR_MASK_ALPHA) #endif png_set_strip_alpha(png_ptr); if (bit_depth < 8) png_set_packing(png_ptr); int_bpp = 3; } if (bit_depth == 16) png_set_strip_16(png_ptr); number_passes = png_set_interlace_handling(png_ptr); png_read_update_info(png_ptr,info_ptr); unsigned long rowbytes = png_get_rowbytes(png_ptr, info_ptr); if (width * int_bpp != rowbytes) { printf("[png.cpp]: Error processing %s - please report (including image).\n", name); printf(" width: %lu rowbytes: %lu\n", (unsigned long)width, (unsigned long)rowbytes); fclose(fh); return(FH_ERROR_FORMAT); } for (pass = 0; pass < number_passes; pass++) { fbptr = (png_byte *)(*buffer); for (i = 0; i < height; i++, fbptr += width * int_bpp) png_read_row(png_ptr, fbptr, NULL); } png_read_end(png_ptr, info_ptr); png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); fclose(fh); return(FH_ERROR_OK); }
/* * EncodeBlock */ static block_t *EncodeBlock(encoder_t *p_enc, picture_t *p_pic) { encoder_sys_t *p_sys = p_enc->p_sys; if( unlikely( !p_pic ) ) { return NULL; } block_t *p_block = block_Alloc( p_sys->i_blocksize ); if( p_block == NULL ) { return NULL; } png_structp p_png = png_create_write_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 ); if( p_png == NULL ) { block_Release( p_block ); return NULL; } /* Disable filtering to speed-up encoding */ png_set_filter( p_png, 0, PNG_NO_FILTERS ); /* 1 == best speed */ png_set_compression_level( p_png, 1 ); /* save buffer start */ uint8_t *p_start = p_block->p_buffer; size_t i_start = p_block->i_buffer; p_sys->b_error = false; png_infop p_info = NULL; /* libpng longjmp's there in case of error */ if( setjmp( png_jmpbuf( p_png ) ) ) goto error; png_set_write_fn( p_png, p_block, user_write, user_flush ); png_set_error_fn( p_png, p_enc, user_error, user_warning ); p_info = png_create_info_struct( p_png ); if( p_info == NULL ) goto error; png_set_IHDR( p_png, p_info, p_enc->fmt_in.video.i_visible_width, p_enc->fmt_in.video.i_visible_height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT ); if( p_sys->b_error ) goto error; png_write_info( p_png, p_info ); if( p_sys->b_error ) goto error; /* Encode picture */ for( int i = 0; i < p_pic->p->i_visible_lines; i++ ) { png_write_row( p_png, p_pic->p->p_pixels + (i * p_pic->p->i_pitch) ); if( p_sys->b_error ) goto error; } png_write_end( p_png, p_info ); if( p_sys->b_error ) goto error; png_destroy_write_struct( &p_png, &p_info ); /* restore original buffer position */ p_block->p_buffer = p_start; p_block->i_buffer = i_start - p_block->i_buffer; p_block->i_dts = p_block->i_pts = p_pic->date; return p_block; error: png_destroy_write_struct( &p_png, p_info ? &p_info : NULL ); block_Release(p_block); return NULL; }
int hta_map(int pid, Context* context) { register char * const basepointer __asm("rbp"); register char * const stackpointer __asm("rsp"); //====================================================================== // perform map //====================================================================== // create slave EDTs ocrGuid_t slaveEdt_template_guid; ocrGuid_t slaveEdts[NUM_SLAVES]; ocrGuid_t slaveOutEvent[NUM_SLAVES]; ocrGuid_t slaveInDBs[NUM_SLAVES]; ocrEdtTemplateCreate(&slaveEdt_template_guid, slaveEdt, 0, 2); printf("(%lu) slaveEDT template guid %lx\n", MYRANK, slaveEdt_template_guid); for(int i = 0; i < NUM_SLAVES; i++) { int *data; slaveOutEvent[i] = NULL_GUID; ocrDbCreate(&slaveInDBs[i], (void**) &data, sizeof(int), /*flags=*/DB_PROP_NO_ACQUIRE, /*affinity=*/NULL_GUID, NO_ALLOC); ocrEdtCreate(&slaveEdts[i], slaveEdt_template_guid, /*paramc=*/0, /*paramv=*/(u64 *)NULL, /*depc=*/2, /*depv=*/NULL, /*properties=*/0 , /*affinity*/NULL_GUID, &slaveOutEvent[i]); ocrAddDependence(slaveInDBs[i], slaveEdts[i], 1, DB_DEFAULT_MODE); // Immediately satisfy printf("(%lu) slave %d EDT guid %lx\n", MYRANK, i, slaveEdts[i]); printf("(%lu) slave %d out event guid %lx\n", MYRANK, i, slaveOutEvent[i]); } ocrEdtTemplateDestroy(slaveEdt_template_guid); //====================================================================== // Create continuation to wait for slave EDTs to finish //====================================================================== ocrGuid_t procEdt_template_guid; ocrGuid_t procEdt_guid; ocrEdtTemplateCreate(&procEdt_template_guid, procEdt, 1, 3+NUM_SLAVES); u64 rank = MYRANK; ocrGuid_t depv[3+NUM_SLAVES]; depv[0] = UNINITIALIZED_GUID; depv[1] = context->args; depv[2] = context->self_context_guid; for(int i = 0; i < NUM_SLAVES; i++) depv[3+i] = slaveOutEvent[i]; ocrEdtCreate(&procEdt_guid, procEdt_template_guid, /*paramc=*/1, /*paramv=*/(u64 *)&rank, /*depc=*/EDT_PARAM_DEF, /*depv=*/depv, /*properties=*/0 , /*affinity*/NULL_GUID, /*outputEvent*/NULL ); printf("(%lu) continuation procEDT template guid %lx\n", MYRANK, procEdt_template_guid); printf("(%lu) continuation procEDT guid %lx\n", MYRANK, procEdt_guid); // defer firing slave EDTs for(int i = 0; i < NUM_SLAVES; i++) { ocrAddDependence(NULL_GUID, slaveEdts[i], 0, DB_DEFAULT_MODE); //pure control dependence // Immediately satisfy } ocrEdtTemplateDestroy(procEdt_template_guid); // setjmp call creates a continuation point if(!setjmp(context->env)) { // switch back to thread stack // 1. compute the size that need to be copied (the growth of DB stack) size_t size_to_copy = (context->stack + DB_STACK_SIZE) - stackpointer; printf("(%lu) db stack (%p - %p) stack size growth = 0x%x\n", MYRANK, stackpointer, context->stack+DB_STACK_SIZE-1, size_to_copy); // 2. compute the start address of the thread stack char* originalbp = context->originalbp; char* threadsp = originalbp - size_to_copy; char* threadbp = threadsp + (basepointer-stackpointer); // 3. copy DB stack to overwrite thread stack printf("(%lu) Enabling continuation codelet\n", MYRANK); printf("(%lu) switching back to thread stack at (%p - %p) original bp (%p)\n", MYRANK, threadsp, threadbp, originalbp); memcpy(threadsp - RED_ZONE_SIZE, stackpointer - RED_ZONE_SIZE, size_to_copy + RED_ZONE_SIZE); // 4. fix frame link addresses _fix_pointers(basepointer, threadbp, originalbp); // 5. store the next phase EDT guid for deferred activation context->next_phase_edt_guid = procEdt_guid; // 6. set rsp and rbp to point to thread stack. Stop writing to context->stack __asm volatile( "movq %0, %%rbp;" "movq %1, %%rsp;" : :"r"(threadbp), "r"(threadsp) ); printf("(%lu) ==hta_map splited==\n", MYRANK); return HTA_OP_TO_BE_CONTINUED; }
void * enumScanThrd(struct native_enum *NatEnum) { CMCIConnection * con = NatEnum->econ ; /* enumeration */ CMPIObjectPath * cop = NatEnum->ecop ; /* enumeration */ struct timespec tp ; int rc = 0 ; ParserControl control; struct native_enum *local_enmp ; memset(&control,0,sizeof(control)); /* * get the data array and save a copy of address in enumeration */ XmlBuffer *xmb = newXmlBuffer(NULL); control.xmb = xmb; control.respHdr.xmlBuffer = xmb; control.respHdr.rvArray=newCMPIArray(0,0,NULL); local_enmp = con->asynRCntl.enmp ; local_enmp->data = control.respHdr.rvArray ; control.requestObjectPath = cop; control.heap = parser_heap_init(); control.econ = con ; if(rc = setjmp(save_env)) { printf(" we had a timeout , we are going to exit from here \n") ; con->asynRCntl.escanInfo.parsestate = PARSTATE_SERVER_TIMEOUT ; con->asynRCntl.xfer_state = XFER_ERROR ; return ; } /* * wait for first data block received or xfer complete * we need to have some data before starting */ while((con->asynRCntl.xfer_state != XFER_DATA_RECVD )&& (con->asynRCntl.xfer_state != XFER_COMPLETE)){ usleep(100000) ; } control.respHdr.rc = startParsing(&control); /* * releaseXmlBuffer free's that last con->asynRCntl.escanInfo.section * we clear out that pointer just to be safe */ releaseXmlBuffer(xmb); con->asynRCntl.escanInfo.section = 0 ; parser_heap_term(control.heap); con->asynRCntl.escanInfo.parsestate = PARSTATE_COMPLETE ; }
std::optional<ImageData2D> PngImporter::doImage2D(UnsignedInt) { /* Verify file signature */ png_byte signature[8]; _in->read(reinterpret_cast<char*>(signature), 8); if(png_sig_cmp(signature, 0, 8) != 0) { Error() << "Trade::PngImporter::image2D(): wrong file signature"; return std::nullopt; } /* Structures for reading the file */ png_structp file = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr); CORRADE_INTERNAL_ASSERT(file); png_infop info = png_create_info_struct(file); CORRADE_INTERNAL_ASSERT(info); png_bytep* rows = nullptr; unsigned char* data = nullptr; /* Error handling routine */ /** @todo Get rid of setjmp (won't work everywhere) */ if(setjmp(png_jmpbuf(file))) { Error() << "Trade::PngImporter::image2D(): error while reading PNG file"; png_destroy_read_struct(&file, &info, nullptr); delete[] rows; delete[] data; return std::nullopt; } /* Set function for reading from std::istream */ png_set_read_fn(file, _in, [](png_structp file, png_bytep data, png_size_t length) { reinterpret_cast<std::istream*>(png_get_io_ptr(file))->read(reinterpret_cast<char*>(data), length); }); /* The signature is already read */ png_set_sig_bytes(file, 8); /* Read file information */ png_read_info(file, info); /* Image size */ const Vector2i size(png_get_image_width(file, info), png_get_image_height(file, info)); /* Image channels and bit depth */ png_uint_32 bits = png_get_bit_depth(file, info); png_uint_32 channels = png_get_channels(file, info); const png_uint_32 colorType = png_get_color_type(file, info); /* Image format */ ColorFormat format; switch(colorType) { /* Types that can be used without conversion */ case PNG_COLOR_TYPE_GRAY: #ifndef MAGNUM_TARGET_GLES format = ColorFormat::Red; #else format = Context::current() && Context::current()->isExtensionSupported<Extensions::GL::EXT::texture_rg>() ? ColorFormat::Red : ColorFormat::Luminance; #endif CORRADE_INTERNAL_ASSERT(channels == 1); /* Convert to 8-bit */ if(bits < 8) { png_set_expand_gray_1_2_4_to_8(file); bits = 8; } break; case PNG_COLOR_TYPE_RGB: format = ColorFormat::RGB; CORRADE_INTERNAL_ASSERT(channels == 3); break; case PNG_COLOR_TYPE_RGBA: format = ColorFormat::RGBA; CORRADE_INTERNAL_ASSERT(channels == 4); break; /* Palette needs to be converted */ case PNG_COLOR_TYPE_PALETTE: /** @todo test case for this */ png_set_palette_to_rgb(file); format = ColorFormat::RGB; channels = 3; break; default: Error() << "Trade::PngImporter::image2D(): unsupported color type" << colorType; png_destroy_read_struct(&file, &info, nullptr); return std::nullopt; } /* Convert transparency mask to alpha */ if(png_get_valid(file, info, PNG_INFO_tRNS)) { png_set_tRNS_to_alpha(file); channels += 1; CORRADE_INTERNAL_ASSERT(channels == 4); } /* Image type */ ColorType type; switch(bits) { case 8: type = ColorType::UnsignedByte; break; case 16: type = ColorType::UnsignedShort; break; default: Error() << "Trade::PngImporter::image2D(): unsupported bit depth" << bits; png_destroy_read_struct(&file, &info, nullptr); return std::nullopt; } /* Initialize data array */ data = new unsigned char[size.product()*channels*bits/8]; /* Read image row by row */ rows = new png_bytep[size.y()]; const Int stride = size.x()*channels*bits/8; for(Int i = 0; i != size.y(); ++i) rows[i] = data + (size.y() - i - 1)*stride; png_read_image(file, rows); delete[] rows; /* Cleanup */ png_destroy_read_struct(&file, &info, nullptr); return Trade::ImageData2D(format, type, size, data); }
int fh_png_load(const char *name, unsigned char *buffer, int x, int y) { static const png_color_16 my_background = {0, 0, 0, 0, 0}; png_structp png_ptr; png_infop info_ptr; png_uint_32 width, height; unsigned int i; int bit_depth, color_type, interlace_type; int number_passes, pass; png_byte * fbptr; FILE * fh; if (!(fh = fopen(name, "rb"))) return(FH_ERROR_FILE); png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (png_ptr == NULL) return(FH_ERROR_FORMAT); info_ptr = png_create_info_struct(png_ptr); if (info_ptr == NULL) { png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL); fclose(fh); return(FH_ERROR_FORMAT); } #if (PNG_LIBPNG_VER < 10500) if (setjmp(png_ptr->jmpbuf)) #else if (setjmp(png_jmpbuf(png_ptr))) #endif { png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); fclose(fh); return(FH_ERROR_FORMAT); } png_init_io(png_ptr, fh); png_read_info(png_ptr, info_ptr); png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL); if (color_type == PNG_COLOR_TYPE_PALETTE) { png_set_palette_to_rgb(png_ptr); png_set_background(png_ptr, (png_color_16 *)&my_background, PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); /* other possibility for png_set_background: use png_get_bKGD */ } if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) { png_set_gray_to_rgb(png_ptr); png_set_background(png_ptr, (png_color_16 *)&my_background, PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); } if (color_type & PNG_COLOR_MASK_ALPHA) png_set_strip_alpha(png_ptr); if (bit_depth < 8) png_set_packing(png_ptr); if (bit_depth == 16) png_set_strip_16(png_ptr); /* on Intel PC ?: if (bit_depth == 16) png_set_swap(png_ptr); */ number_passes = png_set_interlace_handling(png_ptr); png_read_update_info(png_ptr, info_ptr); if (width * 3 != png_get_rowbytes(png_ptr, info_ptr)) { printf("[png.cpp]: Error processing %s - please report (including image).\n", name); return(FH_ERROR_FORMAT); } for(pass = 0; pass < number_passes; pass++) { fbptr = (png_byte *)buffer; for (i = 0; i < height; i++, fbptr += width * 3) { png_read_row(png_ptr, fbptr, NULL); } } png_read_end(png_ptr, info_ptr); png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); fclose(fh); return(FH_ERROR_OK); }
static gint save_image (char *filename, gint32 image_ID, gint32 drawable_ID) { GPixelRgn pixel_rgn; TileDrawable *drawable; GDrawableType drawable_type; struct jpeg_compress_struct cinfo; struct my_error_mgr jerr; FILE *outfile; guchar *temp, *t; guchar *data; guchar *src, *s; char *name; int has_alpha; GimpExportReturnType export = GIMP_EXPORT_CANCEL; gint32 e_image_ID = -1; gint32 e_drawable_ID = -1; GPrecisionType precision; int rowstride, yend; int i, j; drawable = gimp_drawable_get (drawable_ID); drawable_type = gimp_drawable_type (drawable_ID); gimp_pixel_rgn_init (&pixel_rgn, drawable, 0, 0, drawable->width, drawable->height, FALSE, FALSE); name = malloc (strlen (filename) + 11); sprintf (name, "%s %s:",_("Saving"), filename); gimp_progress_init (name); free (name); /* Step 1: allocate and initialize JPEG compression object */ /* We have to set up the error handler first, in case the initialization * step fails. (Unlikely, but it could happen if you are out of memory.) * This routine fills in the contents of struct jerr, and returns jerr's * address which we place into the link field in cinfo. */ cinfo.err = jpeg_std_error (&jerr.pub); jerr.pub.error_exit = my_error_exit; outfile = NULL; /* Establish the setjmp return context for my_error_exit to use. */ if (setjmp (jerr.setjmp_buffer)) { /* If we get here, the JPEG code has signaled an error. * We need to clean up the JPEG object, close the input file, and return. */ jpeg_destroy_compress (&cinfo); if (outfile) fclose (outfile); if (drawable) gimp_drawable_detach (drawable); return FALSE; } /* Now we can initialize the JPEG compression object. */ jpeg_create_compress (&cinfo); /* Step 2: specify data destination (eg, a file) */ /* Note: steps 2 and 3 can be done in either order. */ /* Here we use the library-supplied code to send compressed data to a * stdio stream. You can also write your own code to do something else. * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that * requires it in order to write binary files. */ if ((outfile = fopen (filename, "wb")) == NULL) { fprintf (stderr, "can't open %s\n", filename); return FALSE; } jpeg_stdio_dest (&cinfo, outfile); /* Get the input image and a pointer to its data. */ cinfo.input_components = gimp_drawable_num_channels(drawable_ID); has_alpha = gimp_drawable_has_alpha(drawable_ID); if(has_alpha) --cinfo.input_components; /* Step 3: set parameters for compression */ /* First we supply a description of the input image. * Four fields of the cinfo struct must be filled in: */ /* image width and height, in pixels */ cinfo.image_width = drawable->width; cinfo.image_height = drawable->height; /* colorspace of input image */ cinfo.in_color_space = gimp_drawable_color(drawable_ID) ? JCS_RGB : JCS_GRAYSCALE; /* Now use the library's routine to set default compression parameters. * (You must set at least cinfo.in_color_space before calling this, * since the defaults depend on the source color space.) */ jpeg_set_defaults (&cinfo); /* Now you can set any non-default parameters you wish to. * Here we just illustrate the use of quality (quantization table) scaling: */ jpeg_set_quality (&cinfo, (int) (jsvals.quality * 100), TRUE /* limit to baseline-JPEG values */); cinfo.smoothing_factor = (int) (jsvals.smoothing * 100); cinfo.optimize_coding = jsvals.optimize; /* Step 4: Start compressor */ /* TRUE ensures that we will write a complete interchange-JPEG file. * Pass TRUE unless you are very sure of what you're doing. */ jpeg_start_compress (&cinfo, TRUE); // Step 4a: write icc profile { char *buffer = NULL; int size = 0; if (gimp_image_has_icc_profile (image_ID, ICC_IMAGE_PROFILE)) { buffer = gimp_image_get_icc_profile_by_mem (image_ID, &size, ICC_IMAGE_PROFILE); if (buffer) { write_icc_profile (&cinfo, buffer, size); printf ("%s:%d %s() embedded icc profile\n",__FILE__,__LINE__,__func__); } } } /* Step 5: while (scan lines remain to be written) */ /* jpeg_write_scanlines(...); */ /* Here we use the library's state variable cinfo.next_scanline as the * loop counter, so that we don't have to keep track ourselves. * To keep things simple, we pass one scanline per call; you can pass * more if you wish, though. */ /* JSAMPLEs per row in image_buffer */ rowstride = drawable->bpp * drawable->width; temp = (guchar *) malloc (cinfo.image_width * cinfo.input_components * 4); data = (guchar *) malloc (rowstride * gimp_tile_height ()); export = gimp_export_image (&image_ID, &drawable_ID, "Jpeg",
void GenericImage::write_png(const char *filename) { int w = width; int h = height; int c = components; int b = pix_depth; void* p = pixels; FILE *filep = NULL; png_structp writep = NULL; png_infop infop = NULL; png_bytep *bytep = NULL; /* Initialize all PNG import data structures. */ if (!(filep = fopen(filename, "wb"))) fail("can't open file\n"); if (!(writep = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) fail("can't create png write struct\n"); if (!(infop = png_create_info_struct(writep))) fail("can't create png info struct\n"); /* Enable the default PNG error handler. */ if (setjmp(png_jmpbuf(writep)) == 0) { png_init_io (writep, filep); /* Set the image information here. Width and height are up to 2^31, * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY, * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB, * or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED */ int color_type; switch (c) { case 1: color_type = PNG_COLOR_TYPE_GRAY; break; case 2: color_type = PNG_COLOR_TYPE_GRAY_ALPHA; break; case 3: color_type = PNG_COLOR_TYPE_RGB; break; case 4: color_type = PNG_COLOR_TYPE_RGB_ALPHA; break; default: color_type = PNG_COLOR_TYPE_RGB; } png_set_compression_level(writep, 9); png_set_IHDR(writep, infop, w, h, b*8, color_type, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); png_write_info(writep, infop); /* pack pixels into bytes */ png_set_packing(writep); bytep = (png_bytep *) png_malloc(writep, h * sizeof (png_bytep)); for (int k = 0; k < h; k++) bytep[k] = (png_bytep)p + k*w*c*b; /* write out the entire image data in one call */ //png_write_image(writep, bytep); /* Write a few rows at a time. */ //png_write_rows(writep, &bytep[first_row], number_of_rows); /* If you are only writing one row at a time, this works */ // for (int y = 0; y < h; y++) // { // png_write_rows(writep, &row_pointers[y], 1); // } // png_write_end(writep, infop); //set rows and write png png_set_rows(writep, infop, bytep); //png_write_png(writep, infop, PNG_TRANSFORM_STRIP_16 | // PNG_TRANSFORM_PACKING, NULL); png_write_png (writep, infop, PNG_TRANSFORM_SWAP_ENDIAN, NULL); free(bytep); } else fail("can't write png data\n"); /* Release all resources. */ png_destroy_write_struct(&writep, &infop); fclose(filep); success("write png file\n"); }
image_t* image_load_png(const char* path) { png_structp png_ptr; png_infop info_ptr; unsigned int sig_read = 0; int color_type, interlace_type; FILE* fp; png_uint_32 width, height; int bit_depth; unsigned int row_bytes; PIXEL_FORMAT sf = PF_A8; uint32 pixel_size = 0; uint32 width_size = 0; image_t* tex = NULL; char* buff = NULL; png_bytepp row_pointers; uint32 r; /* row */ if( (fp = fopen(path, "rb")) == NULL ) { fprintf(stderr, "ERROR: load_png: %s not found\n", path); return NULL; } /* Create and initialize the png_struct * with the desired error handler * functions. If you want to use the * default stderr and longjump method, * you can supply NULL for the last * three parameters. We also supply the * the compiler header file version, so * that we know if the application * was compiled with a compatible version * of the library. REQUIRED */ png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if( png_ptr == NULL ) { fclose(fp); fprintf(stderr, "ERROR: load_png: %s: invalid PNG format\n", path); } /* Allocate/initialize the memory * for image information. REQUIRED. */ info_ptr = png_create_info_struct(png_ptr); if (info_ptr == NULL) { fclose(fp); png_destroy_read_struct(&png_ptr, NULL, NULL); fprintf(stderr, "ERROR: load_png: %s: not enough memory or format not supported\n", path); return NULL; } /* Set error handling if you are * using the setjmp/longjmp method * (this is the normal method of * doing things with libpng). * REQUIRED unless you set up * your own error handlers in * the png_create_read_struct() * earlier. */ if (setjmp(png_jmpbuf(png_ptr))) { /* Free all of the memory associated * with the png_ptr and info_ptr */ png_destroy_read_struct(&png_ptr, &info_ptr, NULL); fclose(fp); /* If we get here, we had a * problem reading the file */ fprintf(stderr, "ERROR: load_png: inconsistant file %s\n", path); return NULL; } /* Set up the output control if * you are using standard C streams */ png_init_io(png_ptr, fp); /* If we have already * read some of the signature */ png_set_sig_bytes(png_ptr, sig_read); /* * If you have enough memory to read * in the entire image at once, and * you need to specify only * transforms that can be controlled * with one of the PNG_TRANSFORM_* * bits (this presently excludes * dithering, filling, setting * background, and doing gamma * adjustment), then you can read the * entire image (including pixels) * into the info structure with this * call * * PNG_TRANSFORM_STRIP_16 | * PNG_TRANSFORM_PACKING forces 8 bit * PNG_TRANSFORM_EXPAND forces to * expand a palette into RGB */ png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_PACKING | PNG_TRANSFORM_EXPAND, NULL); png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL); row_bytes = png_get_rowbytes(png_ptr, info_ptr); switch( color_type ) { case PNG_COLOR_TYPE_GRAY: case PNG_COLOR_TYPE_GRAY_ALPHA: sf = PF_A8; pixel_size = 1; break; case PNG_COLOR_TYPE_RGB: sf = PF_R8G8B8; pixel_size = 3; break; case PNG_COLOR_TYPE_RGB_ALPHA: sf = PF_R8G8B8A8; pixel_size = 4; break; } // align the opengl texture to 4 byte width width_size = width * pixel_size; tex = image_allocate(width, height, sf); if( !tex ) { /* Clean up after the read, * and free any memory allocated */ png_destroy_read_struct(&png_ptr, &info_ptr, NULL); /* Close the file */ fclose(fp); return tex; } buff = (char*)tex->pixels; row_pointers = png_get_rows(png_ptr, info_ptr); for( r = 0; r < height; r++ ) { // note that png is ordered top to // bottom, but OpenGL expect it bottom to top // so the order or swapped memcpy(&(buff[width_size * r]), row_pointers[r], width_size); } /* Clean up after the read, * and free any memory allocated */ png_destroy_read_struct(&png_ptr, &info_ptr, NULL); /* Close the file */ fclose(fp); return tex; }
void GenericImage::read_png(const char *filename) { int w=0, h=0, c=0, b=0; FILE *filep = NULL; png_structp readp = NULL; png_infop infop = NULL; png_bytep *bytep = NULL; void *p = NULL; /* Initialize all PNG import data structures. */ if (!(filep = fopen(filename, "rb"))) { fail("can't open file\n"); } if (!(readp = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) fail("can't create png read struct\n"); if (!(infop = png_create_info_struct(readp))) fail("can't create png info struct\n"); /* Enable the default PNG error handler. */ if (setjmp(png_jmpbuf(readp)) == 0) { /* Read the PNG header. */ png_init_io (readp, filep); //STRIP_16 enforces 8 bit readout // png_read_png(readp, infop, PNG_TRANSFORM_STRIP_16 | // PNG_TRANSFORM_PACKING, NULL); //SWAP_ENDIAN swap byte order png_read_png(readp, infop, PNG_TRANSFORM_SWAP_ENDIAN | PNG_TRANSFORM_PACKING, NULL); /* Extract image properties. */ w = (int) png_get_image_width (readp, infop); h = (int) png_get_image_height(readp, infop); c = (int) png_get_channels(readp, infop); b = (int) png_get_bit_depth(readp, infop)/8; /* Read the pixel data. */ if ((bytep = png_get_rows(readp, infop))) { int i, j, s = w*c*b; /* Allocate the final pixel buffer and copy pixels there. */ if ((p = malloc(w * h * c * b))) { for (i = 0, j = h - 1; j >= 0; ++i, --j) memcpy((png_bytep) p + s * i, bytep[j], s); } else { fail("can't allocate image buffer\n"); } } } /* Release all resources. */ png_destroy_read_struct(&readp, &infop, NULL); fclose(filep); //setup the generic image object width = w; height = h; components = c; pix_depth = b; pixels = p; print(); success("read png file\n"); }
int IMG_SavePNG_RW(SDL_RWops *src, SDL_Surface *surf,int compression){ png_structp png_ptr; png_infop info_ptr; SDL_PixelFormat *fmt=NULL; SDL_Surface *tempsurf=NULL; int ret,funky_format,used_alpha; int i; uint8_t temp_alpha; png_colorp palette; uint8_t *palette_alpha=NULL; png_byte **row_pointers=NULL; png_ptr=NULL;info_ptr=NULL;palette=NULL;ret=-1; funky_format=0; if( !src || !surf) { goto savedone; /* Nothing to do. */ } row_pointers=(png_byte **)malloc(surf->h * sizeof(png_byte*)); if (!row_pointers) { SDL_SetError("Couldn't allocate memory for rowpointers"); goto savedone; } png_ptr=png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,NULL,NULL); if (!png_ptr){ SDL_SetError("Couldn't allocate memory for PNG file"); goto savedone; } info_ptr= png_create_info_struct(png_ptr); if (!info_ptr){ SDL_SetError("Couldn't allocate image information for PNG file"); goto savedone; } /* setup custom writer functions */ png_set_write_fn(png_ptr,(void *)src,png_write_data,NULL); if (setjmp(png_jmpbuf(png_ptr))){ SDL_SetError("Unknown error writing PNG"); goto savedone; } if(compression>Z_BEST_COMPRESSION) compression=Z_BEST_COMPRESSION; if(compression == Z_NO_COMPRESSION) // No compression { png_set_filter(png_ptr,0,PNG_FILTER_NONE); png_set_compression_level(png_ptr,Z_NO_COMPRESSION); } else if(compression<0) // Default compression png_set_compression_level(png_ptr,Z_DEFAULT_COMPRESSION); else png_set_compression_level(png_ptr,compression); fmt=surf->format; if(fmt->BitsPerPixel==8){ /* Paletted */ png_set_IHDR(png_ptr,info_ptr, surf->w,surf->h,8,PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); palette=(png_colorp) malloc(fmt->palette->ncolors * sizeof(png_color)); if (!palette) { SDL_SetError("Couldn't create memory for palette"); goto savedone; } for (i=0;i<fmt->palette->ncolors;i++) { palette[i].red=fmt->palette->colors[i].r; palette[i].green=fmt->palette->colors[i].g; palette[i].blue=fmt->palette->colors[i].b; } png_set_PLTE(png_ptr,info_ptr,palette,fmt->palette->ncolors); uint32_t colorkey; if (SDL_GetColorKey(surf, &colorkey) > 0) { palette_alpha=(uint8_t *)malloc((colorkey+1)*sizeof(uint8_t)); if (!palette_alpha) { SDL_SetError("Couldn't create memory for palette transparency"); goto savedone; } /* FIXME: memset? */ for (unsigned int i=0;i<(colorkey+1);i++) { palette_alpha[i]=255; } palette_alpha[colorkey]=0; png_set_tRNS(png_ptr,info_ptr,palette_alpha,colorkey+1,NULL); } }else{ /* Truecolor */ if (fmt->Amask) { png_set_IHDR(png_ptr,info_ptr, surf->w,surf->h,8,PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); } else { png_set_IHDR(png_ptr,info_ptr, surf->w,surf->h,8,PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); } } png_write_info(png_ptr, info_ptr); if (fmt->BitsPerPixel==8) { /* Paletted */ for(i=0;i<surf->h;i++){ row_pointers[i]= ((png_byte*)surf->pixels) + i*surf->pitch; } if(SDL_MUSTLOCK(surf)){ SDL_LockSurface(surf); } png_write_image(png_ptr, row_pointers); if(SDL_MUSTLOCK(surf)){ SDL_UnlockSurface(surf); } }else{ /* Truecolor */ if(fmt->BytesPerPixel==3){ if(fmt->Amask){ /* check for 24 bit with alpha */ funky_format=1; }else{ /* Check for RGB/BGR/GBR/RBG/etc surfaces.*/ #if SDL_BYTEORDER == SDL_BIG_ENDIAN if(fmt->Rmask!=0xFF0000 || fmt->Gmask!=0x00FF00 || fmt->Bmask!=0x0000FF){ #else if(fmt->Rmask!=0x0000FF || fmt->Gmask!=0x00FF00 || fmt->Bmask!=0xFF0000){ #endif funky_format=1; } } }else if (fmt->BytesPerPixel==4){ if (!fmt->Amask) { /* check for 32bit but no alpha */ funky_format=1; }else{ /* Check for ARGB/ABGR/GBAR/RABG/etc surfaces.*/ #if SDL_BYTEORDER == SDL_BIG_ENDIAN if(fmt->Rmask!=0xFF000000 || fmt->Gmask!=0x00FF0000 || fmt->Bmask!=0x0000FF00 || fmt->Amask!=0x000000FF){ #else if(fmt->Rmask!=0x000000FF || fmt->Gmask!=0x0000FF00 || fmt->Bmask!=0x00FF0000 || fmt->Amask!=0xFF000000){ #endif funky_format=1; } } }else{ /* 555 or 565 16 bit color */ funky_format=1; } if (funky_format) { /* Allocate non-funky format, and copy pixeldata in*/ if(fmt->Amask){ #if SDL_BYTEORDER == SDL_BIG_ENDIAN tempsurf = SDL_CreateRGBSurface(SDL_SWSURFACE, surf->w, surf->h, 24, 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff); #else tempsurf = SDL_CreateRGBSurface(SDL_SWSURFACE, surf->w, surf->h, 24, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000); #endif }else{ #if SDL_BYTEORDER == SDL_BIG_ENDIAN tempsurf = SDL_CreateRGBSurface(SDL_SWSURFACE, surf->w, surf->h, 24, 0xff0000, 0x00ff00, 0x0000ff, 0x00000000); #else tempsurf = SDL_CreateRGBSurface(SDL_SWSURFACE, surf->w, surf->h, 24, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000); #endif } if(!tempsurf){ SDL_SetError("Couldn't allocate temp surface"); goto savedone; } SDL_BlendMode bm; SDL_GetSurfaceBlendMode(surf, &bm); SDL_SetSurfaceBlendMode(surf, SDL_BLENDMODE_NONE); if(SDL_BlitSurface(surf,NULL,tempsurf,NULL)!=0){ SDL_SetError("Couldn't blit surface to temp surface"); SDL_FreeSurface(tempsurf); goto savedone; } SDL_SetSurfaceBlendMode(surf, bm); for(i=0;i<tempsurf->h;i++){ row_pointers[i]= ((png_byte*)tempsurf->pixels) + i*tempsurf->pitch; } if(SDL_MUSTLOCK(tempsurf)){ SDL_LockSurface(tempsurf); } png_write_image(png_ptr, row_pointers); if(SDL_MUSTLOCK(tempsurf)){ SDL_UnlockSurface(tempsurf); } SDL_FreeSurface(tempsurf); } else { for(i=0;i<surf->h;i++){ row_pointers[i]= ((png_byte*)surf->pixels) + i*surf->pitch; } if(SDL_MUSTLOCK(surf)){ SDL_LockSurface(surf); } png_write_image(png_ptr, row_pointers); if(SDL_MUSTLOCK(surf)){ SDL_UnlockSurface(surf); } } } png_write_end(png_ptr, NULL); ret=0; /* got here, so nothing went wrong. YAY! */ savedone: /* clean up and return */ png_destroy_write_struct(&png_ptr,&info_ptr); if (palette) { free(palette); } if (palette_alpha) { free(palette_alpha); } if (row_pointers) { free(row_pointers); } return ret; }
int main(int c, char *v[], char *e[]) { register int rflag = ttyflg; int rsflag = 1; /* local restricted flag */ register unsigned char *flagc = flagadr; struct namnod *n; init_sigval(); mypid = getpid(); mypgid = getpgid(mypid); mysid = getsid(mypid); /* * initialize storage allocation */ if (stakbot == 0) { addblok((unsigned)0); } /* * If the first character of the last path element of v[0] is "-" * (ex. -sh, or /bin/-sh), this is a login shell */ if (*simple(v[0]) == '-') { signal(SIGXCPU, SIG_DFL); signal(SIGXFSZ, SIG_DFL); /* * As the previous comment states, this is a login shell. * Therefore, we set the login_shell flag to explicitly * indicate this condition. */ login_shell = TRUE; } stdsigs(); /* * set names from userenv */ setup_env(); /* * Do locale processing. */ setlocale(LC_CTYPE, ""); /* * 'rsflag' is zero if SHELL variable is * set in environment and * the simple file part of the value. * is rsh */ if (n = findnam("SHELL")) { if (eq("rsh", simple(n->namval))) rsflag = 0; } /* * a shell is also restricted if the simple name of argv(0) is * rsh or -rsh in its simple name */ #ifndef RES if (c > 0 && (eq("rsh", simple(*v)) || eq("-rsh", simple(*v)))) rflag = 0; #endif if (eq("jsh", simple(*v)) || eq("-jsh", simple(*v))) flags |= monitorflg; hcreate(); set_dotpath(); /* * look for options * dolc is $# */ dolc = options(c, (unsigned char **)v); if (dolc < 2) { flags |= stdflg; { while (*flagc) flagc++; *flagc++ = STDFLG; *flagc = 0; } } if ((flags & stdflg) == 0) dolc--; if ((flags & privflg) == 0) { register uid_t euid; register gid_t egid; register uid_t ruid; register gid_t rgid; /* * Determine all of the user's id #'s for this process and * then decide if this shell is being entered as a result * of a fork/exec. * If the effective uid/gid do NOT match and the euid/egid * is < 100 and the egid is NOT 1, reset the uid and gid to * the user originally calling this process. */ euid = geteuid(); ruid = getuid(); egid = getegid(); rgid = getgid(); if ((euid != ruid) && (euid < 100)) setuid(ruid); /* reset the uid to the orig user */ if ((egid != rgid) && ((egid < 100) && (egid != 1))) setgid(rgid); /* reset the gid to the orig user */ } dolv = (unsigned char **)v + c - dolc; dolc--; /* * return here for shell file execution * but not for parenthesis subshells */ if (setjmp(subshell)) { freejobs(); flags |= subsh; } /* * number of positional parameters */ replace(&cmdadr, dolv[0]); /* cmdadr is $0 */ /* * set pidname '$$' */ assnum(&pidadr, (long)mypid); /* * set up temp file names */ settmp(); /* * default internal field separators * Do not allow importing of IFS from parent shell. * setup_env() may have set anything from parent shell to IFS. * Always set the default ifs to IFS. */ assign(&ifsnod, sptbnl); dfault(&timeoutnod, "0"); timeoutnod.namflg |= N_RDONLY; dfault(&mchknod, MAILCHECK); mailchk = stoi(mchknod.namval); /* initialize OPTIND for getopt */ n = lookup("OPTIND"); assign(n, "1"); /* * make sure that option parsing starts * at first character */ getopt_sp = 1; /* initialize multibyte information */ setwidth(); if ((beenhere++) == FALSE) /* ? profile */ { if ((login_shell == TRUE) && (flags & privflg) == 0) { /* system profile */ #ifndef RES if ((input = pathopen(nullstr, sysprofile)) >= 0) exfile(rflag); /* file exists */ #endif /* user profile */ if ((input = pathopen(homenod.namval, profile)) >= 0) { exfile(rflag); flags &= ~ttyflg; } } if (rsflag == 0 || rflag == 0) { if ((flags & rshflg) == 0) { while (*flagc) flagc++; *flagc++ = 'r'; *flagc = '\0'; } flags |= rshflg; } /* * open input file if specified */ if (comdiv) { estabf(comdiv); input = -1; } else { if (flags & stdflg) { input = 0; } else { /* * If the command file specified by 'cmdadr' * doesn't exist, chkopen() will fail calling * exitsh(). If this is a login shell and * the $HOME/.profile file does not exist, the * above statement "flags &= ~ttyflg" does not * get executed and this makes exitsh() call * longjmp() instead of exiting. longjmp() will * return to the location specified by the last * active jmpbuffer, which is the one set up in * the function exfile() called after the system * profile file is executed (see lines above). * This would cause an infinite loop, because * chkopen() will continue to fail and exitsh() * to call longjmp(). To make exitsh() exit instead * of calling longjmp(), we then set the flag forcexit * at this stage. */ flags |= forcexit; input = chkopen(cmdadr, 0); flags &= ~forcexit; } #ifdef ACCT if (input != 0) preacct(cmdadr); #endif comdiv--; } } #ifdef pdp11 else *execargs = (char *)dolv; /* for `ps' cmd */ #endif exfile(0); done(0); /*NOTREACHED*/ return 0; }