---

Image.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 <stdlib.h>
#include <string.h>

#define __IMAGE_MODULE

#include "macros.h"
#include "debug.h"
#include "Memory.h"
#include "Net.h"
#include "Image.h"
#include "Window.h"


#define IMG_FS_RECOG   1
#define IMG_FS_LOADED  2


struct Format_s
{
  char *name;
  int status;
  int counter;
  int (*img_recognize)(u8 *,int);
  int (*img_init)(Image_t *,void (*)(void *),void *);
  void (*img_clean)(Image_t *);
  int (*img_render)(Image_t *,u8 *,int,int,int);
  int (*img_putimage)(Image_t *,u32,Rect_t *);
  void (*cleanup)(void);
  u32 module;
  u32 mainmodule;
};


static List_t *FormatList;      //SEMAPHORE PROTECTED!
static u32 (*call_vector[IMG_FUNC_DONE-IMG_FUNCBASE+1])(tag *);

static Image_t *img_InitImageByMem(ImageIn_t *image, void (*update)(void *),void *userdata);
static Image_t *img_InitImageByName(gui_App_t *app, char *name, void (*update)(void *),void *userdata);


u32 img_InitImage(u32 firsttag, ...)
{
  return(img_InitImageTL((tag *)&firsttag));
}
u32 img_InitImageTL(tag *taglist)
{
  gui_App_t *app;

  ImageIn_t *image;
  Image_t *img=NULL;
  char *imagename;

  debug_Begin();

  app=(gui_App_t *)tag_GetTagData(taglist,TAG_IMG_APP,0L);

  image=(ImageIn_t *)tag_GetTagData(taglist,TAG_IMG_IMAGEIN,0L);
  if(image!=NULL)
  {
    img=img_InitImageByMem(image,NULL,NULL);
    img->app=app;
    img->free_after_use=(int)tag_GetTagData(taglist,TAG_IMG_FREEAFTERUSE,0L);
  }
  else
  {
    imagename=(char *)tag_GetTagData(taglist,TAG_IMG_IMAGENAME,0L);
    if(NULL!=imagename) img=img_InitImageByName(app,imagename,NULL,NULL);
  }

  debug_End();

  return((u32)img);
}



static Image_t *img_InitImageByMem(ImageIn_t *image, void (*update)(void *),void *userdata)
{
  Image_t *img=NULL;
  Format_t *format;
  Node_t *node;
  char *name;

  debug_Begin();

  if(image!=NULL)
  {
    if(NULL!=(img=mem_malloc(sizeof(Image_t))))
    {
      memcpy(&img->iim,image,sizeof(ImageIn_t));
      img->format=NULL;
      for(node=list_GetNodeHead(FormatList);node!=NULL;node=list_GetNodeNext(FormatList,node))
      {
        format=(Format_t *)list_GetNodeData(node);
        if(0==format->img_recognize(image->data,image->data_size))
        {
          if(format->status!=IMG_FS_LOADED)
          {
            if(format->status==IMG_FS_RECOG)
            {
              if(NULL!=(name=mem_malloc(strlen(format->name)+1+6+7+4)))
              {
                strcpy(name,"images/");
                strcat(name,format->name);
                strcat(name,".image_mod");
                glw_OpenModule(name);
                mem_free(name);
              }
            }
          }
          if(format->img_init!=NULL&&0==(format->img_init(img,update,userdata)))
          {
            format->counter++;
            img->format=format->name;
            img->formatpnt=format;
            img->free_after_use=0;
            break;
          }
        }
      }
    }
    if(img->format==NULL)
    {
      mem_free(img);
      img=NULL;
    }
  }

  debug_End();

  return(img);
}


static Image_t *img_InitImageByName(gui_App_t *app, char *name, void (*update)(void *),void *userdata)
{
  Image_t *img=NULL;
  ImageIn_t image;

  debug_Begin();

  // get_file_handle (appname/prefs/name)
  if(NULL!=(image.data=(u8 *)net_LoadFile(TAG_NET_CONN,app->conn,TAG_NET_NAME,name,TAG_NET_LEN,&image.data_size,TAG_DONE)))
  {
    if(NULL!=(img=img_InitImageByMem(&image,update,userdata)))
    {
      debug_Message("--name='%s' id=%p",name,img);
      img->app=app;
      img->free_after_use=1;
    }
  }

  debug_End();

  return(img);
}


u32 img_CleanUpImage(u32 firsttag, ...)
{
  return(img_CleanUpImageTL((tag *)&firsttag));
}
u32 img_CleanUpImageTL(tag *taglist)
{
  Image_t *img;

  int ret=-1;
  Format_t *format;


  debug_Begin();

  img=(Image_t *)tag_GetTagData(taglist,TAG_IMG_OBJECT,0L);

  if(img!=NULL)
  {
    if(NULL!=(format=img->formatpnt))
    {
      format->img_clean(img);
      format->counter--;
      if(format->counter==0&&format->mainmodule!=0L)
      {
        format->status=IMG_FS_RECOG;
        glw_CloseModule(format->mainmodule);
        format->mainmodule=0L;
        format->img_init=NULL;
        format->img_clean=NULL;
        format->img_render=NULL;
        format->img_putimage=NULL;
        format->cleanup=NULL;
      }
      img->formatdata=NULL;
      img->formatpnt=NULL;
    }
    if(img->free_after_use!=0) mem_free(img->iim.data);
    mem_free(img);
  }

  debug_End();

  return((u32)ret);
}


u32 img_GetInfo(u32 firsttag, ...)
{
  return(img_GetInfoTL((tag *)&firsttag));
}
u32 img_GetInfoTL(tag *taglist)
{
  Image_t *img;
  ImageInfo_t *imginfo;

  int ret=-1;


  debug_Begin();

  img=(Image_t *)tag_GetTagData(taglist,TAG_IMG_OBJECT,0L);
  imginfo=(ImageInfo_t *)tag_GetTagData(taglist,TAG_IMG_IMGINFO,0L);

  if(NULL!=img&&NULL!=imginfo)
  {
    debug_Message("--id=%p",img);
    memcpy(&imginfo->iim,&img->iim,sizeof(ImageIn_t));
    imginfo->format=img->format;
    imginfo->minwidth=img->minwidth;
    imginfo->maxwidth=img->maxwidth;
    imginfo->minheight=img->minheight;
    imginfo->maxheight=img->maxheight;
    ret=0;
  }

  debug_End();

  return((u32)ret);
}


u32 img_RenderImage(u32 firsttag, ...)
{
  return(img_RenderImageTL((tag *)&firsttag));
}
u32 img_RenderImageTL(tag *taglist)
{
  Image_t *img;
  u8 *dest;
  int destsize;
  int width;
  int height;

  int ret=-1;
  Format_t *format;


  debug_Begin();

  img=(Image_t *)tag_GetTagData(taglist,TAG_IMG_OBJECT,0L);
  dest=(u8 *)tag_GetTagData(taglist,TAG_IMG_DEST,0L);
  destsize=(int )tag_GetTagData(taglist,TAG_IMG_DESTSIZE,0L);
  width=(int )tag_GetTagData(taglist,TAG_IMG_WIDTH,0L);
  height=(int )tag_GetTagData(taglist,TAG_IMG_HEIGHT,0L);

  if(img!=NULL)
  {
    debug_Message("--id=%p",img);
    if(NULL!=(format=img->formatpnt))
    {
      if(img->minwidth<=width&&img->minheight<=height&&img->maxwidth>=width&&img->maxheight>=height)
      {
        if(0==(format->img_render(img,dest,destsize,width,height))) ret=0;
      }
    }
  }

  debug_End();

  return((u32)ret);
}


u32 img_PutImage(u32 firsttag, ...)
{
  return(img_PutImageTL((tag *)&firsttag));
}
u32 img_PutImageTL(tag *taglist)
{
  Image_t *img;
  Window_t *win;
  Rect_t *rect;

  int ret=-1;
  Format_t *format;


  debug_Begin();

  img=(Image_t *)tag_GetTagData(taglist,TAG_IMG_OBJECT,0L);
  win=(Window_t *)tag_GetTagData(taglist,TAG_IMG_WINDOW,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_IMG_RECT,0L);

  if(img!=NULL)
  {
    debug_Message("--id=%p",img);
    if(NULL!=(format=img->formatpnt))
    {
      debug_Message("rect: %dx%d :: img min: %dx%d  max: %dx%d",rect->width,rect->height,img->minwidth,img->minheight,img->maxwidth,img->maxheight);
      if( img->minwidth<=rect->width&&
          img->minheight<=rect->height&&
          img->maxwidth>=rect->width&&
          img->maxheight>=rect->height)
      {
        debug_Trace();
        if(0==(format->img_putimage(img,win->handle,rect))) ret=0;
        debug_Trace();
      }
    }
  }

  debug_End();

  return((u32)ret);
}


u32 img_RenderImageTiled(u32 firsttag, ...)
{
  return(img_RenderImageTiledTL((tag *)&firsttag));
}
u32 img_RenderImageTiledTL(tag *taglist)
{
  Image_t *img;
  u8 *dest;
  int destsize;
  int imgwidth;
  int imgheight;
  int width;
  int height;

  int ret=-1;
  u8 *buf,*pnt,*from;
  int buflen,vn,hn,vp,hp,top,left=0,x,y,i,lastleft;
  Format_t *format;


  debug_Begin();

  img=(Image_t *)tag_GetTagData(taglist,TAG_IMG_OBJECT,0L);
  dest=(u8 *)tag_GetTagData(taglist,TAG_IMG_DEST,0L);
  destsize=(int )tag_GetTagData(taglist,TAG_IMG_DESTSIZE,0L);
  imgwidth=(int )tag_GetTagData(taglist,TAG_IMG_IMGWIDTH,0L);
  imgheight=(int )tag_GetTagData(taglist,TAG_IMG_IMGHEIGHT,0L);
  width=(int )tag_GetTagData(taglist,TAG_IMG_WIDTH,0L);
  height=(int )tag_GetTagData(taglist,TAG_IMG_HEIGHT,0L);

  ret=0;
  if(img!=NULL)
  {
    debug_Message("--id=%p",img);
    if(NULL!=(format=img->formatpnt))
    {
      if(img->minwidth<=imgwidth&&img->minheight<=imgheight&&img->maxwidth>=imgwidth&&img->maxheight>=imgheight)
      {
        buflen=imgwidth*imgheight*4;
        if(NULL!=(buf=mem_malloc(buflen)))
        {
          if(0==(format->img_render(img,buf,buflen,imgwidth,imgheight)))
          {
            memset(dest,0,destsize);
            hn=width/imgwidth;
            hp=width%imgwidth;
            vn=height/imgheight;
            vp=height%imgheight;
            for(top=y=0;y<vn;y++,top+=(width*4)*imgheight)
            {
              for(left=x=0;x<hn;x++,left+=imgwidth)
              {
                pnt=dest+((top)+left*4);
                from=buf;
                for(i=0;i<imgheight;i++,pnt+=width*4,from+=imgwidth*4)
                {
                  memcpy(pnt,from,imgwidth*4);
                }
              }
            }
            // a teljes kepek keszen vannak, jojjenek a hianyosak (elobb az also)
            lastleft=left;
            for(left=x=0;x<hn;x++,left+=imgwidth)
            {
              pnt=dest+((top)+left*4);
              from=buf;
              for(i=0;i<vp;i++,pnt+=width*4,from+=imgwidth*4)
              {
                memcpy(pnt,from,imgwidth*4);
              }
            }
            // aztan a jobb oldalon
            for(top=y=0,left=lastleft;y<vn;y++,top+=(width*4)*imgheight)
            {
              pnt=dest+((top)+left*4);
              from=buf;
              for(i=0;i<imgheight;i++,pnt+=width*4,from+=imgwidth*4)
              {
                memcpy(pnt,from,hp*4);
              }
            }
            // vegul az utolso a sarokban
            left=imgwidth*hn;
            top=((width*4)*imgheight)*vn;
            pnt=dest+((top)+left*4);
            from=buf;
            for(i=0;i<vp;i++,pnt+=width*4,from+=imgwidth*4)
            {
              memcpy(pnt,from,hp*4);
            }
          }
          mem_free(buf);
        }
      }
    }
  }

  debug_End();

  return((u32)ret);
}


u32 img_PutImageTiled(u32 firsttag, ...)
{
  return(img_PutImageTiledTL((tag *)&firsttag));
}
u32 img_PutImageTiledTL(tag *taglist)
{
  Image_t *img;
  Window_t *win;
  int imgwidth;
  int imgheight;
  Rect_t *rect;

  int ret=-1;
  Format_t *format;
  Vector_t dest;

  debug_Begin();

  img=(Image_t *)tag_GetTagData(taglist,TAG_IMG_OBJECT,0L);
  win=(Window_t *)tag_GetTagData(taglist,TAG_IMG_WINDOW,0L);
  imgwidth=(int )tag_GetTagData(taglist,TAG_IMG_IMGWIDTH,0L);
  imgheight=(int )tag_GetTagData(taglist,TAG_IMG_IMGHEIGHT,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_IMG_RECT,0L);

  if(img!=NULL&&NULL!=(format=img->formatpnt))
  {
    debug_Message("--id=%p",img);
    if(img->minwidth<=imgwidth&&img->minheight<=imgheight&&img->maxwidth>=imgwidth&&img->maxheight>=imgheight)
    {
      dest.size=rect->width*rect->height*4;
      if(NULL!=(dest.data=mem_malloc(dest.size)))
      {
        if(0==(img_RenderImageTiled(TAG_IMG_OBJECT,img,
                                    TAG_IMG_DEST,dest.data,
                                    TAG_IMG_DESTSIZE,dest.size,
                                    TAG_IMG_IMGWIDTH,imgwidth,
                                    TAG_IMG_IMGHEIGHT,imgheight,
                                    TAG_IMG_WIDTH,rect->width,
                                    TAG_IMG_HEIGHT,rect->height,
                                    TAG_DONE)))
        {
          ret=glw_PutImage(TAG_GLW_WINDOW,win->handle,TAG_GLW_PIXELS,&dest,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(dest.data);
      }
    }
  }

  debug_End();

  return((u32)ret);
}


u32 img_RegisterFormatCode(u32 firsttag, ...)
{
  return(img_RegisterFormatCodeTL((tag *)&firsttag));
}
u32 img_RegisterFormatCodeTL(tag *taglist)
{
  char *name;
  int (*img_init)(Image_t *,void (*)(void *),void *);
  int (*img_render)(Image_t *,u8 *,int,int,int);
  int (*img_putimage)(Image_t *,u32 window,Rect_t *);
  void (*img_clean)(Image_t *);
  void (*cleanup)(void);
  u32 module;

  int ret=-1;
  Format_t *format;
  Node_t *node;

  name=(char *)tag_GetTagData(taglist,TAG_IMG_NAME,0L);
  img_init=(int (*)(Image_t *,void (*)(void *),void *))tag_GetTagData(taglist,TAG_IMG_IMG_INIT,0L);
  img_render=(int (*)(Image_t *,u8 *,int,int,int))tag_GetTagData(taglist,TAG_IMG_IMG_RENDER,0L);
  img_putimage=(int (*)(Image_t *,u32 window,Rect_t *))tag_GetTagData(taglist,TAG_IMG_IMG_PUTIMAGE,0L);
  img_clean=(void (*)(Image_t *))tag_GetTagData(taglist,TAG_IMG_IMG_CLEAN,0L);
  cleanup=(void (*)(void))tag_GetTagData(taglist,TAG_IMG_CLEANUP,0L);
  module=(u32)tag_GetTagData(taglist,TAG_IMG_MODULE,0L);

  debug_Begin();

  if(name!=NULL&&img_init!=NULL&&img_render!=NULL&&img_putimage!=NULL&&img_clean!=NULL)
  {
    for(node=list_GetNodeHead(FormatList);node!=NULL;node=list_GetNodeNext(FormatList,node))
    {
      if(NULL!=(format=(Format_t *)list_GetNodeData(node)))
      {
        if(strcmp(format->name,name)==0)
        {
          format->status=IMG_FS_LOADED;
          format->img_init=img_init;
          format->img_clean=img_clean;
          format->img_render=img_render;
          format->img_putimage=img_putimage;
          format->cleanup=cleanup;
          format->mainmodule=module;
          ret=0;
        }
      }
    }
  }

  debug_End();

  return((u32)ret);
}


u32 img_RegisterFormat(u32 firsttag, ...)
{
  return(img_RegisterFormatTL((tag *)&firsttag));
}
u32 img_RegisterFormatTL(tag *taglist)
{
  char *name;
  int (*img_recognize)(u8 *,int);
  u32 module;

  int ret=-1;
  Format_t *format;
  Node_t *node;

  name=(char *)tag_GetTagData(taglist,TAG_IMG_NAME,0L);
  img_recognize=(int (*)(u8 *,int))tag_GetTagData(taglist,TAG_IMG_IMG_RECOGNIZE,0L);
  module=(u32)tag_GetTagData(taglist,TAG_IMG_MODULE,0L);

  debug_Begin();

  if(img_recognize!=NULL&&NULL!=(format=mem_malloc(sizeof(Format_t))))
  {
    if(NULL!=(node=list_CreateNode()))
    {
      format->status=IMG_FS_RECOG;
      format->name=name;
      format->counter=0;
      format->img_recognize=img_recognize;
      format->module=module;
      format->mainmodule=0L;
      list_SetNodeData(node,format);
      list_InsertNodeTail(FormatList,node);
      ret=0;
    }
  }

  debug_End();

  return((u32)ret);
}


void img_CleanUp(void)
{
  Node_t *node;
  Format_t *format;

  debug_Begin();

  if(FormatList!=NULL)
  {
    for(node=list_GetNodeHead(FormatList);node!=NULL;node=list_GetNodeHead(FormatList))
    {
      list_RemoveNode(FormatList,node);
      if(NULL!=(format=(Format_t *)list_GetNodeData(node)))
      {
        debug_Message("free format: '%s'",format->name);
        list_DeleteNode(node);
        debug_Trace();
        if(format->status==IMG_FS_LOADED)
        {
          if(format->cleanup!=NULL) format->cleanup();
          debug_Trace();
          glw_CloseModule(format->mainmodule);
          debug_Trace();
        }
        glw_CloseModule(format->module);
        debug_Trace();
        mem_free(format);
        debug_Message("format free finished.");
      }
    }
    list_DeleteList(FormatList);
  }
  FormatList=NULL;

  debug_End();
}


int img_Init(void)
{
  int ret=0;
  glw_Dir_t *dir;

  debug_Begin();

  call_vector[IMG_INITIMAGE-IMG_FUNCBASE]=img_InitImageTL;
  call_vector[IMG_RENDERIMAGE-IMG_FUNCBASE]=img_RenderImageTL;
  call_vector[IMG_PUTIMAGE-IMG_FUNCBASE]=img_PutImageTL;
  call_vector[IMG_RENDERIMAGETILED-IMG_FUNCBASE]=img_RenderImageTiledTL;
  call_vector[IMG_PUTIMAGETILED-IMG_FUNCBASE]=img_PutImageTiledTL;
  call_vector[IMG_CLEANUPIMAGE-IMG_FUNCBASE]=img_CleanUpImageTL;
  call_vector[IMG_GETINFO-IMG_FUNCBASE]=img_GetInfoTL;
  call_vector[IMG_REGISTERFORMAT-IMG_FUNCBASE]=img_RegisterFormatTL;
  call_vector[IMG_REGISTERFORMATCODE-IMG_FUNCBASE]=img_RegisterFormatCodeTL;
  bases_modules.img_Call=img_Call;
  bases_modules.img_CallTL=img_CallTL;

  if(NULL!=(FormatList=list_CreateList()))
  {
    /*
     *  Ide majd kell egy kis rutin, ami a module directory-bol (dir a prefsbol)
     *  kiolvassa (glw+=dir olvaso fuggvenyek!) az osszes file-t aminek *.image_id
     *  a neve es mindre meghivja az OpenModule()-t.
     */
    if(0L!=(dir=glw_DirOpen("images")))
    {
      char *fname=NULL,*mname=NULL;
      for(fname=glw_DirNext(dir);fname!=NULL;fname=glw_DirNext(dir))
      {
        debug_Message("New module found: '%s'",fname);
        if(strstr(fname,".image_id")!=NULL)
        {
          if(NULL!=(mname=mem_malloc(strlen(fname)+1+7)))
          {
            strcpy(mname,"images/");
            strcat(mname,fname);
            debug_Message("  Load it! '%s'",mname);
            glw_OpenModule(mname);
            mem_free(mname);
          }
        }
        mem_free(fname);
        fname=NULL;
      }
      glw_DirClose(dir);
    }
  }

  debug_End();

  return(ret);
}


u32 img_Call(int function, u32 firsttag, ...)
{
  return(img_CallTL(function,(tag *)&firsttag));
}
u32 img_CallTL(int function, tag *taglist)
{
  u32 ret=~0L;

  debug_Begin();

  debug_Message("function ID : %d",function-IMG_FUNCBASE);

  if(function>=IMG_FUNCBASE&&function<IMG_FUNC_DONE)
  {
    ret=call_vector[function-IMG_FUNCBASE](taglist);
  }
  else debug_Warning("%s(): Function code out of range! code=0x%04x",__FUNCTION__,function);


  debug_End();

  return(ret);
}

---