_jedimg2.c

Ir a la documentación de este archivo.

#include "jed_plt.h"

#include <stdio.h> 

#define BYTE unsigned char   

#if (PLATAFORMA != SPARC64_LINUX_GCC) && (PLATAFORMA != i386_LINUX_GCC) && (PLATAFORMA != SUN) && (PLATAFORMA != CYGNUS_WIN32) && (PLATAFORMA != POWERPC_AIX_VACPP)

#define IMPERR()                                                            \
    fprintf(stderr,                                                         \
"AQUYNZA: Error fatal - JPEGlib No disponible\n"                            \
"AQUYNZA ha sido compilado con la opcion JPEG_ENABLED desactivada.  "       \
"Edite el\n"                                                                \
"archivo jed_defs.h, defina la constante JPEG_ENABLED y recompile el \n"    \
"proyecto.  Es posible que esto se deba a que la libreria \"jpeglib\" no\n" \
"esta disponible en su sistema.  Consulte al administrador del sistema y\n" \
"solicite la instalacion de dicha libreria en caso de ser necesario."       \
    );

void
IMAGEN_exportar_jpeg(char *filename, int calidad_jpeg,
                     int x_tam, int y_tam)
{
    IMPERR();
    fprintf(stderr,"Intente exportar a \"%s\" con la calidad %d,\n"
    "una imagen de <%d x %d> pixels.", filename, calidad_jpeg, x_tam, y_tam);
    fflush(stderr);
}

BYTE *
IMAGEN_importar_jpeg(FILE *fd, int *x_tam, int *y_tam,
                     int *components, char *error_cad)
{
    IMPERR();

    /*if ( fd ) fclose(fd);*/

    (*x_tam) = 0;
    (*y_tam) = 0;
    (*components) = 0;
    error_cad[0] = '\0';
    return NULL;
}
#endif

#if (PLATAFORMA == i386_LINUX_GCC) || (PLATAFORMA == SUN) || (PLATAFORMA == CYGNUS_WIN32) || (PLATAFORMA == SPARC64_LINUX_GCC) || (PLATAFORMA == POWERPC_AIX_VACPP)

/*******************************************************************/
/* JPEG DECOMPRESSION CODE EXTRACTED FROM JPEG LIBRARY SAMPLE CODE */
/*******************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <malloc.h>
#include <time.h>
#include <setjmp.h>

#include "jpeglib.h"

/*= DEFINICIONES LOCALES ====================================================*/

struct _MANEJADOR_DE_ERRORES_JPEG_ {
  struct jpeg_error_mgr pub;    /* "public" fields */

  jmp_buf setjmp_buffer;        /* for return to caller */
};

typedef struct _MANEJADOR_DE_ERRORES_JPEG_ * _MANEJADOR_DE_ERRORES_JPEG_PTR;

/*= FUNCIONES UTILITARIAS (PRIVADAS) ========================================*/

void
my_error_exit(j_common_ptr cinfo)
/*
 * Here's the routine that will replace the standard error_exit method:
 */
{
    /* cinfo->err really points to a _MANEJADOR_DE_ERRORES_JPEG_ struct, so coerce pointer */
    _MANEJADOR_DE_ERRORES_JPEG_PTR myerr = 
        (_MANEJADOR_DE_ERRORES_JPEG_PTR) cinfo->err;

    /* Always display the message. */
    /* We could postpone this until after returning, if we chose. */
    (*cinfo->err->output_message)(cinfo);

    /* Return control to the setjmp point */
    longjmp(myerr->setjmp_buffer, 1);
}

/*= SERVICIOS PUBLICOS ======================================================*/

BYTE *
IMAGEN_importar_jpeg(FILE *fd, int *x_tam, int *y_tam, int *components,
                     char *error_cad)
{
    struct jpeg_decompress_struct encabezado;
    /* We use our private extension JPEG error handler.
     * Note that this struct must live as long as the main JPEG parameter
     * struct, to avoid dangling-pointer problems.                       */
    struct _MANEJADOR_DE_ERRORES_JPEG_ jerr;
    /* More stuff */
    JSAMPARRAY buffer;          /* Output row buffer */
    int row_stride;             /* physical row width in output buffer */
    long i;
    JSAMPLE *image_buffer;    

    error_cad[0] = '\0';

    /*- Step 1: allocate and initialize JPEG decompression object -----------*/
    /* Inicializa la libreria JPEG */
    encabezado.err = jpeg_std_error(&jerr.pub);
    jerr.pub.error_exit = my_error_exit;
    if ( setjmp(jerr.setjmp_buffer) ) {
        jpeg_destroy_decompress(&encabezado);
        fprintf(stderr, "<JED_IMG> - ERROR: abriendo un JPEG.\n");
        fflush(stderr);
        return NULL;
    }
    jpeg_create_decompress(&encabezado);   
    jpeg_stdio_src(&encabezado, fd);     /* Indica de donde leer los datos  */
    jpeg_read_header(&encabezado, TRUE); /* Carga el encabezado             */
    jpeg_start_decompress(&encabezado);  /* Inicia la lectura de pixels     */

    /*Make a one-row-high sample array that will go away when done with image*/
    row_stride = encabezado.output_width * encabezado.output_components;
    buffer = (*encabezado.mem->alloc_sarray)
                ((j_common_ptr)&encabezado, JPOOL_IMAGE, row_stride, 1);

    /*- Step 6: while (scan lines remain to be read) ------------------------*/
    /*- jpeg_read_scanlines(...);                                           -*/

    image_buffer = (JSAMPLE *)malloc(encabezado.image_width * 
                                     encabezado.image_height * 
                                     encabezado.output_components);
    if ( !image_buffer ) {
        fprintf(stderr, "<JED_IMG> - ERROR: "
            "No hay memoria para una imagen de %d X %d pixels.\n",
            encabezado.image_width, encabezado.image_height);
        fflush(stderr);
        exit(-1);
    }
    
    
    for ( i = encabezado.output_height - 1;
          encabezado.output_scanline < encabezado.output_height; i-- ) {
        jpeg_read_scanlines(&encabezado, buffer, 1);
        memcpy(image_buffer +
          encabezado.image_width*encabezado.output_components*i,
          buffer[0], row_stride);
    }

    /*- Step 7: Finish decompression ---------------------------------------*/
    jpeg_finish_decompress(&encabezado);
    jpeg_destroy_decompress(&encabezado);

    /* At this point you may want to check to see whether any corrupt-data
     * warnings occurred (test whether jerr.pub.num_warnings is nonzero). */

    if ( jerr.pub.num_warnings != 0 ) {
        sprintf(error_cad, "[Warnings JPEG = %d].", jerr.pub.num_warnings);
    }

    /*- Finalmente, deje los resultados listos ------------------------------*/
    (*x_tam) = encabezado.image_width;
    (*y_tam) = encabezado.image_height;
    (*components) = encabezado.output_components;
    return image_buffer;
}

void
IMAGEN_exportar_jpeg(FILE *fd, int calidad_jpeg, int x_tam, int y_tam,
                     BYTE *Data)
{
    static int i;
    static struct jpeg_compress_struct cinfo;
    static struct jpeg_error_mgr       jerr;
    static JSAMPROW row_pointer[1];     /* pointer to JSAMPLE row[s]  */
                        
    /*- Abra el archivito -------------------------------------------------*/
    if ( !fd ) {
        return;
    }

    /*- Exporte la imagen -------------------------------------------------*/
    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_compress(&cinfo);
    jpeg_stdio_dest(&cinfo, fd);

    cinfo.image_width = x_tam;        /* image width and height, in pixels */
    cinfo.image_height = y_tam;
    cinfo.input_components = 3;       /* # of color components per pixel   */
    cinfo.in_color_space = JCS_RGB;   /* colorspace of input image         */
    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, calidad_jpeg, TRUE);
    jpeg_start_compress(&cinfo, TRUE);
    
    for ( i = cinfo.image_height; i > 0; i-- ) {
        /* jpeg_write_scanlines expects an array of pointers to scanlines.
         * Here the array is only one element long, but you could pass
         * more than one scanline at a time if that's more convenient. */
        row_pointer[0] = & Data[i * x_tam * 3];
        jpeg_write_scanlines(&cinfo, row_pointer, 1);
    }
    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);
}

/*= EOF =====================================================================*/
#endif

---

Este archivo HTML ha sido generado automáticamente a partir del código fuente AQUYNZA. NO LO EDITE. Para mayor información contacte al autor.