int read_image (dt_imageio_png_t *png, void *out) { if (setjmp(png_jmpbuf(png->png_ptr))) { fclose(png->f); png_destroy_read_struct(&png->png_ptr, NULL, NULL); return 1; } // reflect changes png_read_update_info(png->png_ptr, png->info_ptr); png_bytep row_pointer = (png_bytep) out; unsigned long rowbytes = png_get_rowbytes(png->png_ptr, png->info_ptr); for (int y = 0; y < png->height; y++) { png_read_row(png->png_ptr, row_pointer, NULL); row_pointer += rowbytes; } png_read_end(png->png_ptr, png->info_ptr); png_destroy_read_struct(&png->png_ptr, &png->info_ptr, NULL); fclose(png->f); return 0; }
void read_scanline( byte_t* dst ) { png_read_row( this->get()->_struct , dst , NULL ); }
int res_create_theme_display_surface(const char* name, const char* themename, gr_surface* pSurface) { gr_surface surface = NULL; int result = 0; png_structp png_ptr = NULL; png_infop info_ptr = NULL; png_uint_32 width, height; png_byte channels; *pSurface = NULL; result = open_theme_png(name, themename, &png_ptr, &info_ptr, &width, &height, &channels); if (result < 0) return result; surface = init_display_surface(width, height); if (surface == NULL) { result = -8; goto exit; } unsigned char* p_row = malloc(width * 4); unsigned int y; for (y = 0; y < height; ++y) { png_read_row(png_ptr, p_row, NULL); transform_rgb_to_draw(p_row, surface->data + y * surface->row_bytes, channels, width); } free(p_row); *pSurface = surface; exit: png_destroy_read_struct(&png_ptr, &info_ptr, NULL); if (result < 0 && surface != NULL) free(surface); return result; }
static VALUE each_interlace_none(struct each_args *args) { struct readerdata *reader; unsigned char *inwidthbuf, *outwidthbuf, *yinbuf; struct xscaler *xs; struct yscaler *ys; uint32_t i, scaley; int cmp; reader = args->reader; xs = &args->xs; inwidthbuf = xscaler_psl_pos0(xs); outwidthbuf = args->outwidthbuf; ys = &args->ys; scaley = reader->scale_height; cmp = png_get_channels(reader->png, reader->info); png_write_info(args->wpng, args->winfo); for(i=0; i<scaley; i++) { while ((yinbuf = yscaler_next(ys))) { png_read_row(reader->png, inwidthbuf, NULL); xscaler_scale(xs, yinbuf); } yscaler_scale(ys, outwidthbuf, i, cmp, 0); png_write_row(args->wpng, outwidthbuf); } png_write_end(args->wpng, args->winfo); return Qnil; }
static void Read3ByteRow(png_structp png_ptr, unsigned char *tmpRow, unsigned char *ImgData, int row_num, int width) { int pos; unsigned char *img_ptr, *tmp_ptr; png_read_row(png_ptr, tmpRow, NULL); img_ptr = ImgData + (row_num * width * 4); tmp_ptr = tmpRow; for (pos = 0; pos < width; pos++) { *img_ptr = *tmp_ptr; img_ptr++; tmp_ptr++; *img_ptr = *tmp_ptr; img_ptr++; tmp_ptr++; *img_ptr = *tmp_ptr; img_ptr++; tmp_ptr++; *img_ptr = 255; /* Alpha channel */ img_ptr++; } }
static VALUE p_gets(VALUE self) { struct png_data *reader; png_structp png_ptr; png_infop info_ptr; png_uint_32 sl_width; size_t height; VALUE sl; Data_Get_Struct(self, struct png_data, reader); png_ptr = reader->png_ptr; info_ptr = reader->info_ptr; height = png_get_image_height(png_ptr, info_ptr); if (reader->lineno >= height) return Qnil; sl_width = png_get_rowbytes(png_ptr, info_ptr); sl = rb_str_new(0, sl_width); png_read_row(png_ptr, (png_bytep)RSTRING_PTR(sl), (png_bytep)NULL); reader->lineno += 1; if (reader->lineno >= height) png_read_end(png_ptr, info_ptr); return sl; }
/* Read the entire image. If the image has an alpha channel or a tRNS * chunk, and you have called png_handle_alpha()[*], you will need to * initialize the image to the current image that PNG will be overlaying. * We set the num_rows again here, in case it was incorrectly set in * png_read_start_row() by a call to png_read_update_info() or * png_start_read_image() if png_set_interlace_handling() wasn't called * prior to either of these functions like it should have been. You can * only call this function once. If you desire to have an image for * each pass of a interlaced image, use png_read_rows() instead. * * [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.8 */ void PNGAPI png_read_image(png_structp png_ptr, png_bytepp image) { png_uint_32 i, image_height; int pass, j; png_bytepp rp; png_debug(1, "in png_read_image\n"); #ifdef PNG_READ_INTERLACING_SUPPORTED pass = png_set_interlace_handling(png_ptr); #else if (png_ptr->interlaced) png_error(png_ptr, "Cannot read interlaced image -- interlace handler disabled."); pass = 1; #endif image_height = png_ptr->height; png_ptr->num_rows = image_height; /* Make sure this is set correctly */ for (j = 0; j < pass; j++) { rp = image; for (i = 0; i < image_height; i++) { png_read_row(png_ptr, *rp, png_bytep_NULL); rp++; } } }
void read_image_data(const char* filename, png_bytep* input, png_bytep* output, size_t* w, size_t* h) { int i; /* Open input file */ FILE *png_input; if((png_input = fopen("input.png", "rb")) == NULL) { perror("Can't read input image file"); exit(1); } /* Read image data */ png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); png_infop info_ptr = png_create_info_struct(png_ptr); png_init_io(png_ptr, png_input); png_read_info(png_ptr, info_ptr); *w = png_get_image_width(png_ptr, info_ptr); *h = png_get_image_height(png_ptr, info_ptr); /* Allocate input/output memory and initialize data */ input = (png_bytep*)malloc(*h * png_get_rowbytes(png_ptr, info_ptr)); output = (png_bytep*)malloc(*h * png_get_rowbytes(png_ptr, info_ptr) * SCALE_FACTOR * SCALE_FACTOR ); for(i=0; i<*h; i++) { png_read_row(png_ptr, *input + i * png_get_rowbytes(png_ptr, info_ptr), NULL); } /* Close input file */ png_read_end(png_ptr, info_ptr); png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); // fclose(png_input); }
/** * \brief Reads a row of image data at a time. */ void read_row(byte* bytes) { if (setjmp(png_jmpbuf(m_png))) { throw error(m_error); } png_read_row(m_png, bytes, 0); }
bool emPngImageFileModel::TryContinueLoading() throw(emString) { png_textp t; int e,i,n; if (!L->ImagePrepared) { Image.Setup( L->width, L->height, L->bytes_per_pixel ); Signal(ChangeSignal); L->ImagePrepared=true; return false; } if (setjmp(L->jmpbuffer)) throw emString(L->errorText); if (L->y<(int)L->height && L->pass<L->number_of_passes) { png_read_row( L->png_ptr, Image.GetWritableMap()+L->y*Image.GetWidth()*Image.GetChannelCount(), NULL ); L->y++; if (L->y>=(int)L->height) { L->y=0; L->pass++; } Signal(ChangeSignal); return false; } png_read_end(L->png_ptr,L->end_info_ptr); for (e=0; e<2; e++) { n=png_get_text( L->png_ptr, e ? L->end_info_ptr : L->info_ptr, &t, NULL ); for (i=0; i<n; i++) { if ( t[i].text && *t[i].text && t[i].key && ( strcasecmp(t[i].key,"Comment")==0 || strcasecmp(t[i].key,"Description")==0 ) ) { if (!Comment.IsEmpty()) Comment+='\n'; Comment+=t[i].text; } } } Signal(ChangeSignal); return true; }
static int read_png ( FILE *fp ) { png_structp png_ptr = png_create_read_struct ( PNG_LIBPNG_VER_STRING,0,0,0 ); png_infop info_ptr = NULL; png_bytep row = NULL, display = NULL; if ( png_ptr == NULL ) return 0; if ( setjmp ( png_jmpbuf ( png_ptr ) ) ) { png_destroy_read_struct ( &png_ptr, &info_ptr, NULL ); if ( row != NULL ) free ( row ); if ( display != NULL ) free ( display ); return 0; } png_init_io ( png_ptr, fp ); info_ptr = png_create_info_struct ( png_ptr ); if ( info_ptr == NULL ) png_error ( png_ptr, "OOM allocating info structure" ); png_read_info ( png_ptr, info_ptr ); { png_size_t rowbytes = png_get_rowbytes ( png_ptr, info_ptr ); row = malloc ( rowbytes ); display = malloc ( rowbytes ); if ( row == NULL || display == NULL ) png_error ( png_ptr, "OOM allocating row buffers" ); { png_uint_32 height = png_get_image_height ( png_ptr, info_ptr ); int passes = png_set_interlace_handling ( png_ptr ); int pass; png_start_read_image ( png_ptr ); for ( pass = 0; pass < passes; ++pass ) { png_uint_32 y = height; /* NOTE: this trashes the row each time; interlace handling won't * work, but this avoids memory thrashing for speed testing. */ while ( y-- > 0 ) png_read_row ( png_ptr, row, display ); } } } /* Make sure to read to the end of the file: */ png_read_end ( png_ptr, info_ptr ); png_destroy_read_struct ( &png_ptr, &info_ptr, NULL ); free ( row ); free ( display ); return 1; }
const unsigned char* CImageLoaderPng::ReadRow(void *row_ptr) { #ifdef _engine_COMPILE_WITH_LIBPNG_ png_read_row((png_structp)row_ptr, (png_bytep)g_png_load_buffer, 0); return (const unsigned char*)g_png_load_buffer; #else return 0; #endif // _engine_COMPILE_WITH_LIBPNG_ }
static void read_scanline(struct oil_libpng *ol) { int i; for (i=oil_scale_slots(&ol->os); i>0; i--) { png_read_row(ol->rpng, ol->inbuf, NULL); oil_scale_in(&ol->os, ol->inbuf); } }
int stencilize (InPng *in_png, char *output_filename) { FILE *fh; png_structp png; png_infop png_info; png_bytep row; int i, j; if (!(fh = fopen(output_filename, "wb"))) { fail("failed to open output file"); } png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (!png) { fail("could not create png"); } png_info = png_create_info_struct(png); if (!png_info) { fail("could not create png_info"); } png_init_io(png, fh); png_set_IHDR(png, png_info, in_png->info->width, in_png->info->height, in_png->info->bit_depth, in_png->info->color_type, in_png->info->interlace_type, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); png_write_info(png, png_info); row = in_png->row; for (i = 0; i < in_png->info->height; i++) { png_read_row(in_png->png, row, NULL); j = 0; while (j < in_png->rowstride) { row[j + 0] = 0; row[j + 1] = 0; row[j + 2] = 0; row[j + 3] = 255 - row[j + 3]; j += 4; } png_write_row(png, row); } png_write_end(png, png_info); fclose(fh); return 1; }
bool onSkipScanlines(int count) override { if (setjmp(png_jmpbuf(fPng_ptr))) { SkCodecPrintf("Failed to skip row.\n"); return false; } for (int row = 0; row < count; row++) { png_read_row(fPng_ptr, fSwizzlerSrcRow, nullptr); } return true; }
// // Load a texture from a png image // bool PngLoader::loadImageIntoBuffer() { DEBUG_ENTER_FUNC(); if (!basicImageLoad()) { png_destroy_read_struct(&_pngPtr, &_infoPtr, png_infopp_NULL); return false; } png_set_strip_16(_pngPtr); // Strip off 16 bit channels in case they occur if (_paletteSize) { // Copy the palette png_colorp srcPal = _infoPtr->palette; for (int i = 0; i < _infoPtr->num_palette; i++) { unsigned char alphaVal = (i < _infoPtr->num_trans) ? _infoPtr->trans[i] : 0xFF; // Load alpha if it's there _palette->setSingleColorRGBA(i, srcPal->red, srcPal->green, srcPal->blue, alphaVal); srcPal++; } } else { // Not a palettized image if (_colorType == PNG_COLOR_TYPE_GRAY && _bitDepth < 8) png_set_gray_1_2_4_to_8(_pngPtr); // Round up grayscale images if (png_get_valid(_pngPtr, _infoPtr, PNG_INFO_tRNS)) png_set_tRNS_to_alpha(_pngPtr); // Convert trans channel to alpha for 32 bits png_set_add_alpha(_pngPtr, 0xff, PNG_FILLER_AFTER); // Filler for alpha if none exists } uint32 rowBytes = png_get_rowbytes(_pngPtr, _infoPtr); // there seems to be a bug in libpng where it doesn't increase the rowbytes or the // channel even after we add the alpha channel if (_channels == 3 && (rowBytes / _width) == 3) { _channels = 4; rowBytes = _width * _channels; } PSP_DEBUG_PRINT("rowBytes[%d], channels[%d]\n", rowBytes, _channels); unsigned char *line = (unsigned char*) malloc(rowBytes); if (!line) { png_destroy_read_struct(&_pngPtr, png_infopp_NULL, png_infopp_NULL); PSP_ERROR("Couldn't allocate line\n"); return false; } for (size_t y = 0; y < _height; y++) { png_read_row(_pngPtr, line, png_bytep_NULL); _buffer->copyFromRect(line, rowBytes, 0, y, _width, 1); // Copy into buffer } free(line); png_read_end(_pngPtr, _infoPtr); png_destroy_read_struct(&_pngPtr, &_infoPtr, png_infopp_NULL); return true; }
// 读取一行png数据 bool PngReader::ReadRowData(png_bytep buffer) { bool result = false; if (NULL != m_readPtr && NULL != m_readInfoPtr) { png_read_row(m_readPtr, buffer, NULL); result = true; } return result; }
int main(int argc, char **argv) { int x,y; unsigned char* image; png_structp png_ptr_read; png_infop info_ptr_read; FILE *in_file, *out_file; double gamma; in_file=fopen("arrow.png","r"); out_file=fopen("arrow.inc","w"); if (!(in_file&&out_file)){ perror("arrow"); exit(1); } png_ptr_read=png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); info_ptr_read=png_create_info_struct(png_ptr_read); png_init_io(png_ptr_read, in_file); png_read_info(png_ptr_read, info_ptr_read); x=png_get_image_width(png_ptr_read,info_ptr_read); y=png_get_image_height(png_ptr_read,info_ptr_read); if (png_get_gAMA(png_ptr_read,info_ptr_read, &gamma)) { png_set_gamma(png_ptr_read, 1, gamma); } else { png_set_gamma(png_ptr_read, 1, 1.0); } png_read_update_info(png_ptr_read, info_ptr_read); image=malloc(3*x); if (!image){ fprintf(stderr,"Not enough memory\n"); exit(1); } fprintf(out_file,"/* Automatically generated by the program \"arrow\" (arrow.c) */"); fprintf(out_file,"enum {arrow_width=32, arrow_height=%d, arrow_area=%d};\n",y,y*32); fprintf(out_file,"\nstatic unsigned int arrow[%d]={\n",y+y); for (;y;y--){ png_read_row(png_ptr_read,image,NULL); print_row_hex(out_file,image,x); } fprintf(out_file,"};\n"); free(image); png_read_end(png_ptr_read, NULL); png_destroy_read_struct(&png_ptr_read, &info_ptr_read, NULL); fclose(in_file); return 0; }
Raster::Line PNGRaster::GetLine(int line) { ASSERT(data && line >= 0 && line < data->size.cy); byte *scanline = new byte[data->row_bytes]; if(setjmp(png_jmpbuf(data->png_ptr))) return Raster::Line(scanline, this, true); if(data->preload) { delete[] scanline; if(!data->loaded) { data->loaded = true; data->preimage.SetCount(data->row_bytes * data->size.cy); data->row_pointers.Alloc(data->size.cy); for(int i = 0; i < data->size.cy; i++) data->row_pointers[i] = &data->preimage[i * data->row_bytes]; png_read_image(data->png_ptr, data->row_pointers); } const byte *rowdata = &data->preimage[data->row_bytes * line]; return Raster::Line(rowdata, this, false); } else { if(line < data->next_row) { png_destroy_read_struct(&data->png_ptr, &data->info_ptr, NULL); GetStream().Seek(data->soff); if(!Init()) { NEVER(); } if(data->strip16) png_set_strip_16(data->png_ptr); if(data->out_bpp > 8) png_set_bgr(data->png_ptr); data->next_row = 0; } while(data->next_row < line) { png_read_row(data->png_ptr, scanline, NULL); data->next_row++; } png_read_row(data->png_ptr, scanline, NULL); data->next_row++; return Raster::Line(scanline, this, true); } }
bool PNGIgnorePixels(png_structp png, png_infop info) { if (setjmp(png_jmpbuf(png))) { return false; } unsigned height = png_get_image_height(png, info); unsigned i; for (i = 0; i < height; ++i) { png_read_row(png, 0, 0); } return true; }
bool onSkipScanlines(int count) override { // Assume that an error in libpng indicates an incomplete input. if (setjmp(png_jmpbuf(this->png_ptr()))) { SkCodecPrintf("setjmp long jump!\n"); return false; } for (int row = 0; row < count; row++) { png_read_row(this->png_ptr(), fSrcRow, nullptr); } return true; }
static int png2vips_generate( VipsRegion *or, void *seq, void *a, void *b, gboolean *stop ) { VipsRect *r = &or->valid; Read *read = (Read *) a; int y; #ifdef DEBUG printf( "png2vips_generate: line %d, %d rows\n", r->top, r->height ); #endif /*DEBUG*/ /* We're inside a tilecache where tiles are the full image width, so * this should always be true. */ g_assert( r->left == 0 ); g_assert( r->width == or->im->Xsize ); g_assert( VIPS_RECT_BOTTOM( r ) <= or->im->Ysize ); /* Tiles should always be a strip in height, unless it's the final * strip. */ g_assert( r->height == VIPS_MIN( 8, or->im->Ysize - r->top ) ); /* And check that y_pos is correct. It should be, since we are inside * a vips_sequential(). */ g_assert( r->top == read->y_pos ); for( y = 0; y < r->height; y++ ) { png_bytep q = (png_bytep) VIPS_REGION_ADDR( or, 0, r->top + y ); /* We need to catch and ignore errors from read_row(). */ if( !setjmp( png_jmpbuf( read->pPng ) ) ) png_read_row( read->pPng, q, NULL ); else { #ifdef DEBUG printf( "png2vips_generate: png_read_row() failed, " "line %d\n", r->top + y ); printf( "png2vips_generate: file %s\n", read->name ); printf( "png2vips_generate: thread %p\n", g_thread_self() ); #endif /*DEBUG*/ } read->y_pos += 1; } return( 0 ); }
// // ReadImage() // read a PNG format image into memory, returning the image itself // This version reads the entire image // CImage* CImageIOPng::ReadImage(CNcbiIstream& istr) { png_structp png_ptr = NULL; png_infop info_ptr = NULL; png_infop end_ptr = NULL; CRef<CImage> image; try { // create our PNG structures s_PngReadInit(png_ptr, info_ptr, end_ptr); // begin reading our image png_set_read_fn(png_ptr, &istr, s_PngRead); png_read_info(png_ptr, info_ptr); // store and validate our image's parameters size_t width = 0; size_t height = 0; size_t depth = 0; size_t x = (size_t)-1; size_t y = (size_t)-1; size_t w = (size_t)-1; size_t h = (size_t)-1; s_PngReadValidate(png_ptr, info_ptr, width, height, depth, x, y, w, h); // allocate our image and read, line by line image.Reset(new CImage(width, height, depth)); unsigned char* row_ptr = image->SetData(); for (size_t i = 0; i < height; ++i) { png_read_row(png_ptr, row_ptr, NULL); row_ptr += width * depth; } // read the end pointer png_read_end(png_ptr, end_ptr); // close and return s_PngReadFinalize(png_ptr, info_ptr, end_ptr); } catch (...) { // destroy everything s_PngReadFinalize(png_ptr, info_ptr, end_ptr); // rethrow throw; } return image.Release(); }
void PNGAPI png_read_rows(png_structp png_ptr, png_bytepp row, png_bytepp display_row, png_uint_32 num_rows) { png_uint_32 i; png_bytepp rp; png_bytepp dp; png_debug(1, "in png_read_rows"); if (png_ptr == NULL) return; rp = row; dp = display_row; if (rp != NULL && dp != NULL) for (i = 0; i < num_rows; i++) { png_bytep rptr = *rp++; png_bytep dptr = *dp++; png_read_row(png_ptr, rptr, dptr); } else if (rp != NULL) for (i = 0; i < num_rows; i++) { png_bytep rptr = *rp; png_read_row(png_ptr, rptr, NULL); rp++; } else if (dp != NULL) for (i = 0; i < num_rows; i++) { png_bytep dptr = *dp; png_read_row(png_ptr, NULL, dptr); dp++; } }
int read_png_client(int row_start, int n_rows_to_get, void *dest_void, void *read_client_info, meta_parameters *meta, int data_type) { // since we set "require_full_load", we should be reading in the // entire image assert(row_start == 0); assert(n_rows_to_get == meta->general->line_count); unsigned char *dest = (unsigned char*)dest_void; ReadPngClientInfo *info = (ReadPngClientInfo*)read_client_info; // these will explode if we ever call this fn a second time on // the same data. Shouldn't happen, because we set "require_full_load" assert(info->fp); assert(info->png_ptr); assert(info->info_ptr); png_structp png_ptr = (png_structp)info->png_ptr; png_infop info_ptr = (png_infop)info->info_ptr; int ns = meta->general->sample_count; int nchan = info->rgb_flag ? 3 : 1; png_bytep png_buf = MALLOC(ns * sizeof(png_byte) * nchan); int ii, jj, b, k=0; // iterate over all rows in the png for ( ii = 0; ii < n_rows_to_get; ii++ ) { png_read_row(png_ptr, png_buf, NULL); for (jj = 0 ; jj < ns; jj++ ) { for (b = 0; b<nchan; ++b) dest[k+b] = png_buf[nchan*jj+b]; k += nchan; } } fclose(info->fp); info->fp = NULL; png_destroy_read_struct(&png_ptr, &info_ptr, NULL); info->png_ptr = NULL; info->info_ptr = NULL; FREE(png_buf); return TRUE; }
//============================================================================= // load_png //============================================================================= int load_png(PKLImage pkl, FILE *image) { png_structp png_ptr; png_infop info_ptr; int i; png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if(!png_ptr) return(1); info_ptr = png_create_info_struct(png_ptr); if(!info_ptr){ png_destroy_read_struct(&png_ptr, NULL, NULL); return(1); } if( setjmp(png_jmpbuf(png_ptr)) ){ png_destroy_info_struct(png_ptr, &info_ptr); png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); return(1); } png_init_io(png_ptr, image); png_read_info(png_ptr, info_ptr); pkl->width = info_ptr->width; pkl->height = info_ptr->height; pkl->color = color_pn2pk(info_ptr->color_type); pkl->channel = pkl_png_channels(pkl->color); pkl->resh = resolution_p2p(info_ptr->phys_unit_type, info_ptr->x_pixels_per_unit); pkl->resv = resolution_p2p(info_ptr->phys_unit_type, info_ptr->y_pixels_per_unit); if(pkl->color == PKL_UNKNOWN) return(1); pkl->image = malloc(pkl->width * pkl->height * pkl->channel); if(!pkl->image) return(1); if(info_ptr->color_type==PNG_COLOR_TYPE_RGB_ALPHA || info_ptr->color_type==PNG_COLOR_TYPE_GRAY_ALPHA || info_ptr->num_trans) png_set_strip_alpha(png_ptr); if(info_ptr->bit_depth<8 && info_ptr->color_type==PNG_COLOR_TYPE_GRAY) png_set_gray_1_2_4_to_8(png_ptr); if(info_ptr->bit_depth==16) png_set_strip_16(png_ptr); if(info_ptr->color_type==PNG_COLOR_TYPE_PALETTE) png_set_palette_to_rgb(png_ptr); for(i=0; i<pkl->height; i++) png_read_row(png_ptr, &pkl->image[i*pkl->width*pkl->channel], NULL); png_destroy_info_struct(png_ptr, &info_ptr); png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); return(0); }
int res_create_alpha_surface(const char *name, gr_surface *pSurface) { int result = 0; unsigned int y; unsigned char *p_row; gr_surface surface = NULL; png_structp png_ptr = NULL; png_infop info_ptr = NULL; png_uint_32 width, height; png_byte channels; FILE *fp = NULL; *pSurface = NULL; result = open_png(name, &png_ptr, &info_ptr, &fp, &width, &height, &channels); if (result < 0) return result; if (channels != 1) { result = -7; goto exit; } if (!(surface = malloc_surface(width * height))) { result = -8; goto exit; } surface->width = width; surface->height = height; surface->row_bytes = width; surface->pixel_bytes = 1; for (y = 0; y < height; y++) { p_row = surface->data + y * surface->row_bytes; png_read_row(png_ptr, p_row, NULL); } *pSurface = surface; exit: close_png(&png_ptr, &info_ptr, fp); if (result < 0 && surface != NULL) free(surface); return result; }
static int read_convert_bitmap(gp_pixmap *res, gp_progress_cb *callback, png_structp png, int passes, double gamma) { uint16_t *row; if (passes > 1) { GP_DEBUG(1, "Interlaced 16 bit PNG not supported"); return ENOSYS; } row = malloc(6 * res->w); if (!row) { GP_DEBUG(1, "Malloc failed :("); return ENOMEM; } unsigned int y; if (gamma < 0.01) gp_pixmap_set_gamma(res, 2.2); for (y = 0; y < res->h; y++) { png_read_row(png, (void*)row, NULL); uint8_t *rrow = GP_PIXEL_ADDR(res, 0, y); unsigned int x = 0; if (gamma > 0.1) { for (x = 0; x < res->w; x++) { rrow[3*x] = row[3 * x]>>8; rrow[3*x + 1] = row[3 * x + 1]>>8; rrow[3*x + 2] = row[3 * x + 2]>>8; } } else { for (x = 0; x < res->w; x++) { rrow[3*x] = gp_linear16_to_gamma8(row[3 * x]); rrow[3*x + 1] = gp_linear16_to_gamma8(row[3 * x + 1]); rrow[3*x + 2] = gp_linear16_to_gamma8(row[3 * x + 2]); } } if (gp_progress_cb_report(callback, y, res->h, res->w)) { GP_DEBUG(1, "Operation aborted"); free(row); return ECANCELED; } }
int onGetScanlines(void* dst, int count, size_t rowBytes) override { // Assume that an error in libpng indicates an incomplete input. int row = 0; if (setjmp(png_jmpbuf(this->png_ptr()))) { SkCodecPrintf("setjmp long jump!\n"); return row; } void* dstRow = dst; for (; row < count; row++) { png_read_row(this->png_ptr(), fSrcRow, nullptr); this->swizzler()->swizzle(dstRow, fSrcRow); dstRow = SkTAddOffset<void>(dstRow, rowBytes); } return row; }
inline void transport_read_png24(Transport * trans, const uint8_t * data, const size_t width, const size_t height, const size_t rowsize) { png_struct * ppng = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr); png_set_read_fn(ppng, trans, &png_read_data_fn); png_info * pinfo = png_create_info_struct(ppng); png_read_info(ppng, pinfo); for (size_t k = 0 ; k < height ; ++k) { png_read_row(ppng, const_cast<unsigned char*>(data), nullptr); data += rowsize; } png_read_end(ppng, pinfo); png_destroy_read_struct(&ppng, &pinfo, nullptr); }