LIBPNG et ressource

Question

Bonjour

voilà, j'aimerai utiliser libpng pour reduire la taille des images qui sont en ressource en utilisant le png plutôt que le bitmap...
je l'ai déjà fait avec libjpg et à partir d'un patch qui permet de lire via les ressources et non un fichier, ça marche au poil
mais avec libpng, est-ce possible ? doit-on utiliser le meme style patch pour lire les ressources (l'adapter, mais c'est coton) ?
existe-t-il déjà une methode ? (je n'utilise pas de dll externe please)

si quelqu'un avait un exemple, ça serait encore mieux

merci

nightlord666 · Answer

Tu met ton image en binary data dans tes ressources, tu crée un buffer contenant ces données, et tu crée un PNG à partir de ce buffer.

cs_bbear · Answer

je me suis mal expliqué je crois, sorry  
euh...dans mes ressources j'ai une image PNG
et je veux l'afficher en faisant un "pngtobitmap" avec la lib libpng
mais je crois qu'elle ne permet que de lire un fichier externe et pas en ressource.

je l'ai déjà fait avec une image JPG en ressource : et je l'affiche via JpgtoBitmap (source de cppfrance "JpgShow" http://www.cppfrance.com/article.aspx?ID=1114 ) et un patch memsrc.c que j'ai trouvé et qui permet de lire le fichier via les ressources et non pas un fichier externe. et ça marche

je voudrais faire la meme chose en png. mais je ne comprends pas tout avec cette lib.
et je ne crois pas qu'elle utilise les ressources.
je pensais adapter memsrc pour la lib png, si il n'existe pas d'autre moyen.

voila le code de memsrc

/*
* memsrc.c
*
* Copyright (C) 1994-1996, Thomas G. Lane.
* This file is part of the Independent JPEG Group's software.
* For conditions of distribution and use, see the accompanying README file.
*
* This file contains decompression data source routines for the case of
* reading JPEG data from a memory buffer that is preloaded with the entire
* JPEG file. This would not seem especially useful at first sight, but
* a number of people have asked for it.
* This is really just a stripped-down version of jdatasrc.c. Comparison
* of this code with jdatasrc.c may be helpful in seeing how to make
* custom source managers for other purposes.
*/


/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
#include "jinclude.h"
#include "jpeglib.h"
#include "jerror.h"




/* Expanded data source object for memory input */


typedef struct {
struct jpeg_source_mgr pub; /* public fields */


JOCTET eoi_buffer[2]; /* a place to put a dummy EOI */
} my_source_mgr;


typedef my_source_mgr * my_src_ptr;




/*
* Initialize source --- called by jpeg_read_header
* before any data is actually read.
*/


METHODDEF(void)
init_source (j_decompress_ptr cinfo)
{
/* No work, since jpeg_memory_src set up the buffer pointer and count.
* Indeed, if we want to read multiple JPEG images from one buffer,
* this *must* not do anything to the pointer.
*/
}




/*
* Fill the input buffer --- called whenever buffer is emptied.
*
* In this application, this routine should never be called; if it is called,
* the decompressor has overrun the end of the input buffer, implying we
* supplied an incomplete or corrupt JPEG datastream. A simple error exit
* might be the most appropriate response.
*
* But what we choose to do in this code is to supply dummy EOI markers
* in order to force the decompressor to finish processing and supply
* some sort of output image, no matter how corrupted.
*/


METHODDEF(boolean)
fill_input_buffer (j_decompress_ptr cinfo)
{
my_src_ptr src = (my_src_ptr) cinfo->src;


WARNMS(cinfo, JWRN_JPEG_EOF);


/* Create a fake EOI marker */
src->eoi_buffer[0] = (JOCTET) 0xFF;
src->eoi_buffer[1] = (JOCTET) JPEG_EOI;
src->pub.next_input_byte = src->eoi_buffer;
src->pub.bytes_in_buffer = 2;


return TRUE;
}




/*
* Skip data --- used to skip over a potentially large amount of
* uninteresting data (such as an APPn marker).
*
* If we overrun the end of the buffer, we let fill_input_buffer deal with
* it. An extremely large skip could cause some time-wasting here, but
* it really isn't supposed to happen ... and the decompressor will never
* skip more than 64K anyway.
*/


METHODDEF(void)
skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
my_src_ptr src = (my_src_ptr) cinfo->src;


if (num_bytes > 0) {
while (num_bytes > (long) src->pub.bytes_in_buffer) {
num_bytes -= (long) src->pub.bytes_in_buffer;
(void) fill_input_buffer(cinfo);
/* note we assume that fill_input_buffer will never return FALSE,
* so suspension need not be handled.
*/
}
src->pub.next_input_byte += (size_t) num_bytes;
src->pub.bytes_in_buffer -= (size_t) num_bytes;
}
}




/*
* An additional method that can be provided by data source modules is the
* resync_to_restart method for error recovery in the presence of RST markers.
* For the moment, this source module just uses the default resync method
* provided by the JPEG library. That method assumes that no backtracking
* is possible.
*/




/*
* Terminate source --- called by jpeg_finish_decompress
* after all data has been read. Often a no-op.
*
* NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
* application must deal with any cleanup that should happen even
* for error exit.
*/


METHODDEF(void)
term_source (j_decompress_ptr cinfo)
{
/* no work necessary here */
}




/*
* Prepare for input from a memory buffer.
*/


GLOBAL(void)
jpeg_memory_src (j_decompress_ptr cinfo, const JOCTET * buffer, size_t bufsize)
{
my_src_ptr src;


/* The source object is made permanent so that a series of JPEG images
* can be read from a single buffer by calling jpeg_memory_src
* only before the first one.
* This makes it unsafe to use this manager and a different source
* manager serially with the same JPEG object. Caveat programmer.
*/
if (cinfo->src == NULL) { /* first time for this JPEG object? */
cinfo->src = (struct jpeg_source_mgr *)
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
SIZEOF(my_source_mgr));
}


src = (my_src_ptr) cinfo->src;
src->pub.init_source = init_source;
src->pub.fill_input_buffer = fill_input_buffer;
src->pub.skip_input_data = skip_input_data;
src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
src->pub.term_source = term_source;


src->pub.next_input_byte = buffer;
src->pub.bytes_in_buffer = bufsize;
}

nightlord666 · Answer

Tu a essayé de recréer ton png en fichier temporaire et en le rechargeant ? Je pense que c'est quand même le plus simple...

cs_bbear · Answer

je ne comprends pas "recréer ton png" ??
je ne veux pas créé de png, il est déjà dans les ressources mais pour l'afficher il faut bien le transformer en bitmap ? et c'est bien libpng qui permet de lire un png pour le decompresser dans un bitmap temporaire pour l'utiliser ensuite ??
(idem avec libjpeg)

moi j'arrive pas à readapter le code de Kaid "JpegShow" (sur ce site) et "memsrc.c" mais pour la lib png

LIBPNG et ressource

4 réponses

Votre réponse

Discussions similaires