---

image_Jpeg_mod.c

Go to the documentation of this file.

/*
 *    gui - [gega user interface] the flexible solution for user interface problems
 *    Copyright (C) 2002  Gergely Gati
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; version 2 of the License.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *    Gergely Gati
 *      email:           g.gati@freemail.hu
 *      AIM screenname:  GatiGergely
 *      ICQ number:      93131690
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <jpeglib.h>

#define __IMAGE_MODULE

#include "Bases.h"
#include "Module.h"
#include "Memory.h"
#include "Common.h"
#include "debug.h"
#include "macros.h"

#include "images/image_Jpeg.h"


#ifdef CYGWIN
#ifndef UNIX
#include <sys/reent.h>
struct _reent *_impure_ptr __ATTRIBUTE_IMPURE_PTR__;
int __errno;
#endif
#endif

typedef struct jpeg_CustomData_s
{
  Image_t *img;
  int fp;
  struct jpeg_decompress_struct cinfo;
  struct jpeg_error_mgr jerr;
} jpeg_CustomData_t;


static char *jpeg_name="jpeg";


/******INPUT BEGIN*****/

typedef struct
{
  struct jpeg_source_mgr pub;   /* public fields */
  jpeg_CustomData_t *cdata;     /* source stream */
  boolean start_of_file;    /* have we gotten any data yet? */
} my_source_mgr;


typedef my_source_mgr * my_src_ptr;


static bases_Modules_t *api;
VERSION("Jpeg.image_mod",1,0,"Gergely Gati","g.gati@freemail.hu");


METHODDEF(void)
my_init_source (j_decompress_ptr cinfo)
{
  my_src_ptr src = (my_src_ptr) cinfo->src;
  src->start_of_file = TRUE;
  src->cdata->fp=0;
}

METHODDEF(boolean)
my_fill_input_buffer (j_decompress_ptr cinfo)
{
  my_src_ptr src = (my_src_ptr) cinfo->src;

  src->pub.next_input_byte = &src->cdata->img->iim.data[src->cdata->fp];
  src->pub.bytes_in_buffer = min(src->cdata->img->iim.data_size-src->cdata->fp,4096);
  src->start_of_file = FALSE;
  src->cdata->fp+=src->pub.bytes_in_buffer;

  return TRUE;
}

METHODDEF(void)
my_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) my_fill_input_buffer(cinfo);
    }
    src->pub.next_input_byte += (size_t) num_bytes;
    src->pub.bytes_in_buffer -= (size_t) num_bytes;
  }
}

METHODDEF(void)
my_term_source (j_decompress_ptr cinfo)
{
}

GLOBAL(void)
jpeg_my_stdio_src (j_decompress_ptr cinfo, jpeg_CustomData_t *cdata)
{
  my_src_ptr src;

  if (cinfo->src == NULL)
  {
    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 = (my_src_ptr) cinfo->src;
  src->pub.init_source = my_init_source;
  src->pub.fill_input_buffer = my_fill_input_buffer;
  src->pub.skip_input_data = my_skip_input_data;
  src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
  src->pub.term_source = my_term_source;
  src->cdata = cdata;
  src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
  src->pub.next_input_byte = NULL; /* until buffer loaded */
}

/***********/



static void my_error_exit(j_common_ptr cinfo)
{
  printf("%s\n",__FUNCTION__);
  exit(0);
}



// ez kitolti az image struktura hianyzo mezoit
// ha az input struktura format mezoje ki van toltve,
// es az nem "jpeg", akkor FALSE,
// ha NULL akkor egy statikus "jpeg"-re allitja, ha
// a data egy valid png-nek latszik.
// kitolti a meret mezoket is.
static int jpeg_ImgInit(Image_t *img, void (*update)(void *),void *userdata)
{
  int ret=-1;
  jpeg_CustomData_t *cdata;

  debug_Begin();

  if(img!=NULL)
  {
    if(img->format==NULL||strcmp(img->format,jpeg_name)==0)
    {
      if(img->iim.data[6]=='J'&&img->iim.data[7]=='F'&&img->iim.data[8]=='I'&&img->iim.data[9]=='F')
      {
        if(img->format==NULL) img->format=jpeg_name;
        if(NULL!=(cdata=mem_malloc(sizeof(jpeg_CustomData_t))))
        {
          img->formatdata=cdata;
          cdata->img=img;
          cdata->fp=0;
          cdata->cinfo.err=jpeg_std_error(&cdata->jerr);
          cdata->jerr.error_exit=my_error_exit;
          jpeg_create_decompress(&cdata->cinfo);
            jpeg_my_stdio_src(&cdata->cinfo,cdata);
            jpeg_read_header(&cdata->cinfo,TRUE);
            img->minwidth=img->maxwidth=cdata->cinfo.image_width;
            img->minheight=img->maxheight=cdata->cinfo.image_height;
          jpeg_destroy_decompress(&cdata->cinfo);
          ret=0;
        }
      }
    }
  }

  debug_End();

  return(ret);
}


static void jpeg_ImgCleanUp(Image_t *img)
{
  jpeg_CustomData_t *cdata;

  debug_Begin();

  if(img!=NULL)
  {
    cdata=(jpeg_CustomData_t *)img->formatdata;
    if(cdata!=NULL) mem_free(cdata);
  }

  debug_End();
}


// a dest memoriat a hivo prezentalja destsize
// meretben, ha kicsi, hiba (-1)
// a rendereles 32bitesen tortenik, az atlatszo
// pixelek helyere 0xffffffff kerul
static int jpeg_ImgRender(Image_t *img, u8 *dest, int destsize, int width, int height)
{
  jpeg_CustomData_t *cdata;
  JSAMPARRAY row_pointers;
  int i;

  debug_Begin();

  if(img!=NULL&&img->formatdata!=NULL&&dest!=NULL&&destsize>=(width*height*4)&&width==img->minwidth&&height==img->minheight)
  {
    cdata=(jpeg_CustomData_t *)img->formatdata;

    cdata->fp=0;
    jpeg_create_decompress(&cdata->cinfo);
    jpeg_my_stdio_src(&cdata->cinfo,cdata);
    jpeg_read_header(&cdata->cinfo,TRUE);
//      img->minwidth=img->maxwidth=cdata->cinfo.image_width;
//      img->minheight=img->maxheight=cdata->cinfo.image_height;
    jpeg_start_decompress(&cdata->cinfo);
    if(NULL!=(row_pointers=mem_malloc(height*sizeof(JSAMPROW))))
    {
      for(i=0;i<height;i++) row_pointers[i]=&dest[width*(i*4)];
      for(i=0;cdata->cinfo.output_scanline < cdata->cinfo.output_height;i++)
      {
        jpeg_read_scanlines(&cdata->cinfo,&row_pointers[i],1);
      }
      mem_free(row_pointers);
    }
    jpeg_finish_decompress(&cdata->cinfo);
    jpeg_destroy_decompress(&cdata->cinfo);
  }

  debug_End();

  return(0);
}


static int jpeg_PutImage(Image_t *img, u32 window, Rect_t *rect)
{
  Vector_t buff;

  debug_Begin();

  buff.size=(rect->width*rect->height*4)+1;
  if(NULL!=(buff.data=mem_malloc(buff.size)))
  {
    if(0==(jpeg_ImgRender(img,buff.data,buff.size,rect->width,rect->height)))
    {
      api->glw_Call(GLW_PUTIMAGE,TAG_GLW_WINDOW,window,TAG_GLW_PIXELS,&buff,TAG_GLW_CLIPRECT,rect,TAG_GLW_LEFT,rect->left,TAG_GLW_TOP,rect->top,TAG_GLW_WIDTH,rect->width,TAG_GLW_HEIGHT,rect->height,TAG_DONE);
    }
    mem_free(buff.data);
  }

  debug_End();

  return(0);
}


static void jpeg_CleanUp(void)
{
  debug_Begin();
  debug_End();
}


static int jpeg_Init(u32 module)
{
  int ret=-1;

  debug_Begin();

  ret=api->img_Call(IMG_REGISTERFORMATCODE,
                TAG_IMG_NAME,(u32)"jpeg",
                TAG_IMG_IMG_INIT,(u32)jpeg_ImgInit,
                TAG_IMG_IMG_RENDER,(u32)jpeg_ImgRender,
                TAG_IMG_IMG_PUTIMAGE,(u32)jpeg_PutImage,
                TAG_IMG_IMG_CLEAN,(u32)jpeg_ImgCleanUp,
                TAG_IMG_CLEANUP,(u32)jpeg_CleanUp,
                TAG_IMG_MODULE,module,
                TAG_DONE);

  debug_Begin();

  return(ret);
}

EXPORT int module_Init(u32 module, bases_Modules_t *bases)
{
    api=bases;
    return(jpeg_Init(module));
}

---