本文整理汇总了C++中png_get_image_height函数的典型用法代码示例。如果您正苦于以下问题:C++ png_get_image_height函数的具体用法?C++ png_get_image_height怎么用?C++ png_get_image_height使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了png_get_image_height函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: image_png_read_header
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;
}
示例2: PngSize
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;
}
示例3: oil_libpng_init
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;
}
示例4: readPng
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];
}
示例5: verifySignature
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;
}
示例6: png_load_hdr
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);
}
示例7: loadPNGDecode
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;
}
示例8: png_sig_cmp
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;
}
示例9: read_png
/* 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;
}
示例10: png_get_bbox
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;
}
示例11: png_create_read_struct
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;
}
示例12: getSizePng
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;
}
示例13: png_read_png
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;
}
示例14: ReadPngData_Interlaced
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;
}
示例15: rewind
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;
}