Converting string to IMAGE_T - c++

Question

i'm working on a simple graphic application working with raspberry dispmanx.
My goal is to acquire a png file via stdin (from a RGBA array, formatted as a string, from a python app), convert it into the IMAGE_T format expected by dispmanx in order to display it.
Now, I only have a function that can acquire PNG from file, but it takes too much time to write the image on disk, event on tmpfs.
How can I rewrite this function to work with a string as input ?
I would have manage this alone, but i don't know how to emulate a file from a variable to feed png_ptr and info_ptr ...
#include <png.h>
#include <stdlib.h>
#include "bcm_host.h"
#include "loadpng.h"
//-------------------------------------------------------------------------
#ifndef ALIGN_TO_16
#define ALIGN_TO_16(x) ((x + 15) & ~15)
#endif
//-------------------------------------------------------------------------
bool
loadPngData(
IMAGE_T* image,
const char *file)
{
FILE* fpin = fopen(file, "rb");
if (fpin == NULL)
{
fprintf(stderr, "loadpng: can't open file for reading\n");
return false;
}
//---------------------------------------------------------------------
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
NULL,
NULL,
NULL);
if (png_ptr == NULL)
{
fclose(fpin);
return false;
}
png_infop info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL)
{
png_destroy_read_struct(&png_ptr, 0, 0);
fclose(fpin);
return false;
}
if (setjmp(png_jmpbuf(png_ptr)))
{
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
fclose(fpin);
return false;
}
//---------------------------------------------------------------------
png_init_io(png_ptr, imgdata);
png_read_info(png_ptr, info_ptr);
//---------------------------------------------------------------------
png_byte colour_type = png_get_color_type(png_ptr, info_ptr);
png_byte bit_depth = png_get_bit_depth(png_ptr, info_ptr);
VC_IMAGE_TYPE_T type = VC_IMAGE_RGB888;
if (colour_type & PNG_COLOR_MASK_ALPHA)
{
type = VC_IMAGE_RGBA32;
}
initImage(image,
type,
png_get_image_width(png_ptr, info_ptr),
png_get_image_height(png_ptr, info_ptr),
false);
//---------------------------------------------------------------------
double gamma = 0.0;
if (png_get_gAMA(png_ptr, info_ptr, &gamma))
{
png_set_gamma(png_ptr, 2.2, gamma);
}
//---------------------------------------------------------------------
if (colour_type == PNG_COLOR_TYPE_PALETTE)
{
png_set_palette_to_rgb(png_ptr);
}
if ((colour_type == PNG_COLOR_TYPE_GRAY) && (bit_depth < 8))
{
png_set_expand_gray_1_2_4_to_8(png_ptr);
}
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
{
png_set_tRNS_to_alpha(png_ptr);
}
if (bit_depth == 16)
{
#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
png_set_scale_16(png_ptr);
#else
png_set_strip_16(png_ptr);
#endif
}
if (colour_type == PNG_COLOR_TYPE_GRAY ||
colour_type == PNG_COLOR_TYPE_GRAY_ALPHA)
{
png_set_gray_to_rgb(png_ptr);
}
//---------------------------------------------------------------------
png_read_update_info(png_ptr, info_ptr);
//---------------------------------------------------------------------
png_bytepp row_pointers = malloc(image->height * sizeof(png_bytep));
png_uint_32 j = 0;
for (j = 0 ; j < image->height ; ++j)
{
row_pointers[j] = image->buffer + (j * image->pitch);
}
//---------------------------------------------------------------------
png_read_image(png_ptr, row_pointers);
//---------------------------------------------------------------------
fclose(fpin);
free(row_pointers);
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
return true;
}
Edit : Image can be provided from python in raw RGBA, or in png format (as a string with header, and chunks). I suppose raw RGBA would faster (skipping png format), but the modifying this function may be more simple with PNG string ...
Any clue is welcome !

Answer 1

If you can get raw RGBA data then you don't need this function. This function is used to decode compressed png format to raw RGBA. The only thing you'd probably also need to provide is width and height.
The only question now is what would be more efficient - sending raw, uncompressed data to C program or encoding it in Python to PNG, sending encoded data and decoding it in C program.
The biggest issue here is the png_init_io(png_ptr, fpin); (I changed imgData to fpin in the function call, but you probably wanted to pass the array instead of the FILE handle). In libpng documentation in section 5 there's a description how to provide one's own functions for input/output. You'd have to substitute png_init_io with your own function taking const char* instead of FILE*. Here's a part on the png_init_io:
Input/Output in libpng is done through png_read() and png_write(), which currently just call fread() and fwrite(). The FILE * is stored in png_struct and is initialized via png_init_io(). If you wish to change the method of I/O, the library supplies callbacks that you can set through the function png_set_read_fn() and png_set_write_fn() at run time, instead of calling the png_init_io() function. These functions also provide a void pointer that can be retrieved via the function png_get_io_ptr(). For example:
png_set_read_fn(png_structp read_ptr,
voidp read_io_ptr, png_rw_ptr read_data_fn)
png_set_write_fn(png_structp write_ptr,
voidp write_io_ptr, png_rw_ptr write_data_fn,
png_flush_ptr output_flush_fn);
voidp read_io_ptr = png_get_io_ptr(read_ptr);
voidp write_io_ptr = png_get_io_ptr(write_ptr);
The replacement I/O functions must have prototypes as follows:
void user_read_data(png_structp png_ptr,
png_bytep data, png_size_t length);
void user_write_data(png_structp png_ptr,
png_bytep data, png_size_t length);
void user_flush_data(png_structp png_ptr);
I've never manipulated those functions so I can't help you here, but it seems that the only thing you'd have to change is skip opening the file and read the same chunks of data from the array as the original implementation does with a file. You'd have to read this section, probably check the source code to see what's to be done and think if it's worth the time if you have the possibility to get already decoded data.