本文整理汇总了C++中png_set_PLTE函数的典型用法代码示例。如果您正苦于以下问题:C++ png_set_PLTE函数的具体用法?C++ png_set_PLTE怎么用?C++ png_set_PLTE使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了png_set_PLTE函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: save_to_png
void save_to_png(char* filename) {
int i;
// use malloc rather than the stack since an array of several million bytes will overflow the stack
uint8_t *pixels = malloc(width * height * 3 * sizeof(uint8_t));
// switch the framebuffer in order to force the full texture to be saved
glBindFramebuffer(GL_FRAMEBUFFER, framebuffers[fb]);
glViewport(0, 0, width, height);
// copy pixels from screen
glActiveTexture(0);
glBindTexture(GL_TEXTURE_2D, textures[fb]);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width, height);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)pixels);
// use libpng to write the pixels to a png image
png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png) goto png_fail;
png_infop info = png_create_info_struct(png);
if (!info) {
png_destroy_write_struct(&png, &info);
goto png_fail;
}
if(filename == NULL) {
// filename => current time in milliseconds
char tmp[256];
snprintf(tmp, 256, "%llu.png", get_time_us() * 1000);
filename = tmp;
}
FILE *file = fopen(filename, "wb");
if (!file) {
png_destroy_write_struct(&png, &info);
goto png_fail;
}
png_init_io(png, file);
png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
png_colorp palette = png_malloc(png, PNG_MAX_PALETTE_LENGTH * sizeof(png_color));
if (!palette) {
fclose(file);
png_destroy_write_struct(&png, &info);
goto png_fail;
}
png_set_PLTE(png, info, palette, PNG_MAX_PALETTE_LENGTH);
png_write_info(png, info);
png_set_packing(png);
png_bytepp rows = (png_bytepp)png_malloc(png, height * sizeof(png_bytep));
for (i = 0; i < height; ++i) {
rows[i] = (png_bytep)(pixels + (height - i - 1) * width * 3);
}
png_write_image(png, rows);
png_write_end(png, info);
png_free(png, palette);
png_destroy_write_struct(&png, &info);
fclose(file);
free(pixels);
printf("PNG: finished at %llu\n", get_time_us());
render_prepare_screen();
return;
png_fail:
fail("Failed to create PNG\n");
}
示例2: write_png_palette
static int write_png_palette(
png_struct *png_ptr, png_info *info_ptr, SDL_Surface *scr)
{
int i, result = -1;
png_color *palette;
palette = malloc(sizeof(*palette) * scr->format->palette->ncolors);
if (palette)
{
// Convert SDL palette to libpng
for (i = 0; i < scr->format->palette->ncolors; i++) {
palette[i].red = scr->format->palette->colors[i].r;
palette[i].green = scr->format->palette->colors[i].g;
palette[i].blue = scr->format->palette->colors[i].b;
}
png_set_PLTE(png_ptr, info_ptr,
palette, scr->format->palette->ncolors);
free(palette);
result = 0;
}
return result;
}
示例3: rwpng_write_image8
pngquant_error rwpng_write_image8(FILE *outfile, png8_image *mainprog_ptr)
{
png_structp png_ptr;
png_infop info_ptr;
pngquant_error retval = rwpng_write_image_init((png_image*)mainprog_ptr, &png_ptr, &info_ptr, outfile);
if (retval) return retval;
/* set the image parameters appropriately */
int sample_depth;
if (mainprog_ptr->num_palette <= 2)
sample_depth = 1;
else if (mainprog_ptr->num_palette <= 4)
sample_depth = 2;
else if (mainprog_ptr->num_palette <= 16)
sample_depth = 4;
else
sample_depth = 8;
png_set_IHDR(png_ptr, info_ptr, mainprog_ptr->width, mainprog_ptr->height,
sample_depth, PNG_COLOR_TYPE_PALETTE,
0, PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_BASE);
png_set_PLTE(png_ptr, info_ptr, &mainprog_ptr->palette[0], mainprog_ptr->num_palette);
if (mainprog_ptr->num_trans > 0)
png_set_tRNS(png_ptr, info_ptr, mainprog_ptr->trans, mainprog_ptr->num_trans, NULL);
rwpng_write_end(&info_ptr, &png_ptr, (png_image*)mainprog_ptr);
return SUCCESS;
}
示例4: writeSetup2
void writeSetup2(png_structp png_ptr_write, png_infop info_ptr_write,
png_structp png_ptr_read, png_infop info_ptr_read)
{
/* IHDR */
png_uint_32 width;
png_uint_32 height;
int bit_depth;
int colour_type;
int interlace_method;
int compression_method;
int filter_method;
/* PLTE */
png_colorp palette = NULL;
int palette_size = 0;
/* gAMA */
double gamma;
/* tRNS */
png_bytep trans;
int num_trans;
png_color_16p trans_values;
/* bKGD */
png_color_16p background;
png_get_IHDR(png_ptr_read, info_ptr_read, &width, &height,
&bit_depth, &colour_type, &interlace_method,
&compression_method, &filter_method);
png_set_IHDR(png_ptr_write, info_ptr_write, width, height,
bit_depth, colour_type, interlace_method,
compression_method, filter_method);
if(png_get_valid(png_ptr_read, info_ptr_read, PNG_INFO_PLTE))
{
png_get_PLTE(png_ptr_read, info_ptr_read, &palette, &palette_size);
png_set_PLTE(png_ptr_write, info_ptr_write, palette, palette_size);
}
if(png_get_valid(png_ptr_read, info_ptr_read, PNG_INFO_gAMA))
{
png_get_gAMA(png_ptr_read, info_ptr_read, &gamma);
png_set_gAMA(png_ptr_write, info_ptr_write, gamma);
}
if(png_get_valid(png_ptr_read, info_ptr_read, PNG_INFO_tRNS))
{
png_get_tRNS(png_ptr_read, info_ptr_read, &trans, &num_trans, &trans_values);
png_set_tRNS(png_ptr_write, info_ptr_write, trans, num_trans, trans_values);
}
if(png_get_valid(png_ptr_read, info_ptr_read, PNG_INFO_bKGD))
{
png_get_bKGD(png_ptr_read, info_ptr_read, &background);
png_set_bKGD(png_ptr_write, info_ptr_write, background);
}
}
示例5: write_palette_chunk
/** Write out the PLTE (and possibly tRNS) chunk to the png. This will create the
* palette data to set in the PLTE chunk and set it, and if the colorkey is set
* for the surface an appropriate tRNS chunk is generated.
*
* \param png_ptr A pointer to the png write structure.
* \param info_ptr A pointer to the png info structure.
* \param surf The surface that is being written to the png.
* \return -1 on error, 0 if the palette chunk was written without problems.
*/
static int write_palette_chunk(png_structp png_ptr, png_infop info_ptr, SDL_Surface *surf)
{
png_colorp palette;
Uint8 *alphas;
int slot;
SDL_PixelFormat *fmt = surf -> format;
SDL_Color *sourcepal = fmt -> palette -> colors;
// Write the image header first...
png_set_IHDR(png_ptr, info_ptr, surf -> w, surf -> h, 8, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
// now sort out the palette
if(!(palette = (png_colorp)malloc(fmt -> palette -> ncolors * sizeof(png_color)))) {
SDL_SetError("Unable to create memory for palette storage");
return -1;
}
// Copy the palette over. Can't just use a straight
// memcpy as sdl palettes have pad bytes.
for(slot = 0; slot < fmt -> palette -> ncolors; ++slot) {
memcpy(&palette[slot], &sourcepal[slot], 3);
}
// Set it...
png_set_PLTE(png_ptr, info_ptr, palette, fmt -> palette -> ncolors);
// Done with the palette now
free(palette);
Uint32 colorkey;
int ck = SDL_GetColorKey(surf, &colorkey);
// If we have a colour key, we need to set up the alphas for each palette colour
if(ck == 0) {
// According the the PNG spec (section 4.2.1.1) we only need enough entries
// to store transparencies up to the transparent pixel.
if(!(alphas = (Uint8 *)malloc((colorkey + 1) * sizeof(Uint8)))) {
SDL_SetError("Unable to create memory for transparency storage");
return -1;
}
// Set all of the alpha values to full
memset(alphas, 255, (colorkey + 1) * sizeof(Uint8));
// And handle the transparent pixel
alphas[colorkey] = 0;
// Write the chunk, and then we're done with the transparencies
png_set_tRNS(png_ptr, info_ptr, alphas, colorkey + 1, NULL);
free(alphas);
}
return 0;
}
示例6: save_png
/*
* Saves a byte array stored in pixels of width w and height h as a png into
* filename
*/
GLuint save_png (const char * filename, GLubyte * pixels, GLuint w, GLuint h)
{
png_structp png;
png_infop info;
png_colorp palette;
png_bytepp rows;
FILE * fp;
GLuint i;
png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png) return 1;
info = png_create_info_struct(png);
if(!info) {
png_destroy_write_struct(&png, NULL);
return 1;
}
fp = fopen(filename, "wb");
if (!fp) {
png_destroy_write_struct(&png, &info);
return 1;
}
png_init_io(png, fp);
png_set_IHDR(png, info, w, h, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
palette = (png_colorp) png_malloc(png, PNG_MAX_PALETTE_LENGTH
* sizeof(png_color));
if (!palette) {
fclose(fp);
png_destroy_write_struct(&png, &info);
return 1;
}
png_set_PLTE(png, info, palette, PNG_MAX_PALETTE_LENGTH);
png_write_info(png, info);
png_set_packing(png);
rows = (png_bytepp) png_malloc(png, h * sizeof(png_bytep));
for (i = 0; i < h; ++i)
rows[i] = (png_bytep) (pixels + (h - i - 1) * w * 3);
png_write_image(png, rows);
png_write_end(png, info);
png_free(png, palette);
png_destroy_write_struct(&png, &info);
fclose(fp);
free(rows);
return 0;
}
示例7: gdImagePng
void gdImagePng(gdImagePtr im, FILE *out)
{
int i;
png_colorp palette;
png_structp png_write_ptr =
png_create_write_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_write_ptr);
if (setjmp(gdPngJmpbufStruct.jmpbuf)) {
png_destroy_write_struct(&png_write_ptr, &info_ptr);
return;
}
palette = (png_colorp)png_malloc (png_write_ptr,
im->colorsTotal*sizeof(png_color));
if (palette == NULL) {
png_destroy_write_struct(&png_write_ptr, &info_ptr);
return;
}
png_init_io(png_write_ptr, out);
png_set_write_status_fn(png_write_ptr, NULL);
png_set_IHDR(png_write_ptr,info_ptr,
im->sx,im->sy,im->colorsTotal > 16 ? 8:4,
PNG_COLOR_TYPE_PALETTE,
im->interlace ? PNG_INTERLACE_ADAM7: PNG_INTERLACE_NONE ,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
for(i=0; i<im->colorsTotal; i++) {
palette[i].red = im->red[i];
palette[i].green = im->green[i];
palette[i].blue = im->blue[i];
}
png_set_PLTE(png_write_ptr, info_ptr, palette, im->colorsTotal);
/* choose between speed (1) and space (9) optimization */
/* we want to be fast ... */
png_set_compression_level(png_write_ptr,1);
png_set_filter(png_write_ptr,PNG_FILTER_TYPE_BASE,PNG_NO_FILTERS);
/* store file info */
png_write_info(png_write_ptr, info_ptr);
png_set_packing(png_write_ptr);
png_write_image(png_write_ptr, im->pixels);
png_write_end(png_write_ptr, info_ptr);
png_free(png_write_ptr, palette);
png_destroy_write_struct(&png_write_ptr, &info_ptr);
}
示例8: opng_realloc_PLTE
/*
* Change the size of the palette buffer.
* Changing info_ptr->num_palette directly, avoiding reallocation, should
* have been sufficient, but can't be done using the current libpng API.
*/
static void opng_realloc_PLTE(png_structp png_ptr, png_infop info_ptr, int num_palette)
{
png_colorp palette;
int src_num_palette = 0;
png_get_PLTE(png_ptr, info_ptr, &palette, &src_num_palette);
if (num_palette == src_num_palette)
{return;}
png_color buffer[PNG_MAX_PALETTE_LENGTH];
memcpy(buffer, palette, num_palette * sizeof(png_color));
if (num_palette > src_num_palette)
memset(buffer + src_num_palette, 0,
(num_palette - src_num_palette) * sizeof(png_color));
png_set_PLTE(png_ptr, info_ptr, buffer, num_palette);
}
示例9: bitmap_write
extern void bitmap_write(struct bitmap *bitmap)
{
if (!output_path && is_tty_stdout())
message_fatal("Data cannot be written to a terminal");
FILE *fp = output_path ? fopen(output_path, "wb") : stdout;
if (fp == NULL)
message_fatal("Unable to open file for writing");
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
NULL, NULL, NULL);
if (png_ptr == NULL)
message_fatal("Unable to create png struct");
png_infop info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL)
message_fatal("Unable to create png info struct");
if (setjmp(png_jmpbuf(png_ptr))) {
fclose(fp);
png_destroy_write_struct(&png_ptr, &info_ptr);
message_fatal("Error writing png file");
}
png_init_io(png_ptr, fp);
png_set_IHDR(png_ptr, info_ptr, bitmap->width, bitmap->height, 8,
PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_color *palette = palette_create();
png_set_PLTE(png_ptr, info_ptr, palette, 256);
png_bytep row_pointers[bitmap->height];
for (unsigned y = 0; y < bitmap->height; y++)
row_pointers[y] = bitmap->data + bitmap->width * y;
png_write_info(png_ptr, info_ptr);
png_write_image(png_ptr, row_pointers);
png_write_end(png_ptr, info_ptr);
palette_release(palette);
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(fp);
}
示例10: pngx_set_GIF_palette
static void
pngx_set_GIF_palette(png_structp png_ptr, png_infop info_ptr,
unsigned char *color_table, unsigned int num_colors)
{
png_color palette[256];
unsigned int i;
PNGX_ASSERT(color_table != NULL && num_colors <= 256);
for (i = 0; i < num_colors; ++i)
{
palette[i].red = color_table[3 * i];
palette[i].green = color_table[3 * i + 1];
palette[i].blue = color_table[3 * i + 2];
}
png_set_PLTE(png_ptr, info_ptr, palette, (int)num_colors);
}
示例11: bta_transparent_toPNG
/*
* bta_transparent_toPNG
*/
void bta_transparent_toPNG(bta_cell_t *in, btstring_t *fname)
{
FILE *outfp;
png_structp png_ptr;
png_infop info_ptr;
uint32_t i;
int trans = 0;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
printf("Failed allocating png_ptr\n");
return;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
printf("Failed allocating info_ptr\n");
return;
}
outfp = fopen(fname->buf, "wb");
if (outfp == NULL) {
printf("Error opening %s\n", fname->buf);
return;
}
png_init_io(png_ptr, outfp);
png_set_IHDR(png_ptr, info_ptr, in->width, in->height, 8, \
PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE, \
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_set_PLTE(png_ptr, info_ptr, egapalette, 16);
png_set_tRNS(png_ptr, info_ptr, (png_bytep)&trans, 1, NULL);
png_write_info(png_ptr, info_ptr);
for (i = 0; i < in->height; i++)
png_write_row(png_ptr, &in->gfx->buf[i * in->width]);
png_write_end(png_ptr, info_ptr);
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(outfp);
bts_free(fname);
}
示例12: SetPngPalette
void SetPngPalette(png_structp png_ptr, png_infop info_ptr, struct Palette *palette)
{
png_colorp colors = malloc(palette->numColors * sizeof(png_color));
if (colors == NULL)
FATAL_ERROR("Failed to allocate PNG palette.\n");
for (int i = 0; i < palette->numColors; i++) {
colors[i].red = palette->colors[i].red;
colors[i].green = palette->colors[i].green;
colors[i].blue = palette->colors[i].blue;
}
png_set_PLTE(png_ptr, info_ptr, colors, palette->numColors);
free(colors);
}
示例13: png_create_write_struct
void Texture::SaveTexture( const OutPutTextureData& saveto )
{
unsigned long i;
png_structp png_ptr;
png_infop info_ptr;
png_colorp palette;
png_byte *image;
png_bytep *row_pointers;
IFile* writefile = IOSystem::Instance().FileFactory(saveto.m_Path);
writefile->OpenFile( IFile::AT_READ );
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
info_ptr = png_create_info_struct(png_ptr);
png_set_write_fn( png_ptr, writefile, png_rw, png_flush );
//png_init_io(png_ptr, writefile.BaseFile() );
int colortype, bitesize;
switch( saveto.m_Pixel )
{
case Device::PF_R8G8B8: colortype = PNG_COLOR_TYPE_RGB; bitesize = 3; break;
case Device::PF_R8G8B8A8: colortype = PNG_COLOR_TYPE_RGBA; bitesize = 4; break;
}
png_set_IHDR(png_ptr, info_ptr, saveto.m_Size.m_x, saveto.m_Size.m_y, 8, colortype,
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH * sizeof (png_color));
png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH);
png_write_info(png_ptr, info_ptr);
png_set_packing(png_ptr);
row_pointers = (png_bytep *)malloc(saveto.m_Size.m_y * sizeof(png_bytep));
for (i = 0; i < saveto.m_Size.m_y; i++)
{
row_pointers[i] = (png_bytep)&saveto.m_Data[i * saveto.m_Size.m_y * bitesize];
}
png_write_image(png_ptr, row_pointers);
png_write_end(png_ptr, info_ptr);
png_free(png_ptr, palette);
palette = NULL;
png_destroy_write_struct(&png_ptr, &info_ptr);
free(row_pointers);
row_pointers = NULL;
writefile->CloseFile( );
IOSystem::Instance().FileDestroy( writefile );
}
示例14: write
void write() const
{
assert(m_png);
assert(m_info);
sync_ihdr();
if (m_color_type == color_type_palette)
{
if (! m_palette.empty())
{
png_set_PLTE(m_png, m_info,
const_cast< color* >(& m_palette[0]),
(int) m_palette.size());
}
if (! m_tRNS.empty())
{
#ifdef PNG_tRNS_SUPPORTED
png_set_tRNS(m_png, m_info,
const_cast< byte* >(& m_tRNS[0]),
m_tRNS.size(),
NULL);
#else
throw error("attempted to write tRNS chunk; recompile with PNG_tRNS_SUPPORTED");
#endif
}
}
if (m_gamma > 0)
{
#ifdef PNG_gAMA_SUPPORTED
#ifdef PNG_FLOATING_POINT_SUPPORTED
png_set_gAMA(m_png, m_info, m_gamma);
#else
png_set_gAMA_fixed(m_png, m_info,
(png_fixed_point)(m_gamma * 100000));
#endif
#else
throw error("attempted to write gAMA chunk; recompile with PNG_gAMA_SUPPORTED");
#endif
}
png_write_info(m_png, m_info);
}
示例15: rwpng_write_image8
pngquant_error rwpng_write_image8(FILE *outfile, png8_image *mainprog_ptr)
{
png_structp png_ptr;
png_infop info_ptr;
pngquant_error retval = rwpng_write_image_init((png_image*)mainprog_ptr, &png_ptr, &info_ptr, outfile);
if (retval) return retval;
// Palette images generally don't gain anything from filtering
png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, PNG_FILTER_VALUE_NONE);
rwpng_set_gamma(info_ptr, png_ptr, mainprog_ptr->gamma);
/* set the image parameters appropriately */
int sample_depth;
if (mainprog_ptr->num_palette <= 2)
sample_depth = 1;
else if (mainprog_ptr->num_palette <= 4)
sample_depth = 2;
else if (mainprog_ptr->num_palette <= 16)
sample_depth = 4;
else
sample_depth = 8;
png_set_IHDR(png_ptr, info_ptr, mainprog_ptr->width, mainprog_ptr->height,
sample_depth, PNG_COLOR_TYPE_PALETTE,
0, PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_BASE);
png_set_PLTE(png_ptr, info_ptr, &mainprog_ptr->palette[0], mainprog_ptr->num_palette);
if (mainprog_ptr->num_trans > 0)
png_set_tRNS(png_ptr, info_ptr, mainprog_ptr->trans, mainprog_ptr->num_trans, NULL);
png_bytepp row_pointers = rwpng_create_row_pointers(info_ptr, png_ptr, mainprog_ptr->indexed_data, mainprog_ptr->height, mainprog_ptr->width);
rwpng_write_end(&info_ptr, &png_ptr, row_pointers);
free(row_pointers);
return SUCCESS;
}