[Help] Compressore Jpeg Independent Group in C

[dario79]

Raga chiedo assolutamente a voi una mano per il mio lavoro di tesi...

Devo implementare il compressore Jpeg open source CJPEG su un piccolo processore.

Dato che questo processore non ha disco devo caricargli l'immagine da comprimere in memoria e lui restituirà il file jpeg in memoria stesso.

Per questo ho fatto in modo da creare una matrice (ossia una mia variabile) contenente un esempio di immagine, poi inglobarla nel codice tramite header.h e lavorarci come "file sorgente".

Purtroppo il programma è scritto per leggere da file e sto incontrando notevoli difficoltà nel fargli puntare a IMAGE[N][M] anzichè al file.
Il mio lavoro è per il tipo file immagine PGM formato ascii, ossia il P2.
Il pacchetto lo trovate qui: ftp://ftp.simtel.net/pub/simtelnet/msdos/graphics/jpegsr6.zip

i file da valutare sono cjpeg.c e rdppm.c

A chi saprà aiutarmi comprerò una Bentley :sofico: no dai una pizza :Prrr:


Grazie mille a tutti

[ilsensine]

Non farei così. Cambierei tutte le chiamate a fread/fwrite/ecc. a tue funzioni di comodo, che implementano la lettura da memoria. Così ti astrai da "dove vengono i dati".

Il tuo "piccolo processore" è sufficientemente grande da eseguire un sistema operativo o è proprio "piccolo"?

[dario79]

ciao e grazie innanzitutto

il processore è il Leon 2 sparc....un open source vhdl...capace di far girare anche un piccolo linux sopra

il discorso è che la mia tesi è volta a valutare il consumo di potenza, in tal caso durante codifiche video.

Questo esclude qualsiasi forma di aggiunta di ulteriore software che puo' sviare le mie analisi....mi spiego?

Tornando al discorso, mi daresti un input sulle funzioni a cui ti riferivi?

Dici di crearmi delle void globali che puntano alla memoria?
Se dai un'occhiata al codice vedrai che tali void sono già realizzate per effettuare scansioni sulle righe delle immagini...l'unica cosa è che devo cambiare lo stdin e ahimè non so farlo dalla memoria anzichè da FILE * inputfile :muro:

grazie mille

[cionci]

Quello che diceva ilsensine era di farti un layer per adattare il formato di tutte le chiamate a chiamate personalizzate...

Tanto per cominciare io memorizzerei i dati su un vettore e non su una matrice...

A questo punto si tratta di fare funzioni del tipo:

miafopen, miafread, miafseek, miafclose...

Ovviamente tutte le occorrenze delle varie funzioni f* devono essere modificate con le tue nuove...

Nella funzione miafopen dovrai ingnorare completamente i parametri...
Nella miafread ritornerai nel buffer passato il numero di byte richiesto...e in pratica hai finito...

[dario79]

compreso....

si tratterebbe di fare un sorta di redirect tra le chiamate a funzione....

ogni puntata al file la cambio con la mia funzione.....la MIAFUNZIONE sarà realizzata per far semplicemente scambiare il puntatore anzichè al file---->alla prima locazione di memoria della matrice/vettore...giusto?

[cionci]

la MIAFUNZIONE sarà realizzata per far semplicemente scambiare il puntatore anzichè al file---->alla prima locazione di memoria della matrice/vettore...giusto?
Ecco questa è un'idea ottima...con la miafopen restituisci un puntatore all'inizio del vettore...
Ovviamente dovresti cambiare il tipo FILE con MIOFILE ;)

[dario79]

ci provo....come al solito siete i migliori
grassie e non abbandonatemi che mi voglio laureaaaaaaaaaaaaaaààààà :sofico:

[dario79]

allora studiandomi il codice ho naotato che nel programma principale c'è questa parte:


/* Open the input file. */
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
input_file = read_stdin();
}

/* Open the output file. */
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
/* default output file is stdout */
output_file = write_stdout();
}

#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &cinfo, &progress);
#endif

/* Figure out the input file format, and set up to read it. */
src_mgr = select_file_type(&cinfo, input_file);
src_mgr->input_file = input_file;

/* Read the input file header to obtain file size & colorspace. */
(*src_mgr->start_input) (&cinfo, src_mgr);

/* Now that we know input colorspace, fix colorspace-dependent defaults */
jpeg_default_colorspace(&cinfo);

/* Adjust default compression parameters by re-parsing the options */
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);

/* Specify data destination for compression */
jpeg_stdio_dest(&cinfo, output_file);

/* Start compressor */
jpeg_start_compress(&cinfo, TRUE);

/* Process data */
while (cinfo.next_scanline < cinfo.image_height) {
num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr);
(void) jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines);
}

/* Finish compression and release memory */
(*src_mgr->finish_input) (&cinfo, src_mgr);
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);

/* Close files, if we opened them */
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);

#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &cinfo);
#endif

/* All done. */
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}


in cui le void read_stdin e out sono definite in un altro file come:


/*
* Routines to establish binary I/O mode for stdin and stdout.
* Non-Unix systems often require some hacking to get out of text mode.
*/

GLOBAL(FILE *)
read_stdin (void)
{
FILE * input_file = stdin;

#ifdef USE_SETMODE /* need to hack file mode? */
setmode(fileno(stdin), O_BINARY);
#endif
#ifdef USE_FDOPEN /* need to re-open in binary mode? */
if ((input_file = fdopen(fileno(stdin), READ_BINARY)) == NULL) {
fprintf(stderr, "Cannot reopen stdin\n");
exit(EXIT_FAILURE);
}
#endif
return input_file;
}


GLOBAL(FILE *)
write_stdout (void)
{
FILE * output_file = stdout;

#ifdef USE_SETMODE /* need to hack file mode? */
setmode(fileno(stdout), O_BINARY);
#endif
#ifdef USE_FDOPEN /* need to re-open in binary mode? */
if ((output_file = fdopen(fileno(stdout), WRITE_BINARY)) == NULL) {
fprintf(stderr, "Cannot reopen stdout\n");
exit(EXIT_FAILURE);
}
#endif
return output_file;
}


come vedi la definizione di MIAFREAD è già fatta come read_stdin

ecco secondo la nostra idea come dovrei cambiare il puntatore al file dato che io ho incluso in un header la mia matriciozza contenente il file imamgine?

#define IMAGE {{------------
------------

-----------}

grazie mille!

[cionci]

typedef unsigned char * MIOFILE;

GLOBAL(MIOFILE *)
read_stdin (void)
{
MIOFILE * input_file = (MIOFILE *) malloc(IMAGESIZE);

memcpy(input_file, IMAGE, IMAGESIZE);

return input_file;
}

Ma la JPEG la devi scrivere sull'stdout ?

[dario79]

all'inizio, per poter accertarmi del corretto funzionamento del tutto, devo farlo andare da pc e scrivere il jpeg su disco, poi invece la scrittura la farò nell'ulima parte di memoria....

ps tu hai definito mio file come usigned char mentre io nell'header la mia matrice IMAGE solo come define IMAGE ecc....

la conversione in char avverrà in auto?

[cionci]

IMAGE come ti ho detto...è meglio memorizzarla come vettore e non come matrice... Come sono formati gli elementi della matrice ?

[cionci]

Devi aggiungere anche questa riga:

unsigned char img[] = IMAGE;

e modificare questa:

memcpy(input_file, img, IMAGESIZE);

[dario79]

provvedo a cambiare la scrittura dell'header per scriverla come vettore...

ora la sua struttura è:



#define col 25

#define righe 10

#define IMAGE { \
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1}, \
{0,3,3,3,3,0,0,7,7,7,7,0,0,11,11,11,11,0,0,15,15,15,15,1,1}, \
{0,3,0,0,0,0,0,7,0,0,0,0,0,11,0,0,0,0,0,15,0,0,15,1,1}, \
{0,3,3,3,0,0,0,7,7,7,0,0,0,11,11,11,0,0,0,15,15,15,15,1,1}, \
{0,3,0,0,0,0,0,7,0,0,0,0,0,11,0,0,0,0,0,15,0,0,0,1,1}, \
{0,3,0,0,0,0,0,7,7,7,7,0,0,11,11,11,11,0,0,15,0,0,0,1,1}, \
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1}, \
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1}, \
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1}, \
{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1} \
}


grazie mille!!!

[dario79]

debian:/home/dario/Desktop/jpeg-6b# make
gcc -O2 -I. -c -o cjpeg.o cjpeg.c
gcc -O2 -I. -c -o rdppm.o rdppm.c
gcc -O2 -I. -c -o rdgif.o rdgif.c
gcc -O2 -I. -c -o rdtarga.o rdtarga.c
gcc -O2 -I. -c -o rdrle.o rdrle.c
gcc -O2 -I. -c -o rdbmp.o rdbmp.c
gcc -O2 -I. -c -o rdswitch.o rdswitch.c
gcc -O2 -I. -c -o cdjpeg.o cdjpeg.c
cdjpeg.c:24: error: parse error before numeric constant
cdjpeg.c:156: error: conflicting types for `read_stdin'
cdjpeg.h:150: error: previous declaration of `read_stdin'
cdjpeg.c: In function `read_stdin':
cdjpeg.c:157: error: `IMAGESIZE' undeclared (first use in this function)
cdjpeg.c:157: error: (Each undeclared identifier is reported only once
cdjpeg.c:157: error: for each function it appears in.)
make: *** [cdjpeg.o] Error 1
debian:/home/dario/Desktop/jpeg-6b#



provalo anche tu magari è + semplice e capirsi sarebbe + facile....www.ijg.org

grazie infinitamente

[dario79]

Ascolta secondo te la mia idea potrebbe funzionare?

Allora io gli inglobo la variabile e tutto come prima....lascio anche il codice relativo a FILE invariato....

Poi stavo guardando il file relativo alla lettura di immagini ppm (quelle che mi servono) e la mia idea era quella che, anzichè fargli passare nel buffer quello che lui sta leggendo da file, gli forzo io una scrittura di quello che ho nella variabile così lui arriverà fino al 99% della procedura originaria ma il dato effettivamente passato è quello che dico io....

METHODDEF(JDIMENSION)
get_scaled_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
/* This version is for reading raw-byte-format PGM files with any maxval */
{
ppm_source_ptr source = (ppm_source_ptr) sinfo;
register JSAMPROW ptr;
register U_CHAR * bufferptr;
register JSAMPLE *rescale = source->rescale;
JDIMENSION col;

if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
ERREXIT(cinfo, JERR_INPUT_EOF);
ptr = source->pub.buffer[0];
bufferptr = source->iobuffer;
for (col = cinfo->image_width; col > 0; col--) {
*ptr++ = rescale[UCH(*bufferptr++)];
}
return 1;
}


pensavo ad un qualcosa del tipo

METHODDEF(JDIMENSION)
get_scaled_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
/* This version is for reading raw-byte-format PGM files with any maxval */
{
ppm_source_ptr source = (ppm_source_ptr) sinfo;
register JSAMPROW ptr;
register U_CHAR * bufferptr;
register JSAMPLE *rescale = source->rescale;
JDIMENSION col;

source->iobuffer = IMAGE[indice];
indice++;

// if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
// ERREXIT(cinfo, JERR_INPUT_EOF);


ptr = source->pub.buffer[0];
bufferptr = source->iobuffer;
for (col = cinfo->image_width; col > 0; col--) {
*ptr++ = rescale[UCH(*bufferptr++)];
}
return 1;
}


dato che questa funzione è richiamata in un while nel programma principale tante volte quanto è lunga l'immagine, cioè sta effettuando delle scansioni per riga (il file è rdppm.c)

così com'è non me lo piglia....devo rivedere qualcosa....

conto sul vostro aiuto

grazie!!

[cionci]

debian:/home/dario/Desktop/jpeg-6b# make
gcc -O2 -I. -c -o cjpeg.o cjpeg.c
gcc -O2 -I. -c -o rdppm.o rdppm.c
gcc -O2 -I. -c -o rdgif.o rdgif.c
gcc -O2 -I. -c -o rdtarga.o rdtarga.c
gcc -O2 -I. -c -o rdrle.o rdrle.c
gcc -O2 -I. -c -o rdbmp.o rdbmp.c
gcc -O2 -I. -c -o rdswitch.o rdswitch.c
gcc -O2 -I. -c -o cdjpeg.o cdjpeg.c
cdjpeg.c:24: error: parse error before numeric constant
cdjpeg.c:156: error: conflicting types for `read_stdin'
cdjpeg.h:150: error: previous declaration of `read_stdin'
cdjpeg.c: In function `read_stdin':
cdjpeg.c:157: error: `IMAGESIZE' undeclared (first use in this function)
cdjpeg.c:157: error: (Each undeclared identifier is reported only once
cdjpeg.c:157: error: for each function it appears in.)
make: *** [cdjpeg.o] Error 1
debian:/home/dario/Desktop/jpeg-6b#


Devi definire una costante chiamata IMAGESIZE...inoltre devi modificare la dichiarazione di read_stdin...

Il nuovo metodo mi sembra decisamente peggiore...