C++ png_get_image_height函数代码示例

int image_png_read_header(MediaScanImage *i, MediaScanResult *r) {
  int x;
  PNGData *p = malloc(sizeof(PNGData));
  i->_png = (void *)p;
  LOG_MEM("new PNGData @ %p\n", i->_png);

  p->buf = (Buffer *)r->_buf;
  p->fp = r->_fp;
  p->path = r->path;

  p->png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp) p, image_png_error, image_png_warning);
  if (!p->png_ptr)
    FATAL("Could not initialize libpng\n");

  p->info_ptr = png_create_info_struct(p->png_ptr);
  if (!p->info_ptr) {
    png_destroy_read_struct(&p->png_ptr, (png_infopp) NULL, (png_infopp) NULL);
    FATAL("Could not initialize libpng\n");
  }

  if (setjmp(png_jmpbuf(p->png_ptr))) {
    image_png_destroy(i);
    return 0;
  }

  png_set_read_fn(p->png_ptr, p, image_png_read_buf);

  png_read_info(p->png_ptr, p->info_ptr);

  i->width = png_get_image_width(p->png_ptr, p->info_ptr);
  i->height = png_get_image_height(p->png_ptr, p->info_ptr);
  i->channels = png_get_channels(p->png_ptr, p->info_ptr);
  i->has_alpha = 1;
  r->mime_type = MIME_IMAGE_PNG;

  // Match with DLNA profile
  // DLNA does not support interlaced images
  if (png_get_interlace_type(p->png_ptr, p->info_ptr) == PNG_INTERLACE_NONE) {
    for (x = 0; png_profiles_mapping[x].profile; x++) {
      if (i->width <= png_profiles_mapping[x].max_width && i->height <= png_profiles_mapping[x].max_height) {
        r->dlna_profile = png_profiles_mapping[x].profile->id;
        break;
      }
    }
  }

  return 1;
}

int PngSize(
    FILE * fd,
    long *width,
    long *height)
{
    png_structp png_read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
                                                      (png_voidp) NULL,
                                                      /* we would need to point to error handlers
                                                         here to do it properly */
                                                      (png_error_ptr) NULL,
                                                      (png_error_ptr) NULL);

    png_infop info_ptr = png_create_info_struct(png_read_ptr);

    (*width) = 0;
    (*height) = 0;

/* this is to make compile on aix work since they seem to define jmpbuf
   to be _jmpbuf which breaks compilation */

#ifndef png_jmpbuf
#ifdef PNG_SETJMP_SUPPORTED
#  define png_jmpbuf(png_ptr)   ((png_ptr)->PNG_jmpbuf)
#else
#ifdef jmpbuf
#undef jmpbuf
#endif
#  define png_jmpbuf(png_ptr)   ((png_ptr)->jmpbuf)
#endif
#endif

    if (setjmp(png_jmpbuf(png_read_ptr))) {
        png_destroy_read_struct(&png_read_ptr, &info_ptr, (png_infopp) NULL);
        return 0;
    }

    png_init_io(png_read_ptr, fd);
    png_read_info(png_read_ptr, info_ptr);
    (*width) = png_get_image_width(png_read_ptr, info_ptr);
    (*height) = png_get_image_height(png_read_ptr, info_ptr);

    png_destroy_read_struct(&png_read_ptr, &info_ptr, NULL);
    if (*width > 0 && *height > 0)
        return 1;
    else
        return 0;
}

int oil_libpng_init(struct oil_libpng *ol, png_structp rpng, png_infop rinfo,
	int out_width, int out_height)
{
	int ret, in_width, in_height, buf_len;
	enum oil_colorspace cs;

	ol->rpng = rpng;
	ol->rinfo = rinfo;
	ol->in_vpos = 0;
	ol->inbuf = NULL;
	ol->inimage = NULL;

	cs = png_cs_to_oil(png_get_color_type(rpng, rinfo));
	if (cs == OIL_CS_UNKNOWN) {
		return -1;
	}

	in_width = png_get_image_width(rpng, rinfo);
	in_height = png_get_image_height(rpng, rinfo);
	ret = oil_scale_init(&ol->os, in_height, out_height, in_width,
		out_width, cs);
	if (ret!=0) {
		free(ol->inbuf);
		return ret;
	}

	buf_len = png_get_rowbytes(rpng, rinfo);
	switch (png_get_interlace_type(rpng, rinfo)) {
	case PNG_INTERLACE_NONE:
		ol->inbuf = malloc(buf_len);
		if (!ol->inbuf) {
			oil_scale_free(&ol->os);
			return -2;
		}
		break;
	case PNG_INTERLACE_ADAM7:
		ol->inimage = alloc_full_image_buf(in_height, buf_len);
		if (!ol->inimage) {
			oil_scale_free(&ol->os);
			return -2;
		}
		png_read_image(rpng, ol->inimage);
		break;
	}

	return 0;
}

static void readPng(gambatte::uint_least32_t *const out, const char *const filename) {
    const struct PngContext {
        png_structp png;
        png_infop info;
        png_infop endinfo;

        PngContext() :
            png(png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0)),
            info(png ? png_create_info_struct(png) : 0),
            endinfo(png ? png_create_info_struct(png) : 0)
        {
            assert(png);
            assert(info);
            assert(endinfo);
        }

        ~PngContext() {
            png_destroy_read_struct(&png, &info, &endinfo);
        }
    } pngCtx;

    const struct FileCtx {
        std::FILE *f;
        FileCtx(const char *filename) : f(std::fopen(filename, "rb")) {
            assert(f);
        }
        ~FileCtx() {
            std::fclose(f);
        }
    } fileCtx(filename);

    if (setjmp(png_jmpbuf(pngCtx.png)))
        std::abort();

    png_init_io(pngCtx.png, fileCtx.f);
    png_read_png(pngCtx.png, pngCtx.info, 0, 0);

    assert(png_get_image_height(pngCtx.png, pngCtx.info) == 144);
    assert(png_get_rowbytes(pngCtx.png, pngCtx.info) == 160 * 4);

    png_bytep *const rows = png_get_rows(pngCtx.png, pngCtx.info);

    for (std::size_t y = 0; y < 144; ++y)
        for (std::size_t x = 0; x < 160; ++x)
            out[y * 160 + x] = rows[y][x * 4] << 16 | rows[y][x * 4 + 1] << 8 | rows[y][x * 4 + 2];
}

Texture* TextureReader::read()
{
    verifySignature(reader);
    initialisePNGReader(reader);

    const unsigned char* data = readImageData();
    const unsigned int width = png_get_image_width(_png, _pngInfo);
    const unsigned int height = png_get_image_height(_png, _pngInfo);

    _data = (GLubyte*)data;
    Texture* texture = new Texture(_data, width, height, 0);
    texture->setData(data);
    delete[] data;
    png_destroy_read_struct(&_png, &_pngInfo, NULL);

    return texture;
}

int png_load_hdr(img I) {
    unsigned char sig[PNG_SIG_LEN];
    png_structp png_ptr;
    png_infop info_ptr;

    rewind(I->fp);

    if (fread(sig, sizeof(sig[0]), PNG_SIG_LEN, I->fp) != PNG_SIG_LEN) {
        return(0);
    }

    /* Check the PNG signature of the file */
    if (png_sig_cmp(sig, (png_size_t)0, PNG_SIG_LEN)) {
        I->err = IE_HDRFORMAT;
        return 0;
    }

    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
        NULL, NULL, NULL);

    if (png_ptr == NULL) {
        I->err = IE_HDRFORMAT;
        return 0;
    }

    info_ptr = png_create_info_struct(png_ptr);

    if (info_ptr == NULL) {
        png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
        I->err = IE_HDRFORMAT;
        return 0;
    }
    
    rewind(I->fp);
    png_init_io(png_ptr, I->fp);

    png_read_info(png_ptr, info_ptr);

    I->width = png_get_image_width(png_ptr, info_ptr);
    I->height = png_get_image_height(png_ptr, info_ptr);
    
    png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);

    return(1);
}

static int loadPNGDecode(unsigned char **pixels, int *width, int *height, int flags,
						 png_structp png_ptr, png_infop info_ptr,  png_infop end_info, 
						 const char *callerStr) {
	// get header info
    png_read_info(png_ptr, info_ptr);

    *width = png_get_image_width(png_ptr, info_ptr);
    *height = png_get_image_height(png_ptr, info_ptr);
	int color_type = png_get_color_type(png_ptr, info_ptr);
    int bit_depth = png_get_bit_depth(png_ptr, info_ptr);

    if (color_type == PNG_COLOR_TYPE_PALETTE && bit_depth <= 8) png_set_expand(png_ptr);
    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) png_set_expand(png_ptr);
    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) png_set_expand(png_ptr);
    if (bit_depth == 16) png_set_strip_16(png_ptr);
	if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
		png_set_gray_to_rgb(png_ptr);

	// decode
	if (pixels) {
		if (!(flags & PNG_NO_ALLOC))
			*pixels = (unsigned char*)malloc(3 * (*width) * (*height) * sizeof(unsigned char));
		unsigned char **row_pointers = (unsigned char **)malloc(2 * (*height) * sizeof(unsigned char*));

		if ((*pixels == NULL) || (row_pointers == NULL)) {
			cprintf("%s: memory allocation error\n", callerStr);
			if ((!(flags & PNG_NO_ALLOC)) && (*pixels)) free(*pixels);
			if (row_pointers) free(row_pointers);
			return -1;
		}

		int i;
		for (i = 0; i < 2 * (*height); i++) {
			row_pointers[i] = *pixels;
		}
		for (i = 0; i < *height; i++) {
			row_pointers[i] = (*pixels) + (i) * (*width) * 3;
		}
		png_read_image(png_ptr, row_pointers);
		free(row_pointers);

		png_read_end(png_ptr, end_info);
	}
	return 0;
}

int svlImageCodecPNG::ReadDimensions(std::istream &stream, unsigned int &width, unsigned int &height)
{
    // check file for signature
    png_byte pngsig[PNG_SIG_SIZE];
    if (stream.read(reinterpret_cast<char*>(pngsig), PNG_SIG_SIZE).fail() ||
        png_sig_cmp(pngsig, 0, PNG_SIG_SIZE) != 0) {
        return SVL_FAIL;
    }

    // create read structure
    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
    if (png_ptr == 0) return SVL_FAIL;

    // create info structure
    png_infop info_ptr = png_create_info_struct(png_ptr);
    if (info_ptr == 0) {
        png_destroy_read_struct(&png_ptr, reinterpret_cast<png_infopp>(0), reinterpret_cast<png_infopp>(0));
        return SVL_FAIL;
    }

    width = 0;
    height = 0;

    // setup error handling
    if (setjmp(png_jmpbuf(png_ptr))) {
        png_destroy_read_struct(&png_ptr, &info_ptr, reinterpret_cast<png_infopp>(0));
        return SVL_OK;
    }
    PNG_source_stream source;
    source.stream = &stream;
    source.error = false;
    png_set_read_fn(png_ptr, &source, PNG_read_data_stream);

    png_set_sig_bytes(png_ptr, PNG_SIG_SIZE);
    png_read_info(png_ptr, info_ptr);

    // check file header
    width = static_cast<unsigned int>(png_get_image_width(png_ptr, info_ptr));
    height = static_cast<unsigned int>(png_get_image_height(png_ptr, info_ptr));

    // clean up
    png_destroy_read_struct(&png_ptr, &info_ptr,reinterpret_cast<png_infopp>(0));

    return SVL_OK;
}

/* read the png image to fill row_pointers */
int read_png(FILE *fp, png_bytep **row_pointers, png_uint_32 *width, png_uint_32 *height) {
    png_structp png_ptr;
    png_infop info_ptr;
    png_uint_32 color_type;
    unsigned char header[PNG_HEADER_SIZE];

    /* check if it's a png file */
    size_t bytes_read = fread(header, sizeof(unsigned char), PNG_HEADER_SIZE, fp);
    if (ferror(fp) || (bytes_read != PNG_HEADER_SIZE)) {
        return 0;
    }
    if (png_sig_cmp(header, 0, PNG_HEADER_SIZE) != 0) {
        return 0;
    }

    /* initialize libpng stuff */
    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, NULL, NULL);
    info_ptr = png_create_info_struct(png_ptr);
    png_init_io(png_ptr, fp);
    png_set_sig_bytes(png_ptr, PNG_HEADER_SIZE); // because of the check above
    png_read_info(png_ptr, info_ptr);

    *height = png_get_image_height(png_ptr, info_ptr);
    *width = png_get_image_width(png_ptr, info_ptr);
    *row_pointers = png_malloc(png_ptr, *height*sizeof(png_bytep));
    for (int i=0; i<*height; i++) {
        (*row_pointers)[i] = png_malloc(png_ptr, *width*PIXEL_SIZE);
    }
    png_set_rows(png_ptr, info_ptr, *row_pointers);

    color_type = png_get_color_type(png_ptr, info_ptr);
    /* we don't need alpha channel */
    if (color_type & PNG_COLOR_MASK_ALPHA) {
        png_set_strip_alpha(png_ptr);
    }
    png_read_update_info(png_ptr, info_ptr);

    /* and ... finally read the image */
    png_read_image(png_ptr, *row_pointers);
    png_read_end(png_ptr, NULL);
    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);

    return 1;
}

int
png_get_bbox (FILE *png_file, uint32_t *width, uint32_t *height,
	       double *xdensity, double *ydensity)
{
  png_structp png_ptr;
  png_infop   png_info_ptr;

  rewind (png_file);
  png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, warn);
  if (png_ptr == NULL ||
      (png_info_ptr = png_create_info_struct (png_ptr)) == NULL) {
    WARN("%s: Creating Libpng read/info struct failed.", PNG_DEBUG_STR);
    if (png_ptr)
      png_destroy_read_struct(&png_ptr, NULL, NULL);
    return -1;
  }

  /* Inititializing file IO. */
  png_init_io (png_ptr, png_file);

  /* Read PNG info-header and get some info. */
  png_read_info(png_ptr, png_info_ptr);
  *width      = png_get_image_width (png_ptr, png_info_ptr);
  *height     = png_get_image_height(png_ptr, png_info_ptr);

  if (compat_mode)
    *xdensity = *ydensity = 72.0 / 100.0;
  else
  {
    png_uint_32 xppm = png_get_x_pixels_per_meter(png_ptr, png_info_ptr);
    png_uint_32 yppm = png_get_y_pixels_per_meter(png_ptr, png_info_ptr);

    *xdensity = xppm ? 72.0 / 0.0254 / xppm : 1.0;
    *ydensity = yppm ? 72.0 / 0.0254 / yppm : 1.0;
  }

  /* Cleanup */
  if (png_info_ptr)
    png_destroy_info_struct(png_ptr, &png_info_ptr);
  if (png_ptr)
    png_destroy_read_struct(&png_ptr, NULL, NULL);

  return 0;
}

int svlImageCodecPNG::ReadDimensions(const unsigned char *buffer, const size_t buffersize, unsigned int &width, unsigned int &height)
{
    if (!buffer || buffersize < static_cast<unsigned int>(PNG_SIG_SIZE)) return SVL_FAIL;

    // check file for signature
    if (png_sig_cmp(const_cast<unsigned char*>(buffer), 0, PNG_SIG_SIZE) != 0) return SVL_FAIL;

    // create read structure
    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
    if (png_ptr == 0) return SVL_FAIL;

    // create info structure
    png_infop info_ptr = png_create_info_struct(png_ptr);
    if (info_ptr == 0) {
        png_destroy_read_struct(&png_ptr, reinterpret_cast<png_infopp>(0), reinterpret_cast<png_infopp>(0));
        return SVL_FAIL;
    }

    width = 0;
    height = 0;

    // setup error handling
    if (setjmp(png_jmpbuf(png_ptr))) {
        png_destroy_read_struct(&png_ptr, &info_ptr, reinterpret_cast<png_infopp>(0));
        return SVL_OK;
    }
    _PNG_source_memory source;
    source.buffer = const_cast<unsigned char*>(buffer + PNG_SIG_SIZE);
    source.buffersize = static_cast<unsigned int>(buffersize - PNG_SIG_SIZE);
    source.error = false;
    png_set_read_fn(png_ptr, &source, PNG_read_data_memory);

    png_set_sig_bytes(png_ptr, PNG_SIG_SIZE);
    png_read_info(png_ptr, info_ptr);

    // check file header
    width = static_cast<unsigned int>(png_get_image_width(png_ptr, info_ptr));
    height = static_cast<unsigned int>(png_get_image_height(png_ptr, info_ptr));

    // clean up
    png_destroy_read_struct(&png_ptr, &info_ptr,reinterpret_cast<png_infopp>(0));

    return SVL_OK;
}

static int getSizePng(const char *file, unsigned int *width, unsigned int *height)
{
	FILE *fp = fopen(file, "rb");
	if(!fp){
		printf("Couldn't open file: %s\n", file);
		return false;
	}

	unsigned char header[8];
	fread(header, 1, sizeof(header), fp);
	if(png_sig_cmp(header, 0, sizeof(header))){
		printf("File supplied is not a valid PNG: %s\n", file);
		return false;
	}

	png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
	if(!png){
		return false;
	}

	png_infop info = png_create_info_struct(png);
	if(!info){
		png_destroy_read_struct(&png, NULL, NULL);
		fclose(fp);
		return false;
	}

	if(setjmp(png_jmpbuf(png))){
		png_destroy_read_struct(&png, &info, NULL);
		fclose(fp);
		return false;
	}

	png_init_io(png, fp);
	png_set_sig_bytes(png, sizeof(header));

	png_read_info(png, info);

	*width = png_get_image_width(png, info);
	*height = png_get_image_height(png, info);

	return true;
}

unsigned char* TextureReader::readImageData()
{
    const int transforms = PNG_TRANSFORM_PACKING | PNG_TRANSFORM_STRIP_16;
    png_read_png(_png, _pngInfo, transforms, NULL);

    const unsigned int height = png_get_image_height(_png, _pngInfo);
    const unsigned int rowSize = png_get_rowbytes(_png, _pngInfo);
    unsigned char* data = new unsigned char[height * rowSize];
    unsigned char* row = data;
    unsigned char** rows = png_get_rows(_png, _pngInfo);

    for(unsigned int i = height - 1u; i != UINT32_MAX; --i)
    {
        std::copy(rows[i], rows[i] + rowSize, row);
        row += rowSize;
    }

    return data;
}

static HPDF_STATUS
ReadPngData_Interlaced  (HPDF_Dict    image,
                         png_structp  png_ptr,
                         png_infop    info_ptr)
{
    png_uint_32 len = png_get_rowbytes(png_ptr, info_ptr);
    png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
    png_bytep* row_pointers = HPDF_GetMem (image->mmgr,
                height * sizeof (png_bytep));

    if (row_pointers) {
        HPDF_UINT i;

        HPDF_MemSet (row_pointers, 0, height * sizeof (png_bytep));
        for (i = 0; i < (HPDF_UINT)height; i++) {
            row_pointers[i] = HPDF_GetMem (image->mmgr, len);

            if (image->error->error_no != HPDF_OK)
                break;
        }

        if (image->error->error_no == HPDF_OK) {
            png_read_image(png_ptr, row_pointers);
            if (image->error->error_no == HPDF_OK) {       /* add this line */
                for (i = 0; i < (HPDF_UINT)height; i++) {
                    if (HPDF_Stream_Write (image->stream, row_pointers[i], len) !=
                            HPDF_OK)
                        break;
                }
            }
        }

        /* clean up */
        for (i = 0; i < (HPDF_UINT)height; i++) {
            HPDF_FreeMem (image->mmgr, row_pointers[i]);
        }

        HPDF_FreeMem (image->mmgr, row_pointers);
    }

    return image->error->error_no;
}

struct image *png_open(FILE *f){
	struct png_t *p;

	rewind(f);
	if(!ispng(f))
		return NULL;

	p = malloc(sizeof(struct png_t));
	if((p->png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)) == NULL){
		free(p);
		return NULL;
	}
	if((p->info_ptr = png_create_info_struct(p->png_ptr)) == NULL){
		png_destroy_read_struct(&p->png_ptr, (png_infopp)NULL, (png_infopp)NULL);
		free(p);
		return NULL;
	}
	if((p->end_info = png_create_info_struct(p->png_ptr)) == NULL){
		png_destroy_read_struct(&p->png_ptr, &p->info_ptr, (png_infopp)NULL);
		free(p);
		return NULL;
	}
	if(setjmp(png_jmpbuf(p->png_ptr))){
		png_destroy_read_struct(&p->png_ptr, &p->info_ptr, &p->end_info);
		free(p);
		return NULL;
	}

	p->f = f;
	rewind(f);
	png_init_io(p->png_ptr, f);

	png_read_info(p->png_ptr, p->info_ptr);

	p->img.bufwidth = png_get_image_width(p->png_ptr, p->info_ptr);
	p->img.bufheight = png_get_image_height(p->png_ptr, p->info_ptr);

	p->img.fmt = &libpng;

	return (struct image *)p;
}