Example #1
0
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;
}
Example #4
0
File: png.c Project: ender672/oil
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;
}
Example #5
0
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++;
  }
}
Example #6
0
File: png.c Project: ender672/axon
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;
}
Example #7
0
/* 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++;
    }
  }
}
Example #8
0
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);
}
Example #9
0
 /**
  * \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;
}
Example #11
0
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_
}
Example #13
0
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);
	}
}
Example #14
0
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;
}
Example #15
0
    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;
    }
Example #16
0
//
// 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;
}
Example #17
0
// 读取一行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;
}
Example #19
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);
	}
}
Example #20
0
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;
}
Example #21
0
    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;
    }
Example #22
0
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 );
}
Example #23
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++;
      }
}
Example #25
0
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;
}
Example #26
0
//=============================================================================
// 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;
}
Example #28
0
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;
		}
	}
Example #29
0
    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;
    }
Example #30
0
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);
}