本文整理汇总了C++中png_get_rows函数的典型用法代码示例。如果您正苦于以下问题:C++ png_get_rows函数的具体用法?C++ png_get_rows怎么用?C++ png_get_rows使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了png_get_rows函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: Assert
void ImageFormat_PNG::CopyPixels(unsigned int* destination)
{
if (!info_ptr_ || !png_ptr_)
{
return;
}
png_infop info_ptr=static_cast<png_infop>(info_ptr_);
png_structp png_ptr=static_cast<png_structp>(png_ptr_);
Assert(info_ptr->color_type==PNG_COLOR_TYPE_RGB_ALPHA || info_ptr->color_type==PNG_COLOR_TYPE_RGB,"Unknown PNG format");
if (info_ptr->color_type!=PNG_COLOR_TYPE_RGB_ALPHA && info_ptr->color_type!=PNG_COLOR_TYPE_RGB)
{
return;
}
if (info_ptr->color_type==PNG_COLOR_TYPE_RGB_ALPHA)
{
unsigned char* data=reinterpret_cast<unsigned char*>(destination);
png_byte** row_pointers=png_get_rows(png_ptr, info_ptr);
int rowSize=info_ptr->width*4;
for (unsigned int y=0; y<info_ptr->height; y++)
{
for (unsigned int x=0; x<info_ptr->width; x++)
{
data[x*4+y*rowSize+0]=row_pointers[y][x*4+0];
data[x*4+y*rowSize+1]=row_pointers[y][x*4+1];
data[x*4+y*rowSize+2]=row_pointers[y][x*4+2];
data[x*4+y*rowSize+3]=row_pointers[y][x*4+3];
}
}
}
else
{
unsigned char* data=reinterpret_cast<unsigned char*>(destination);
png_byte** row_pointers=png_get_rows(png_ptr, info_ptr);
int rowSize=info_ptr->width*4;
for (unsigned int y=0; y<info_ptr->height; y++)
{
for (unsigned int x=0; x<info_ptr->width; x++)
{
data[x*4+y*rowSize+0]=row_pointers[y][x*3+0];
data[x*4+y*rowSize+1]=row_pointers[y][x*3+1];
data[x*4+y*rowSize+2]=row_pointers[y][x*3+2];
data[x*4+y*rowSize+3]=0xff;
}
}
}
}
示例2: fopen
void TextWindow::ScreenBackgroundImage(int link, uint32_t v) {
if(SS.bgImage.fromFile) MemFree(SS.bgImage.fromFile);
SS.bgImage.fromFile = NULL;
if(link == 'l') {
FILE *f = NULL;
png_struct *png_ptr = NULL;
png_info *info_ptr = NULL;
char importFile[MAX_PATH] = "";
if(!GetOpenFile(importFile, PNG_EXT, PNG_PATTERN)) goto err;
f = fopen(importFile, "rb");
if(!f) goto err;
uint8_t header[8];
if (fread(header, 1, 8, f) != 8)
goto err;
if(png_sig_cmp(header, 0, 8)) goto err;
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
NULL, NULL, NULL);
if(!png_ptr) goto err;
info_ptr = png_create_info_struct(png_ptr);
if(!info_ptr) goto err;
if(setjmp(png_jmpbuf(png_ptr))) goto err;
png_init_io(png_ptr, f);
png_set_sig_bytes(png_ptr, 8);
png_read_png(png_ptr, info_ptr,
PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_STRIP_ALPHA, NULL);
int w; w = (int)png_get_image_width(png_ptr, info_ptr);
int h; h = (int)png_get_image_height(png_ptr, info_ptr);
uint8_t **rows; rows = png_get_rows(png_ptr, info_ptr);
// Round to next-highest powers of two, since the textures require
// that. And round up to 4, to guarantee 32-bit alignment.
int rw; rw = max(4, RoundUpToPowerOfTwo(w));
int rh; rh = max(4, RoundUpToPowerOfTwo(h));
SS.bgImage.fromFile = (uint8_t *)MemAlloc(rw*rh*3);
{for(int i = 0; i < h; i++) {
memcpy(SS.bgImage.fromFile + ((h - 1) - i)*(rw*3), rows[i], w*3);
}}
SS.bgImage.w = w;
SS.bgImage.h = h;
SS.bgImage.rw = rw;
SS.bgImage.rh = rh;
SS.bgImage.scale = SS.GW.scale;
SS.bgImage.origin = SS.GW.offset.ScaledBy(-1);
err:
if(png_ptr) png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
if(f) fclose(f);
}
SS.later.showTW = true;
}
示例3: _opng_validate_internal
__error__ "PNG_FLAG_FILLER_AFTER" has an unexpected value
#endif
#endif
/*
* Check if it's safe to access libpng's internal structures directly.
* Some fields might have their offsets shifted due to changes in
* libpng's configuration.
*/
static void
_opng_validate_internal(png_structp png_ptr, png_infop info_ptr)
{
#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
png_color_16p background;
#endif
#if defined(PNG_hIST_SUPPORTED)
png_uint_16p hist;
#endif
#if defined(PNG_sBIT_SUPPORTED)
png_color_8p sig_bit;
#endif
png_bytep trans_alpha;
int num_trans;
png_color_16p trans_color;
/* Check info_ptr. */
if (png_get_rows(png_ptr, info_ptr) != info_ptr->row_pointers)
goto error;
#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
if (png_get_bKGD(png_ptr, info_ptr, &background))
if (background != &info_ptr->background)
goto error;
#endif
#if defined(PNG_hIST_SUPPORTED)
if (png_get_hIST(png_ptr, info_ptr, &hist))
if (hist != info_ptr->hist)
goto error;
#endif
#if defined(PNG_sBIT_SUPPORTED)
if (png_get_sBIT(png_ptr, info_ptr, &sig_bit))
if (sig_bit != &info_ptr->sig_bit)
goto error;
#endif
if (png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans, &trans_color))
if ((trans_alpha != NULL && (trans_alpha != info_ptr->trans_alpha ||
num_trans != info_ptr->num_trans)) ||
(trans_color != NULL && trans_color != &info_ptr->trans_color))
goto error;
/* Also check png_ptr. It's not much, we're doing what we can... */
if (png_get_compression_buffer_size(png_ptr) != png_ptr->zbuf_size)
goto error;
/* Everything looks okay. */
return;
error:
png_error(png_ptr,
"[internal error] Inconsistent internal structures (incorrect libpng?)");
}
示例4: readpng
/* Ripped from the libpng manual */
png_bytepp readpng(const char *filename, int* width, int* height) {
FILE *fp = fopen(filename, "rb");
char header[8];
png_structp png_ptr;
png_infop info_ptr, end_info;
if (!fp) {
fprintf(stderr, "%s ", filename);
perror("fopen");
return NULL;
}
fread(header, 1, 8, fp);
if(png_sig_cmp((png_byte*)header, 0, 8))
{
fprintf(stderr, "%s: Not a PNG image!\n", filename);
return NULL;
}
png_ptr = png_create_read_struct(
PNG_LIBPNG_VER_STRING,
NULL, NULL, NULL);
if(!png_ptr)
return NULL;
info_ptr = png_create_info_struct(png_ptr);
if(!info_ptr) {
png_destroy_read_struct(&png_ptr, NULL, NULL);
return NULL;
}
end_info = png_create_info_struct(png_ptr);
if(!end_info) {
png_destroy_read_struct(&png_ptr, NULL, NULL);
return NULL;
}
/* Set up jump target for libpng errors */
if (setjmp(png_jmpbuf(png_ptr)))
{
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
fprintf(stderr, "libpng error!\n");
fclose(fp);
return NULL;
}
png_init_io(png_ptr, fp);
png_set_sig_bytes(png_ptr, 8);
png_read_png(png_ptr, info_ptr, 0, NULL);
/* Make sure the image is in the format we want */
*width = png_get_image_width(png_ptr, info_ptr);
*height = png_get_image_height(png_ptr, info_ptr);
if(png_get_bit_depth(png_ptr, info_ptr) != 8 ||
png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_RGB)
fprintf(stderr, "Need an 8 bit/color RGB image!!\n");
/* Warning! We leak these data structures!!! */
return png_get_rows(png_ptr, info_ptr);
}
示例5: pngfile_to_bytes
Image * pngfile_to_bytes(char* file_name) {
printf("reading file %s\n",file_name);
png_structp png_ptr;
png_infop info_ptr, end_ptr;
png_uint_32 width, height;
int bit_depth;
int color_type;
int interlace_type;
int i;
FILE *fp = fopen(file_name, "rb");
if (!fp) {
fprintf(stderr, "can't open %s\n", file_name);
return 0;
}
/* initialize stuff */
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) abort_("[read_png_file] png_create_read_struct failed");
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) abort_("[read_png_file] png_create_info_struct failed");
end_ptr = png_create_info_struct(png_ptr);
if (!end_ptr) abort_("[read_png_file] png_create_info_struct failed");
png_init_io(png_ptr, fp);
png_set_sig_bytes(png_ptr, 0);
png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL);
Image* img = (Image*)malloc(sizeof(Image));
img->w = width;
img->h = height;
img->hasAlpha = (color_type == PNG_COLOR_TYPE_RGBA);
int bytes_per_pixel = 3;
if(img->hasAlpha) {
bytes_per_pixel = 4;
}
unsigned int row_bytes = png_get_rowbytes(png_ptr, info_ptr);
img->data = (char*) malloc(row_bytes * height);
png_bytepp row_pointers = png_get_rows(png_ptr, info_ptr);
for (i = 0; i < height; i++) {
memcpy(img->data + row_bytes*i, row_pointers[i], row_bytes);
}
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
fclose(fp);
return img;
}
示例6: png_read_png
//
////////////////////////////////////////////////////
//
// Image* readPNGIntoImage()
//
////////////////////////////////////////////////////
//
Image* PNGCodec::readPNGIntoImage(png_structp &png, png_infop &pngInfo)
{
uint8 **buf;
int y;
png_uint_32 iWidth, iHeight, iRowLength;
png_byte iColourType, iBitsPerChannel, iNumChannels;
png_bytepp pngRows;
Image* imgPNG;
png_read_png(png, pngInfo, PNG_TRANSFORM_BGR | PNG_TRANSFORM_STRIP_ALPHA, png_voidp_NULL);
// pixels are in info_ptr->row_pointers
// where row_pointers is:
// png_bytep row_pointers[height];
// and is probably not contiguous
iColourType = png_get_color_type(png, pngInfo);
// if (iColourType != PNG_COLOR_TYPE_RGB_ALPHA)
if (iColourType != PNG_COLOR_TYPE_RGB)
throw new std::runtime_error("Colour type not supported - RGB only, PNGCodec::readPNGIntoImage()");
iBitsPerChannel = png_get_bit_depth(png, pngInfo);
iNumChannels = png_get_channels(png, pngInfo);
iHeight = png_get_image_height(png, pngInfo);
iWidth = png_get_image_width(png, pngInfo);
iRowLength = iWidth * (iBitsPerChannel * iNumChannels) / 8; // Should be same as iWidth
// 07-Jul-2009: Directly load the PNG into a pre-created image's
// buffer. Otherwise ImageRGB24 will make a copy of the buf, which
// is a waste of space (and problematic for very large PNGs!)
imgPNG = new Image;
imgPNG->width = iWidth;
imgPNG->height = iHeight;
imgPNG->data = new unsigned char*[iHeight];
for (y = 0; y < iHeight; y++) {
imgPNG->data[y] = new unsigned char[iRowLength];
}
buf = imgPNG->data;
pngRows = png_get_rows(png, pngInfo);
for (y = 0; y < iHeight; y++) {
// for (x = 0; x < iWidth; x++) {
// This assumes BGR order, in readiness for the ImageRGB24 constructor
// It also assumes 24-bit, no alpha
// Yes, this is not good...
memcpy(buf[y], pngRows[y], iRowLength);
//memcpy((buf + (y * iRowLength)), pngRows[y], iRowLength);
}
// Clean up
png_destroy_read_struct(&png, &pngInfo, png_infopp_NULL);
return imgPNG;
}
示例7: fopen
void Image::loadWithPng()
{
FILE* file = fopen(this->file.c_str(), "rb");
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
png_infop info_ptr = png_create_info_struct(png_ptr);
setjmp(png_jmpbuf(png_ptr));
png_init_io(png_ptr, file);
png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_EXPAND, 0);
int m_width = png_get_image_width(png_ptr, info_ptr);
int m_height = png_get_image_height(png_ptr, info_ptr);
int color_type = png_get_color_type(png_ptr, info_ptr);
int size = m_height * m_width * 4;
unsigned char* rgba = (unsigned char*)malloc(size);
int pos = 0;
png_bytep* row_pointers = png_get_rows(png_ptr, info_ptr);
for (int i = 0; i < m_height; i++)
{
for (int j = 0; j < (4 * m_width); j += 4)
{
rgba[pos++] = row_pointers[i][j]; //R
rgba[pos++] = row_pointers[i][j + 1]; //B
rgba[pos++] = row_pointers[i][j + 2]; //G
rgba[pos++] = row_pointers[i][j + 3]; //A
}
}
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
fclose(file);
auto _data = rgba;
this->width = m_width;
this->height = m_height;
this->size = size;
_rect.x = m_width;
_rect.y = m_height;
this->_data = rgba;
}
示例8: read_png
static png_bytep *
read_png(png_structp png_ptr, png_infop info_ptr, at_input_opts_type * opts)
{
int row;
png_color_16p original_bg;
png_color_16 my_bg;
png_read_info(png_ptr, info_ptr);
png_set_strip_16(png_ptr);
png_set_packing(png_ptr);
if ((png_get_bit_depth(png_ptr, info_ptr) < 8) ||
(png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) ||
(png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
png_set_expand(png_ptr);
if (png_get_bKGD(png_ptr, info_ptr, &original_bg)) {
/* Fill transparent region with ... */
my_bg.index = 0;
if (opts && opts->background_color) {
my_bg.red = 256 * opts->background_color->r;
my_bg.green = 256 * opts->background_color->g;
my_bg.blue = 256 * opts->background_color->b;
my_bg.gray = 256* ((opts->background_color->r
+ opts->background_color->g
+ opts->background_color->b) / 3);
} else
/* else, use white */
my_bg.red = my_bg.green = my_bg.blue = my_bg.gray = 0xFFFF;
png_set_background(png_ptr, &my_bg,
PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
} else
png_set_strip_alpha(png_ptr);
png_set_interlace_handling(png_ptr);
png_read_update_info(png_ptr, info_ptr);
// PGC to replace commented lines
png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
png_read_end(png_ptr, info_ptr);
return png_get_rows(png_ptr, info_ptr);
// info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
// info_ptr->height * sizeof(png_bytep));
//#ifdef PNG_FREE_ME_SUPPORTED
// info_ptr->free_me |= PNG_FREE_ROWS;
//#endif
// for (row = 0; row < (int)info_ptr->height; row++)
// info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
// png_get_rowbytes(png_ptr, info_ptr));
//
// png_read_image(png_ptr, info_ptr->row_pointers);
// info_ptr->valid |= PNG_INFO_IDAT;
// png_read_end(png_ptr, info_ptr);
// return png_get_rows(png_ptr, info_ptr);
}
示例9: read_png
static void
read_png(struct display *dp, struct buffer *bp, const char *operation,
int transforms)
{
png_structp pp;
png_infop ip;
/* This cleans out any previous read and sets operation and transforms to
* empty.
*/
display_clean_read(dp);
if (operation != NULL) /* else this is a verify and do not overwrite info */
{
dp->operation = operation;
dp->transforms = transforms;
}
dp->read_pp = pp = png_create_read_struct(PNG_LIBPNG_VER_STRING, dp,
display_error, display_warning);
if (pp == NULL)
display_log(dp, LIBPNG_ERROR, "failed to create read struct");
/* The png_read_png API requires us to make the info struct, but it does the
* call to png_read_info.
*/
dp->read_ip = ip = png_create_info_struct(pp);
if (ip == NULL)
display_log(dp, LIBPNG_ERROR, "failed to create info struct");
# ifdef PNG_SET_USER_LIMITS_SUPPORTED
/* Remove the user limits, if any */
png_set_user_limits(pp, 0x7fffffff, 0x7fffffff);
# endif
/* Set the IO handling */
buffer_start_read(bp);
png_set_read_fn(pp, bp, read_function);
png_read_png(pp, ip, transforms, NULL/*params*/);
#if 0 /* crazy debugging */
{
png_bytep pr = png_get_rows(pp, ip)[0];
size_t rb = png_get_rowbytes(pp, ip);
size_t cb;
char c = ' ';
fprintf(stderr, "%.4x %2d (%3lu bytes):", transforms, png_get_bit_depth(pp,ip), (unsigned long)rb);
for (cb=0; cb<rb; ++cb)
fputc(c, stderr), fprintf(stderr, "%.2x", pr[cb]), c='.';
fputc('\n', stderr);
}
#endif
}
示例10: main
int main(int argc, char **argv)
{
FILE *fin, *fout;
if (argc < 3)
{
printf("Usage: vmuicon <icon.raw> <icon.c>\n");
exit(0);
}
fin = fopen(argv[1], "rb");
if (!fin)
abort_("File %s could not be opened for reading", argv[1]);
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr)
abort_("Failed to create PNG read struct\n");
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
abort_("Failed to create PNG info struct\n");
if (setjmp(png_jmpbuf(png_ptr)))
{
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
fclose(fin);
abort_("Error reading PNG\n");
}
png_init_io(png_ptr, fin);
png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_INVERT_MONO | PNG_TRANSFORM_PACKSWAP, NULL);
if ((png_get_image_width(png_ptr, info_ptr) != IMAGE_WIDTH) ||
(png_get_image_height(png_ptr, info_ptr) != IMAGE_HEIGHT))
abort_("Image is not %ix%i pixels\n", IMAGE_WIDTH, IMAGE_HEIGHT);
if ((png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_GRAY)
|| (png_get_bit_depth(png_ptr, info_ptr) != 1))
abort_("Image is not a grayscale image with bit depth 1\n");
rows = png_get_rows(png_ptr, info_ptr);
fout = fopen(argv[2], "w+");
if (!fout)
abort_("File %s could not be opened for writing", argv[2]);
write_data(fout);
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
fclose(fin);
fclose(fout);
return 0;
}
示例11: Pnger_Load
CNSL_Display Pnger_Load(const char* filename)
{
CNSL_Display null;
null.width = 0;
null.height = 0;
null.pixels = NULL;
FILE* pngfile = fopen(filename, "rb");
if (!pngfile) {
fprintf(stderr, "unable to open %s\n", filename);
return null;
}
png_structp png_ptr = png_create_read_struct(
PNG_LIBPNG_VER_STRING, NULL, NULL, NULL
);
if (!png_ptr) {
fprintf(stderr, "unable to create png read struct.\n");
return null;
}
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
{
png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
fprintf(stderr, "unable to create png info struct.\n");
return null;
}
png_init_io(png_ptr, pngfile);
unsigned int transforms =
PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_STRIP_ALPHA
| PNG_TRANSFORM_PACKING | PNG_TRANSFORM_GRAY_TO_RGB
| PNG_TRANSFORM_EXPAND;
png_read_png(png_ptr, info_ptr, transforms, NULL);
uint8_t** row_pointers = png_get_rows(png_ptr, info_ptr);
int width = png_get_image_width(png_ptr, info_ptr);
int height = png_get_image_height(png_ptr, info_ptr);
CNSL_Display pixels = CNSL_AllocDisplay(width, height);
int x, y;
for (y = 0; y < pixels.height; y++) {
for (x = 0; x < pixels.width; x++) {
uint8_t rc = row_pointers[y][3*x];
uint8_t gc = row_pointers[y][3*x+1];
uint8_t bc = row_pointers[y][3*x+2];
CNSL_SetPixel(pixels, x, y, CNSL_MakeColor(rc, gc, bc));
}
}
return pixels;
}
示例12: png_set_read_fn
void ogl::texture::load_png(const void *buf, size_t len, std::vector<GLubyte>& p)
{
// Initialize all PNG import data structures.
png_structp rp = 0;
png_infop ip = 0;
png_bytep *bp = 0;
if (!(rp = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0)))
throw std::runtime_error("Failure creating PNG read structure");
if (!(ip = png_create_info_struct(rp)))
throw std::runtime_error("Failure creating PNG info structure");
// Initialize the user-defined IO structure.
struct png_user_io user;
user.buf = (png_bytep) buf;
user.len = (png_size_t) len;
png_set_read_fn(rp, &user, png_user_read);
// Enable the default PNG error handler.
if (setjmp(png_jmpbuf(rp)) == 0)
{
// Read the PNG header.
png_read_png(rp, ip, PNG_TRANSFORM_EXPAND |
PNG_TRANSFORM_PACKING |
PNG_TRANSFORM_STRIP_16 |
PNG_TRANSFORM_SWAP_ENDIAN, 0);
// Extract image properties.
w = GLsizei(png_get_image_width (rp, ip));
h = GLsizei(png_get_image_height(rp, ip));
c = GLsizei(png_get_channels (rp, ip));
p.resize(w * h * c);
// Read the pixel data.
if ((bp = png_get_rows(rp, ip)))
for (GLsizei i = 0, j = h - 1; i < h; ++i, --j)
memcpy(&p[w * c * i], bp[j], (w * c));
}
// Release all resources.
png_destroy_read_struct(&rp, &ip, 0);
}
示例13: ReadHeightmapPNGImageData
/**
* The PNG Heightmap loader.
*/
static void ReadHeightmapPNGImageData(byte *map, png_structp png_ptr, png_infop info_ptr)
{
uint x, y;
byte gray_palette[256];
png_bytep *row_pointers = nullptr;
bool has_palette = png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE;
uint channels = png_get_channels(png_ptr, info_ptr);
/* Get palette and convert it to grayscale */
if (has_palette) {
int i;
int palette_size;
png_color *palette;
bool all_gray = true;
png_get_PLTE(png_ptr, info_ptr, &palette, &palette_size);
for (i = 0; i < palette_size && (palette_size != 16 || all_gray); i++) {
all_gray &= palette[i].red == palette[i].green && palette[i].red == palette[i].blue;
gray_palette[i] = RGBToGrayscale(palette[i].red, palette[i].green, palette[i].blue);
}
/**
* For a non-gray palette of size 16 we assume that
* the order of the palette determines the height;
* the first entry is the sea (level 0), the second one
* level 1, etc.
*/
if (palette_size == 16 && !all_gray) {
for (i = 0; i < palette_size; i++) {
gray_palette[i] = 256 * i / palette_size;
}
}
}
row_pointers = png_get_rows(png_ptr, info_ptr);
/* Read the raw image data and convert in 8-bit grayscale */
for (x = 0; x < png_get_image_width(png_ptr, info_ptr); x++) {
for (y = 0; y < png_get_image_height(png_ptr, info_ptr); y++) {
byte *pixel = &map[y * png_get_image_width(png_ptr, info_ptr) + x];
uint x_offset = x * channels;
if (has_palette) {
*pixel = gray_palette[row_pointers[y][x_offset]];
} else if (channels == 3) {
*pixel = RGBToGrayscale(row_pointers[y][x_offset + 0],
row_pointers[y][x_offset + 1], row_pointers[y][x_offset + 2]);
} else {
*pixel = row_pointers[y][x_offset];
}
}
}
}
示例14: png_get_rows
bool PNGImageLoader::loadImageData(PixelOrigin origin,
DataSource* data,
ImageContext* context)
{
PNGImageContext* png = static_cast<PNGImageContext*>(context);
byte red;
byte green;
byte blue;
byte alpha;
size_t width = png->getWidth();
size_t height = png->getHeight();
png_bytepp row_pointers = png_get_rows(png->d_png_ptr, png->d_info_ptr);
if (png->d_bit_depth == 8)
{
// Read RGBA
if (png->d_num_channels == 4)
{
for (size_t j = 0 ; j < height ; ++j)
{
for(size_t i = 0 ; i < width ; ++i)
{
size_t pixel_offset = 4 * i;
red = *(row_pointers[j] + pixel_offset);
green = *(row_pointers[j] + pixel_offset + 1);
blue = *(row_pointers[j] + pixel_offset + 2);
alpha = *(row_pointers[j] + pixel_offset + 3);
png->setNextPixel(red, green, blue, alpha);
}
}
}
else if (png->d_num_channels == 3)
{
alpha = 0xff;
for (size_t j = 0 ; j < height ; ++j)
{
for(size_t i = 0 ; i < width ; ++i)
{
size_t pixel_offset = 3 * i;
red = *(row_pointers[j] + pixel_offset);
green = *(row_pointers[j] + pixel_offset + 1);
blue = *(row_pointers[j] + pixel_offset + 2);
png->setNextPixel(red, green, blue, alpha);
}
}
}
}
if (origin == PO_BOTTOM_LEFT)
return png->flipVertically();
return true;
}
示例15: opng_analyze_sample_usage
/*
* Analyze the usage of samples.
* The output value usage_map[n] indicates whether the sample n
* is used. The usage_map[] array must have 256 entries.
* The function requires a valid bit depth between 1 and 8.
*/
static void opng_analyze_sample_usage(png_structp png_ptr, png_infop info_ptr, png_bytep usage_map)
{
png_bytep sample_ptr;
int init_shift, init_mask, shift, mask;
png_uint_32 i, j;
png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
png_uint_32 width = png_get_image_width(png_ptr, info_ptr);
int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
png_bytepp row_ptr = png_get_rows(png_ptr, info_ptr);
/* Initialize the output entries with 0. */
memset(usage_map, 0, 256);
/* Iterate through all sample values. */
if (bit_depth == 8)
{
for (i = 0; i < height; ++i, ++row_ptr)
{
for (j = 0, sample_ptr = *row_ptr; j < width; ++j, ++sample_ptr)
usage_map[*sample_ptr] = 1;
}
}
else
{
OPNG_ASSERT(bit_depth < 8);
init_shift = 8 - bit_depth;
init_mask = (1 << 8) - (1 << init_shift);
for (i = 0; i < height; ++i, ++row_ptr)
{
for (j = 0, sample_ptr = *row_ptr; j < width; ++sample_ptr)
{
mask = init_mask;
shift = init_shift;
do
{
usage_map[(*sample_ptr & mask) >> shift] = 1;
mask >>= bit_depth;
shift -= bit_depth;
++j;
} while (mask > 0 && j < width);
}
}
}
#ifdef PNG_bKGD_SUPPORTED
png_color_16p background;
/* bKGD also counts as a used sample. */
if (png_get_bKGD(png_ptr, info_ptr, &background))
usage_map[background->index] = 1;
#endif
}