---

image_Flash_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 <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
#include <setjmp.h>

#include <assert.h>
#include <limits.h>
#include <time.h>

#define __IMAGE_MODULE

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

#ifndef __CYGWIN__
struct timezone {
  int tz_minuteswest;
  int tz_dsttime;
};

struct timeval {
    long    tv_sec;
    long    tv_usec;
};
#endif

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

#include <jpeglib.h>


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


int gettimeofday(struct timeval *tv, struct timezone *tz)
{
  struct glw_Time tm;

  api->glw_Call(GLW_GETTIME,TAG_GLW_TM,&tm,TAG_DONE);
  tv->tv_sec=tm.secs;
  tv->tv_usec=tm.millis;
  return(0);
}

/*
void __assert(int exp)
{
}
int setjmp(jmp_buf jb)
{
  return(0);
}
*/

#include "images/image_Flash.h"
#include <flash.h>


typedef struct flash_CustomData_s
{
  Image_t *img;
} flash_CustomData_t;


//static void getSwf(char *url, int level, void *client_data) {}
//static void showUrl(char *url, char *target, void *client_data) {}



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

  if(img!=NULL)
  {
    if(img->iim.data[0]=='F'&&img->iim.data[1]=='W'&&img->iim.data[2]=='S')
    {
      if(NULL!=(cdata=mem_malloc(sizeof(flash_CustomData_t))))
      {
        img->formatdata=cdata;
        cdata->img=img;
        img->minwidth=8;
        img->minheight=8;
        img->maxwidth=IMAGE_MAXIMUM_SIZE;
        img->maxheight=IMAGE_MAXIMUM_SIZE;
        ret=0;
      }
    }
  }

  return(ret);
}


static void flash_ImgCleanUp(Image_t *img)
{
  flash_CustomData_t *cdata;

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


// a dest memoriat a hivo prezentalja destsize
// meretben, ha kicsi, hiba (-1)
// a rendereles 32bitesen tortenik, az atlatszo
// pixelek helyere 0xffffffff kerul
static int flash_ImgRender(Image_t *img, u8 *dest, int destsize, int width, int height)
{
  int ret=-1;
  int i,j,mx;
    FlashHandle flashHandle;
//  struct FlashInfo fi;
  FlashDisplay fd;
//  FlashEvent fe;
  struct timeval wd;
  long cmd;
  long wakeUp;
//  long delay=0, z=1;

  if(img!=NULL&&img->formatdata!=NULL&&dest!=NULL&&destsize>=(width*height*4)&&
    width>=img->minwidth&&height>=img->minheight&&
    width<=img->maxwidth&&height<=img->maxheight)
  {
    if(0!=(flashHandle=FlashNew()))
    {
        FlashParse(flashHandle,0,(char *)img->iim.data,(long)img->iim.data_size);
//      FlashGetInfo(flashHandle,&fi);
        fd.pixels=(char *)dest;
      fd.width=width;
      fd.height=height;
      fd.bpl=width*4;                // bytes/line
      fd.depth=32;
      fd.bpp=4;                     // bytes_per_pixel
      FlashSettings(flashHandle, PLAYER_LOOP);
      FlashGraphicInit(flashHandle,&fd);
//      FlashSetGetUrlMethod(flashHandle,showUrl,0L);
//      FlashSetGetSwfMethod(flashHandle,getSwf,0L);
      cmd=FLASH_WAKEUP;
      wakeUp=FlashExec(flashHandle,cmd,0,&wd);


      mx=width*height;
      for(i=j=0;i<mx;i++,j+=4)
      {

        dest[j+3]=dest[j];
        dest[j+2]=dest[j+1];
        dest[j+1]=dest[j+2];
        dest[j]=0;
      }

//      fe.type=FeRefresh;
//      FlashExec(flashHandle,FLASH_EVENT,&fe,&wd);
      ret=0;
/*
        while(1)
        {
          if(delay<0) delay=20;
          if(fd.flash_refresh)
          {
              // copy 0,0,fd.width,fd.height (SOURCE: fd.pixels) TO SCREEN
              fd.flash_refresh=0;
          }
          if(wakeUp)
          {
            // wait delay millisecs
          }
          // zoom
          //FlashZoom(flashHandle,z);

          // when refresh needed:
          fe.type=FeRefresh;
          FlashExec(flashHandle,FLASH_EVENT,&fe,&wd);

          // default:
          fe.type=FeNone;
          FlashExec(flashHandle,FLASH_EVENT,&fe,&wd);

        // new delay calc
        gettimeofday(&now,0);
        delay=(wd.tv_sec-now.tv_sec)*1000+(wd.tv_usec-now.tv_usec)/1000;
      }
*/
        FlashClose(flashHandle);
    }
  }

  return(ret);
}


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

  buff.size=(rect->width*rect->height*4)+1;
  if(NULL!=(buff.data=mem_malloc(buff.size)))
  {
    if(0==(flash_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);
  }
  return(0);
}


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


static int flash_Init(u32 module)
{
  int ret=-1;
  ret=api->img_Call(IMG_REGISTERFORMATCODE,
                TAG_IMG_NAME,(u32)"flash",
                TAG_IMG_IMG_INIT,(u32)flash_ImgInit,
                TAG_IMG_IMG_RENDER,(u32)flash_ImgRender,
                TAG_IMG_IMG_PUTIMAGE,(u32)flash_PutImage,
                TAG_IMG_IMG_CLEAN,(u32)flash_ImgCleanUp,
                TAG_IMG_CLEANUP,(u32)flash_CleanUp,
                TAG_IMG_MODULE,module,
                TAG_DONE);
  return(ret);
}

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

---