[efl-upgrade]
authorJeahwan Kim <jae.hwan.kim@samsung.com>
Fri, 10 Sep 2010 10:47:12 +0000 (19:47 +0900)
committerJeahwan Kim <jae.hwan.kim@samsung.com>
Fri, 10 Sep 2010 10:47:12 +0000 (19:47 +0900)
Merge with EFL svn repo

Merge branch 'svn_merge'

Conflicts:
src/lib/canvas/evas_object_textblock.c
src/lib/engines/common/evas_font_draw.c
src/lib/engines/common/evas_image_load.c
src/modules/engines/gl_x11/evas_engine.c
src/modules/engines/gl_x11/evas_x_main.c
src/modules/loaders/bmp/evas_image_load_bmp.c

15 files changed:
1  2 
configure.ac
debian/changelog
debian/control
m4/evas_check_loader.m4
src/lib/canvas/evas_object_textblock.c
src/lib/engines/common/evas_image_load.c
src/lib/engines/common/evas_op_blend/op_blend_mask_color_neon.c
src/lib/file/evas_module.c
src/modules/engines/gl_x11/evas_engine.c
src/modules/engines/gl_x11/evas_x_main.c
src/modules/loaders/bmp/evas_image_load_bmp.c
src/modules/loaders/gif/evas_image_load_gif.c
src/modules/loaders/jpeg/evas_image_load_jpeg.c
src/modules/loaders/png/evas_image_load_png.c
src/modules/loaders/wbmp/evas_image_load_wbmp.c

diff --cc configure.ac
index be700f2,dbd6cde..f50175a
mode 100755,100644..100755
@@@ -229,20 -232,8 +233,20 @@@ PKG_CHECK_MODULES([EINA], [eina >= 1.0.
  # Freetype
  PKG_CHECK_MODULES([FREETYPE], [freetype2 >= 9.3.0])
  
- requirement_evas="freetype2 eina-0 ${requirement_evas}"
+ requirement_evas="freetype2 eina >= 1.0.0 ${requirement_evas}"
  
 +#WinkCodec
 +AC_ARG_ENABLE([winkcodec],
 +              AS_HELP_STRING([--enable-winkcodec],
 +                      [enable/disable wink codec (default: no)]),
 +              [WINK=$enableval], [WINK=no])
 +
 +#if test "x${WINK}" = "xyes" ; then
 +#     PKG_CHECK_MODULES([LIBWINK],[wink])
 +#     AC_DEFINE(USE_WINK_CODEC, 1, [use wink codec])
 +#     requirement_evas="wink ${requirement_evas}"
 +#fi
 +
  ## optional dependencies
  
  # FontConfig
index 9643729,0000000..ee74a86
mode 100644,000000..100644
--- /dev/null
@@@ -1,412 -1,0 +1,420 @@@
++evas (1.0.0.001+svn.51480slp2+build01) unstable; urgency=low
++
++  * efl 1.0 alpha upgrade
++  * Git: 165.213.180.234:/git/slp/pkgs/evas
++  * Tag: evas_1.0.0.001+svn.51480slp2+build01
++
++ -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Tue, 31 Aug 2010 22:42:34 +0900
++
 +evas (0.9.9.060+svn.49540slp2+3build19) unstable; urgency=low
 +
 +  * Disabled word cache.
 +  * Git: 165.213.180.234:/git/slp/pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build19
 +
 + -- Juyung Seo <juyung.seo@samsung.com>  Wed, 25 Aug 2010 08:51:38 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build18) unstable; urgency=low
 +
 +  * Fixed segfault problem with GL engine when rotating.
 +  * Git: 165.213.180.234:/git/slp/pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build18
 +
 + -- Sangjin Lee <lsj119@samsung.com>  Fri, 30 Jul 2010 22:51:48 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build17) unstable; urgency=low
 +
 +  * Fixed segfault problem with GL engine when rotating.
 +  * Git: 165.213.180.234:/git/slp/pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build17
 +
 + -- Gwanglim Lee <gl77.lee@samsung.com>  Fri, 30 Jul 2010 22:27:37 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build16) unstable; urgency=low
 +
 +  * Fixed segfault problem with GL engine when rotating.
 +  * Git: 165.213.180.234:/git/slp/pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build16
 +
 + -- Gwanglim Lee <gl77.lee@samsung.com>  Fri, 30 Jul 2010 21:21:34 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build15) unstable; urgency=low
 +
 +  * Fixed word cache & gl bug (from Brett Nash)
 +  * Git: 165.213.180.234:/git/slp/pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build15
 +
 + -- Juyung Seo <juyung.seo@samsung.com>  Fri, 30 Jul 2010 14:16:57 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build14) unstable; urgency=low
 +
 +  * Disabled word cache 
 +  * Git: 165.213.180.234:/git/slp/pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build14
 +
 + -- ChunEon Park <chuneon.park@samsung.com>  Fri, 30 Jul 2010 11:42:47 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build13) unstable; urgency=low
 +
 +  * [word cache] Disabled again. 
 +  * Git: 165.213.180.234:/git/slp/pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build13
 +
 + -- ChunEon Park <chuneon.park@samsung.com>  Thu, 29 Jul 2010 20:27:09 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build12) unstable; urgency=low
 +
 +  * [word cache] Enabled word cache only not metric cache.
 +  * Git: 165.213.180.234:/git/slp/pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build12
 +
 + -- Juyung Seo <juyung.seo@samsung.com>  Wed, 28 Jul 2010 18:21:38 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build11) unstable; urgency=low
 +
 +  * [word cache & metric cache] Disabled word cache & metric cache.
 +  * Git: 165.213.180.234:/git/slp/pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build11
 +
 + -- Juyung Seo <juyung.seo@samsung.com>  Wed, 28 Jul 2010 18:10:37 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build10) unstable; urgency=low
 +
 +  * [Neon&WordCache] Added wordcache and neon features.
 +  * [rotation] 90 degree rotation with neon bug is fixed.
 +  * Git: 165.213.180.234:/git/slp/pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build10
 +
 + -- Juyung Seo <juyung.seo@samsung.com>  Wed, 28 Jul 2010 14:01:06 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build09) unstable; urgency=low
 +
 +  * Modified no_swap codes in order to ensure the correct screen appearance.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL-pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build09
 +
 + -- ChunEon Park <chuneon.park@samsung.com>  Wed, 07 Jul 2010 20:07:28 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build08) unstable; urgency=low
 +
 +  * Modified no_swap codes in order to ensure the correct screen appearance.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL-pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build08
 +
 + -- Gwanglim Lee <gl77.lee@samsung.com>  Fri, 02 Jul 2010 13:55:18 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build07) unstable; urgency=low
 +
 +  * add no_swap info to GLES engine for supporting lock/unlock feature.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL-pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build07
 +
 + -- Gwanglim Lee <gl77.lee@samsung.com>  Tue, 29 Jun 2010 18:47:33 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build06) unstable; urgency=low
 +
 +  * rev 49790 partial update to resolve rotation bug when using GLES backend.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL-pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build06
 +
 + -- Gwanglim Lee <gl77.lee@samsung.com>  Tue, 22 Jun 2010 16:38:28 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build05) unstable; urgency=low
 +
 +  * Neonize on.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL-pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build05
 +
 + -- Daniel Juyung Seo <juyung.seo@samsung.com>  Mon, 14 Jun 2010 14:51:16 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build04) unstable; urgency=low
 +
 +  * Packaging.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL-pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build04
 +
 + -- Daniel Juyung Seo <juyung.seo@samsung.com>  Thu, 10 Jun 2010 21:09:50 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build03) unstable; urgency=low
 +
 +  * Packaging.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL-pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build03
 +
 + -- Daniel Juyung Seo <juyung.seo@samsung.com>  Thu, 10 Jun 2010 21:04:35 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3build02) unstable; urgency=low
 +
 +  * Packaging.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL-pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3build02
 +
 + -- Daniel Juyung Seo <juyung.seo@samsung.com>  목, 10  6월 2010 21:00:53 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+3) unstable; urgency=low
 +
 +  * Packaging.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL-pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+3
 +
 + -- Daniel Juyung Seo <juyung.seo@samsung.com>  Thu, 10 Jun 2010 20:46:54 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+2) unstable; urgency=low
 +
 +  * Packaging.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL-pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+2
 +
 + -- Daniel Juyung Seo <juyung.seo@samsung.net>  Thu, 10 Jun 2010 20:46:08 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+1) unstable; urgency=low
 +
 +  * Packaging.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL-pkgs/evas
 +  * Tag: evas_0.9.9.060+svn.49540slp2+1
 +
 + -- Daniel Juyung Seo <juyung.seo@samsung.com>  Thu, 10 Jun 2010 20:35:05 +0900
 +
 +evas (0.9.9.060+svn.49540slp2+0) unstable; urgency=low
 +
 +  * Update opensource EFL from SVN
 +  * SVN revision: 49540 (Total EFL revision: 49550)
 +  * Tag: evas_0.9.9.060+svn.49540slp2+0
 +
 + -- Daniel Juyung Seo <juyung.seo@samsung.com>  Thu, 10 Jun 2010 15:50:44 +0900
 +
 +evas (0.9.9.060+svn20100304slp2+7) unstable; urgency=low
 +
 +  * Implemented bmp and wbmp image loader module without 3rd party codec.
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL
 +  * Tag: evas_0.9.9.060+svn20100304slp2+7
 +
 + -- YoungHoon Jung <yhoon.jung@samsung.com>  Wed, 21 Apr 2010 17:09:32 +0900
 +
 +evas (0.9.9.060+svn20100304slp2+6) unstable; urgency=low
 +
 +  * Bug fix - evas textblock cursor problem
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL
 +  * Tag: evas_0.9.9.060+svn20100304slp2+6
 +
 + -- Myungjae Lee <mjae.lee@samsung.com>  Thu, 16 Apr 2010 20:53:00 +0900
 +
 +evas (0.9.9.060+svn20100304slp2+5) unstable; urgency=low
 +
 +  * Rollback entry cursor bug fix
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL
 +  * Tag: evas_0.9.9.060+svn20100304slp2+5
 +
 + -- Myungjae Lee <mjae.lee@samsung.com>  Thu, 16 Apr 2010 11:28:00 +0900
 +
 +evas (0.9.9.060+svn20100304slp2+4) unstable; urgency=low
 +
 +  * Updated package version due to tag
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL
 +  * Tag: evas_0.9.9.060+svn20100304slp2+4
 +
 + -- Myungjae Lee <mjae.lee@samsung.com>  Thu, 15 Apr 2010 20:37:00 +0900
 +
 +evas (0.9.9.060+svn20100304slp2+3) unstable; urgency=low
 +
 +  * Bug fix - evas textblock cursor problem
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL
 +  * Tag: evas_0.9.9.060+svn20100304slp2+3
 +
 + -- Myungjae Lee <mjae.lee@samsung.com>  Thu, 15 Apr 2010 19:57:00 +0900
 +
 +evas (0.9.9.060+svn20100304slp2+2) unstable; urgency=low
 +
 +  * change control - add libfribidi-dev, libharfbuzz-dev
 +  * Git: 165.213.180.234:/git/slp2.0/slp2.0-pkgs/EFL
 +  * Tag: evas_0.9.9.060+svn20100304slp2+2
 +
 + -- Jihoon Kim <jihoon48.kim@samsung.com>  Wed, 07 Apr 2010 17:15:28 +0900
 +
 +evas (0.9.9.060+svn20100304slp2+1) unstable; urgency=low
 +
 +  * change package version
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Thu, 25 Mar 2010 15:06:27 +0900
 +
 +evas (0.9.9.060+svn20100304-8) unstable; urgency=low
 +
 +  * added dependencies to libevas-dev.
 +
 + -- YoungHoon Jung <yhoon.jung@samsung.com>  Wed, 24 Mar 2010 11:19:14 +0900
 +
 +evas (0.9.9.060+svn20100304-7) unstable; urgency=low
 +
 +  * Remove fribidi, haffbuzz from evas 
 +
 + -- Jihoon Kim <jihoon48.kim@samsung.com>  Wed, 24 Mar 2010 11:32:22 +0900
 +
 +evas (0.9.9.060+svn20100304-6) unstable; urgency=low
 +
 +  * Clean up GLES/EGL stubs on EGL window surface gone.
 +   + based on r47461, r47362 and r47386.
 +    (upon a request from Gwanglim Lee<gl77.lee@samsung.com>)
 +
 + -- YoungHoon Jung <yhoon.jung@samsung.com>  Tue, 23 Mar 2010 20:38:02 +0900
 +
 +evas (0.9.9.060+svn20100304-5) unstable; urgency=low
 +
 +  * patched evas_wink.h and minor modifications.
 +
 + -- YoungHoon Jung <yhoon.jung@samsung.com>  Tue, 23 Mar 2010 16:19:47 +0900
 +
 +evas (0.9.9.060+svn20100304-4) unstable; urgency=low
 +
 +  * Change control file. (Add dependencies for harfbuzz, fribidi)
 +
 + -- Doyoun Kang <doyoun.kang@samsung.com>  Tue, 23 Mar 2010 15:12:52 +0900
 +
 +evas (0.9.9.060+svn20100304-3) unstable; urgency=low
 +
 +  * disabled wink codec for PNG, JPG, and GIF.
 +
 + -- YoungHoon Jung <yhoon.jung@samsung.com>  Mon, 22 Mar 2010 16:09:40 +0900
 +
 +evas (0.9.9.060+svn20100304-2) unstable; urgency=low
 +
 +  * implemented PNG/BMP/WBMP/JPEG/GIF image loaders using Wink Codec
 +
 + -- YoungHoon Jung <yhoon.jung@samsung.com>  Thu, 18 Mar 2010 13:52:18 +0900
 +
 +evas (0.9.9.060+svn20100304-1) unstable; urgency=low
 +
 +  * EFL_update_revision_46864
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Wed, 10 Mar 2010 16:06:34 +0900
 +
 +evas (0.9.9.060+svn20100203-8) unstable; urgency=low
 +
 +  * revision up to 46421 (Full merge)
 +
 + -- Sangjin Lee <lsj119@samsung.com>  Thu, 25 Feb 2010 19:29:30 +0900
 +
 +evas (0.9.9.060+svn20100203-7) unstable; urgency=low
 +
 +  * revision up to 46263 (partial merge)
 +
 + -- Doyoun Kang <doyoun.kang@samsung.com>  Thu, 18 Feb 2010 19:27:04 +0900
 +
 +evas (0.9.9.060+svn20100203-6) unstable; urgency=low
 +
 +  * revision up to 45829
 +
 + -- wonguk.jeong <wonguk.jeong@samsung.com>  Fri, 05 Feb 2010 20:52:34 +0900
 +
 +evas (0.9.9.060+svn20100203-5) unstable; urgency=low
 +
 +  * repack
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Thu, 04 Feb 2010 20:24:23 +0900
 +
 +evas (0.9.9.060+svn20100203-4) unstable; urgency=low
 +
 +  * force revision for i386
 +
 + -- sangho park <sangho.g.park@samsung.com>  Thu, 04 Feb 2010 18:54:47 +0900
 +
 +evas (0.9.9.060+svn20100203-3) unstable; urgency=low
 +
 +  * reupload
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Thu, 04 Feb 2010 11:27:11 +0900
 +
 +evas (0.9.9.060+svn20100203-2) unstable; urgency=low
 +
 +  * reupload
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Thu, 04 Feb 2010 05:45:58 +0900
 +
 +evas (0.9.9.060+svn20100203-1) unstable; urgency=low
 +
 +  * EFL_update_revision_45828
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Wed, 03 Feb 2010 16:39:20 +0900
 +
 +evas (0.9.9.060+svn20100119-1) unstable; urgency=low
 +
 +  * EFL_update_revision_45322
 +
 + -- Jihoon Kim <jihoon48.kim@samsung.com>  Tue, 19 Jan 2010 20:44:46 +0900
 +
 +evas (0.9.9.060+svn20100111-5) unstable; urgency=low
 +
 +  * Change required GLES deb package to opengl-es metapackage
 +
 + -- Gwanglim Lee <gl77.lee@samsung.com>  Thu, 14 Jan 2010 19:15:22 +0900
 +
 +evas (0.9.9.060+svn20100111-4) unstable; urgency=low
 +
 +  * libpng12 dependency add
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Tue, 12 Jan 2010 21:01:14 +0900
 +
 +evas (0.9.9.060+svn20100111-3) unstable; urgency=low
 +
 +  * reupload EFL i686
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Tue, 12 Jan 2010 17:35:26 +0900
 +
 +evas (0.9.9.060+svn20100111-2) unstable; urgency=low
 +
 +  * reupload EFL
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Mon, 11 Jan 2010 22:16:31 +0900
 +
 +evas (0.9.9.060+svn20100111-1) unstable; urgency=low
 +
 +  * update EFL revision 45026
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Mon, 11 Jan 2010 13:28:03 +0900
 +
 +evas (0.9.9.060+svn20091229-3) unstable; urgency=low
 +
 +  * Patch for i386 build (exclude opengl-es)
 +
 + -- Youmin Ha <youmin.ha@samsung.com>  Thu, 07 Jan 2010 21:28:44 +0900
 +
 +evas (0.9.9.060+svn20091229-2) unstable; urgency=low
 +
 +  * add depends (opengl-es-sgx540)
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Wed, 30 Dec 2009 19:31:45 +0900
 +
 +evas (0.9.9.060+svn20091229-1) unstable; urgency=low
 +
 +  * update EFL
 +
 + -- Jaehwan Kim <jae.hwan.kim@samsung.com>  Tue, 29 Dec 2009 14:27:02 +0900
 +
 +evas (0.9.9.060+svn20091112-3) unstable; urgency=low
 +
 +  * modify architecture value from all to any 
 +
 + -- Sangho Park <sangho.g.park@sangho.g.park>  Fri, 27 Nov 2009 15:39:53 +0900
 +
 +evas (0.9.9.060+svn20091112-2) unstable; urgency=low
 +
 +  * svn stable version
 +
 + -- Sangho Park <sangho.g.park@sangho.g.park>  Thu, 19 Nov 2009 17:39:02 +0900
 +
 +evas (0.9.9.060+svn20091112-1) unstable; urgency=low
 +
 +  * Clean up changelog
 +
 + -- Sangho Park <sangho.g.park@sangho.g.park>  Thu, 12 Nov 2009 23:27:21 +0100
 +
 +evas (0.9.9.060+svnYYYYMMDD-1) unstable; urgency=low
 +
 +  * Clean up changelog
 +
 + -- quaker <quaker66@gmail.com>  Thu, 22 Apr 2009 18:27:21 +0100
 +
 +evas (0.9.9.050+svnYYYYMMDD-1) unstable; urgency=low
 +
 +  * Clean up changelog
 +
 + -- quaker <quaker66@gmail.com>  Tue, 21 Apr 2009 19:13:59 +0100
diff --cc debian/control
index e0afbf8,0000000..ae71599
mode 100755,000000..100755
--- /dev/null
@@@ -1,109 -1,0 +1,109 @@@
- Package: libevas-svn-01
 +Source: evas
 +Section: libs
 +Priority: optional
 +Maintainer: Jaehwan Kim <jae.hwan.kim@samsung.com>, Jihoon Kim <jihoon48.kim@samsung.com>, wonguk jeong <wonguk.jeong@samsung.com>, Sangjin Lee <lsj119@samsung.com>, Doyoun Kang <doyoun.kang@samsung.com>, YoungHoon Jung <yhoon.jung@samsung.com>, Myungjae Lee <mjae.lee@samsung.com>, Juyung Seo <juyung.seo@samsung.com>, Gwanglim Lee <gl77.lee@samsung.com>
 +Original-Maintainer:  Debian Pkg-e Team <pkg-e-devel@lists.alioth.debian.org>
 +Uploaders: Albin Tonnerre <albin.tonnerre@gmail.com>,
 + Niv Sardi <xaiki@debian.org>, Xavier Oswald <x.oswald@free.fr>,
 + Jan Lübbe <jluebbe@debian.org>,
 + Nikita V. Youshchenko <yoush@debian.org>,
 + ChunEon Park <chuneon.park@samsung.com>
 +Build-Depends: debhelper (>= 6), cdbs, libeet-dev (>= 1.1.0), libeina-dev (>= 0.0.2.060+svn20100304),
 + libfreetype6-dev, libpng12-dev | libpng-dev, libx11-dev, libxrender-dev,
 + x11proto-xext-dev, zlib1g, libjpeg7-dev,
 + libfontconfig1-dev, libxpm-dev,
 + doxygen, pkg-config, libtool, libxext-dev, opengl-es-dev, libfribidi-dev, libharfbuzz-dev,
 + libgif-dev
 +Standards-Version: 3.8.1
 +Homepage: http://www.enlightenment.org
 +
- Provides: libevas0
- Conflicts: libevas0
++Package: libevas
 +Architecture: any
 +Depends: ${shlibs:Depends}, ${misc:Depends}, libevas-engines (>= 0.9.9.060+svn20100304), libpng12-0
- Depends: ${misc:Depends}, libevas-svn-01 (= ${binary:Version}), libjpeg7-dev, libx11-dev,
++Provides: libevas
++Conflicts: libevas
 +Description: Enlightenment DR17 advanced canvas library
 + Evas is an advanced canvas library, providing six engines for rendering: X11,
 + OpenGL (hardware accelerated), DirectFB, the framebuffer, Microsoft Windows
 + and Qtopia.
 + .
 + Due to its simple API, evas can be developed with rapidly, and cleanly.
 + .
 + This package contains the core library and a set of image loaders and/or savers
 + for various formats: eet, gif, jpeg, png, svg, tiff, bmp, wbmp and xpm
 +
 +Package: libevas-doc
 +Architecture: any
 +Section: doc
 +Depends: ${misc:Depends}
 +Enhances: libevas-dev
 +Description: Evas API Documentation
 + Evas is an advanced canvas library, providing six engines for rendering: X11,
 + OpenGL (hardware accelerated), DirectFB, the framebuffer, Microsoft Windows
 + and Qtopia.
 + Due to its simple API, evas can be developed with rapidly, and cleanly.
 + .
 + This package provides development documentation (html and manpages) for the
 + Evas library.
 +
 +Package: libevas-dev
 +Section: libdevel
 +Architecture: any
- Depends: ${misc:Depends}, libevas-svn-01 (= ${binary:Version})
++Depends: ${misc:Depends}, libevas (= ${binary:Version}), libjpeg7-dev, libx11-dev,
 + libfreetype6-dev, libfontconfig1-dev, libeet-dev, pkg-config, libeina-dev (>= 0.0.2.060+svn20100304), libxext-dev, libpng12-dev, libfribidi-dev, libharfbuzz-dev,
 + libgif-dev
 +Suggests: libevas-doc
 +Description: Enlightenment DR17 advanced canvas library development files
 + Evas is an advanced canvas library, providing six engines for rendering: X11,
 + OpenGL (hardware accelerated), DirectFB, the framebuffer, Microsoft Windows
 + and Qtopia.
 + .
 + Due to its simple API, evas can be developed with rapidly, and cleanly.
 + .
 + This package provides headers and static libraries required to develop against
 + evas.
 +
 +Package: libevas-dbg
 +Architecture: any
 +Section: debug
++Depends: ${misc:Depends}, libevas (= ${binary:Version})
 +Priority: extra
 +Description: enlightenment advanced canvas library
 + Evas is an advanced canvas library, providing six engines for rendering: X11,
 + OpenGL (hardware accelerated), DirectFB, the framebuffer, Microsoft Windows
 + and Qtopia.
 + .
 + This package contains unstripped shared libraries. It is provided primarily
 + to provide a backtrace with names in a debugger, this makes it somewhat
 + easier to interpret core dumps. The libraries are installed in
 + /usr/lib/debug and are automatically used by gdb.
 +
 +Package: libevas-engines
 +Architecture: any
 +Depends: ${shlibs:Depends}, ${misc:Depends}
 +Conflicts: libevas-0.9.9.050a-engines
 +Description: Evas module providingg the framebuffer render engine
 + Evas is an advanced canvas library, providing six engines for rendering: X11,
 + OpenGL (hardware accelerated), DirectFB, the framebuffer, Microsoft Windows
 + and Qtopia.
 + Due to its simple API, evas can be developed with rapidly, and cleanly.
 + .
 + This package contains the following Evas engine modules:
 +  - buffer
 +  - software/genenric
 +  - software/X11
 +  - xrender/X11
 +
 +Package: libevas-engines-extras
 +Architecture: any
 +Depends: ${shlibs:Depends}, ${misc:Depends}, libevas-engines, opengl-es
 +Conflicts: libevas-0.9.9.050a-engines-extras
 +Description: Evas module providing the Xrender engine
 + Evas is an advanced canvas library, providing six engines for rendering: X11,
 + OpenGL (hardware accelerated), DirectFB, the framebuffer, Microsoft Windows
 + and Qtopia.
 + Due to its simple API, evas can be developed with rapidly, and cleanly.
 + .
 + This package contains some extra Evas engine modules:
 +  - GL/X11
 +  - Framebuffer
@@@ -788,43 -1052,54 +1053,86 @@@ static const char *linerelsizestr = NUL
  static const char *linegapstr = NULL;
  static const char *linerelgapstr = NULL;
  static const char *itemstr = NULL;
 +static const char *visible = NULL;
+ static const char *linefillstr = NULL;
  
+ /**
+  * @internal
+  * Init the format strings.
+  */
  static void
  _format_command_init(void)
  {
-    if (fontstr) return;
++  /* if (fontstr) return;
 +   fontstr = eina_stringshare_add("font");
 +   font_fallbacksstr = eina_stringshare_add("font_fallbacks");
 +   font_sizestr = eina_stringshare_add("font_size");
 +   font_sourcestr = eina_stringshare_add("font_source");
 +   colorstr = eina_stringshare_add("color");
 +   underline_colorstr = eina_stringshare_add("underline_color");
 +   underline2_colorstr = eina_stringshare_add("underline2_color");
 +   outline_colorstr = eina_stringshare_add("outline_color");
 +   shadow_colorstr = eina_stringshare_add("shadow_color");
 +   glow_colorstr = eina_stringshare_add("glow_color");
 +   glow2_colorstr = eina_stringshare_add("glow2_color");
 +   backing_colorstr = eina_stringshare_add("backing_color");
 +   strikethrough_colorstr = eina_stringshare_add("strikethrough_color");
 +   alignstr = eina_stringshare_add("align");
 +   valignstr = eina_stringshare_add("valign");
 +   wrapstr = eina_stringshare_add("wrap");
 +   left_marginstr = eina_stringshare_add("left_margin");
 +   right_marginstr = eina_stringshare_add("right_margin");
 +   underlinestr = eina_stringshare_add("underline");
 +   strikethroughstr = eina_stringshare_add("strikethrough");
 +   backingstr = eina_stringshare_add("backing");
 +   stylestr = eina_stringshare_add("style");
 +   tabstopsstr = eina_stringshare_add("tabstops");
 +   linesizestr = eina_stringshare_add("linesize");
 +   linerelsizestr = eina_stringshare_add("linerelsize");
 +   linegapstr = eina_stringshare_add("linegap");
 +   linerelgapstr = eina_stringshare_add("linerelgap");
 +   itemstr = eina_stringshare_add("item");
-    visible = eina_stringshare_add("visible");
++   visible = eina_stringshare_add("visible"); */
+    if (format_refcount == 0)
+      {
+         fontstr = eina_stringshare_add("font");
+         font_fallbacksstr = eina_stringshare_add("font_fallbacks");
+         font_sizestr = eina_stringshare_add("font_size");
+         font_sourcestr = eina_stringshare_add("font_source");
+         colorstr = eina_stringshare_add("color");
+         underline_colorstr = eina_stringshare_add("underline_color");
+         underline2_colorstr = eina_stringshare_add("underline2_color");
+         outline_colorstr = eina_stringshare_add("outline_color");
+         shadow_colorstr = eina_stringshare_add("shadow_color");
+         glow_colorstr = eina_stringshare_add("glow_color");
+         glow2_colorstr = eina_stringshare_add("glow2_color");
+         backing_colorstr = eina_stringshare_add("backing_color");
+         strikethrough_colorstr = eina_stringshare_add("strikethrough_color");
+         alignstr = eina_stringshare_add("align");
+         valignstr = eina_stringshare_add("valign");
+         wrapstr = eina_stringshare_add("wrap");
+         left_marginstr = eina_stringshare_add("left_margin");
+         right_marginstr = eina_stringshare_add("right_margin");
+         underlinestr = eina_stringshare_add("underline");
+         strikethroughstr = eina_stringshare_add("strikethrough");
+         backingstr = eina_stringshare_add("backing");
+         stylestr = eina_stringshare_add("style");
+         tabstopsstr = eina_stringshare_add("tabstops");
+         linesizestr = eina_stringshare_add("linesize");
+         linerelsizestr = eina_stringshare_add("linerelsize");
+         linegapstr = eina_stringshare_add("linegap");
+         linerelgapstr = eina_stringshare_add("linerelgap");
++        visible = eina_stringshare_add("visible");
+         itemstr = eina_stringshare_add("item");
+         linefillstr = eina_stringshare_add("linefill");
+      }
+    format_refcount++;
  }
  
+ /**
+  * @internal
+  * Shutdown the format strings.
+  */
  static void
  _format_command_shutdown(void)
  {
     eina_stringshare_del(linegapstr);
     eina_stringshare_del(linerelgapstr);
     eina_stringshare_del(itemstr);
 +   eina_stringshare_del(visible);
+    eina_stringshare_del(linefillstr);
  }
  
+ /**
+  * @internal
+  * Copies str to dst while removing the \\ char, i.e unescape the escape sequences.
+  *
+  * @param[out] dst the destination string - Should not be NULL.
+  * @param[in] src the source string - Should not be NULL.
+  */
  static void
  _format_clean_param(char *dst, const char *src)
  {
@@@ -1140,29 -1440,40 +1474,49 @@@ _format_command(Evas_Object *obj, Evas_
       }
     else if (cmd == linerelgapstr)
       {
-       char *endptr = NULL;
-       double val = strtod(tmp_param, &endptr);
-       if (endptr)
-         {
-            while (*endptr && _is_white(*endptr))
-              endptr++;
-            if (*endptr == '%')
-              {
-                 fmt->linerelgap = val / 100.0;
-                 fmt->linegap = 0;
-                 if (fmt->linerelgap < 0.0) fmt->linerelgap = 0.0;
-              }
+         char *endptr = NULL;
+         double val = strtod(tmp_param, &endptr);
+         if (endptr)
+           {
+              while (*endptr && _is_white(*endptr))
+                endptr++;
+              if (*endptr == '%')
+                {
+                   fmt->linerelgap = val / 100.0;
+                   fmt->linegap = 0;
+                   if (fmt->linerelgap < 0.0) fmt->linerelgap = 0.0;
+                }
+           }
+      }
+    else if (cmd == itemstr)
+      {
+         // itemstr == replacement object items in textblock - inline imges
+         // for example
+      }
+    else if (cmd == linefillstr)
+      {
+         char *endptr = NULL;
+         double val = strtod(tmp_param, &endptr);
+         if (endptr)
+           {
+              while (*endptr && _is_white(*endptr))
+                endptr++;
+              if (*endptr == '%')
+                {
+                   fmt->linefill = val / 100.0;
+                   if (fmt->linefill < 0.0) fmt->linefill = 0.0;
+                }
            }
       }
 +   else if(cmd ==visible)
 +      {               
 +              int v;
 +              v = atoi(tmp_param);
 +              if(v==1)
 +                      fmt->password = 1;
 +              else
 +                      fmt->password = 0;
 +     }
  
     if (new_font)
       {
@@@ -1821,23 -2407,28 +2450,28 @@@ _layout_text_append(Ctxt *c, Evas_Objec
  {
     int adv, inset, tw, th, new_line, empty_item;
     int wrap, twrap, ch, index, white_stripped;
-    char *str;
-    const char *tbase;
+    Eina_Unicode *alloc_str = NULL;
+    const Eina_Unicode *str = EINA_UNICODE_EMPTY_STRING;
+    const Eina_Unicode *tbase;
     Evas_Object_Textblock_Item *it;
  
+    /* FIXME: explain the algorithm. */
     if (n)
       {
-    if ((!fmt->password)&&(repch) && (eina_strbuf_length_get(n->text)))
 -        if ((repch) && (eina_ustrbuf_length_get(n->unicode)))
++   if ((!fmt->password)&&(repch) && (eina_strbuf_length_get(n->utf8)))
            {
-              int i, len, chlen;
-              char *ptr;
-              
-              len = evas_common_font_utf8_get_len((unsigned char *) eina_strbuf_string_get(n->text));
-              chlen = strlen(repch);
-              str = alloca((len * chlen) + 1);
+              int i, len, ind;
+              Eina_Unicode *ptr;
+              Eina_Unicode urepch;
+              len = eina_ustrbuf_length_get(n->unicode);
+              str = alloca((len + 1) * sizeof(Eina_Unicode));
               tbase = str;
-              for (i = 0, ptr = str; i < len; ptr += chlen, i++)
-                memcpy(ptr, repch, chlen);
+              ind = 0;
+              urepch = evas_common_encoding_utf8_get_next(repch, &ind);
+              for (i = 0, ptr = (Eina_Unicode *)tbase; i < len; ptr++, i++)
+                *ptr = urepch;
               *ptr = 0;
            }
          else
index 590e706,e50f95f..c128189
mode 100755,100644..100755
- /*\r
-  * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2\r
-  */\r
\r
 -#include "evas_common.h"
 -#include "evas_private.h"
 -#include "evas_cs.h"
 -
 -struct ext_loader_s
 -{
 -   const char *extention;
 -   const char *loader;
 -};
 -
 -static const struct ext_loader_s loaders[] =
 -{
 -   { "png", "png" },
 -   { "jpg", "jpeg" },
 -   { "jpeg", "jpeg" },
 -   { "jfif", "jpeg" },
 -   { "eet", "eet" },
 -   { "edj", "eet" },
 -   { "eap", "eet" },
 -   { "edb", "edb" },
 -   { "xpm", "xpm" },
 -   { "tiff", "tiff" },
 -   { "tif", "tiff" },
 -   { "svg", "svg" },
 -   { "svgz", "svg" },
 -   { "gif", "gif" },
 -   { "pbm", "pmaps" },
 -   { "pgm", "pmaps" },
 -   { "ppm", "pmaps" },
 -   { "pnm", "pmaps" },
 -   { "bmp", "bmp" },
 -   { "tga", "tga" }
 -};
 -
 -static const char *loaders_name[] =
 -{
 -  "png", "jpeg", "eet", "xpm", "tiff", "gif", "svg", "pmaps", "edb", "bmp", "tga"
 -};
 -
 -struct evas_image_foreach_loader_data
 -{
 -   Image_Entry *ie;
 -   int *error;
 -   Evas_Module *em;
 -};
 -
 -
 -static Eina_Bool
 -_evas_image_foreach_loader(const Eina_Hash *hash __UNUSED__, const void *key __UNUSED__, void *data, void *fdata)
 -{
 -   Evas_Image_Load_Func *evas_image_load_func = NULL;
 -   Evas_Module *em = data;
 -   struct evas_image_foreach_loader_data *d = fdata;
 -   Image_Entry *ie = d->ie;
 -
 -   if (!evas_module_load(em)) return EINA_TRUE;
 -   evas_image_load_func = em->functions;
 -   evas_module_use(em);
 -   *(d->error) = EVAS_LOAD_ERROR_NONE;
 -   if (evas_image_load_func &&
 -       evas_image_load_func->file_head(ie, ie->file, ie->key, d->error) &&
 -       (*(d->error) == EVAS_LOAD_ERROR_NONE))
 -     {
 -      d->em = em;
 -      return EINA_FALSE;
 -     }
 -
 -   return EINA_TRUE;
 -}
 -
 -EAPI int
 -evas_common_load_rgba_image_module_from_file(Image_Entry *ie)
 -{
 -   Evas_Image_Load_Func *evas_image_load_func = NULL;
 -   const char           *loader = NULL;
 -   Evas_Module          *em;
 -   char                 *dot;
 -   int                   i;
 -   int                   ret = EVAS_LOAD_ERROR_NONE;
 -   struct evas_image_foreach_loader_data fdata;
 -
 -
 -#ifdef EVAS_CSERVE
 -   if (evas_cserve_use_get())
 -     {
 -      // TODO: handle errors from server and return them?
 -      DBG("try cserve '%s' '%s'", ie->file, ie->key ? ie->key : "");
 -        if (evas_cserve_image_load(ie, ie->file, ie->key, &(ie->load_opts)))
 -          {
 -           DBG("try cserve '%s' '%s' loaded!",
 -               ie->file, ie->key ? ie->key : "");
 -             return EVAS_LOAD_ERROR_NONE;
 -          }
 -     }
 -#endif   
 -   dot = strrchr (ie->file, '.');
 -   if (dot)
 -     {
 -      for (i = 0, ++dot; i < (sizeof (loaders) / sizeof (struct ext_loader_s)); ++i)
 -        {
 -           if (!strcasecmp(dot, loaders[i].extention))
 -             {
 -                loader = loaders[i].loader;
 -                DBG("known loader '%s' handles extension '%s' of file '%s'",
 -                    loader, dot, ie->file);
 -                break;
 -             }
 -        }
 -     }
 -
 -   if (loader)
 -     {
 -      em = evas_module_find_type(EVAS_MODULE_TYPE_IMAGE_LOADER, loader);
 -      if (em)
 -        {
 -           DBG("found image loader '%s' (%p)", loader, em);
 -           if (evas_module_load(em))
 -             {
 -                evas_module_use(em);
 -                evas_image_load_func = em->functions;
 -                ret = EVAS_LOAD_ERROR_NONE;
 -                if (evas_image_load_func->file_head(ie, ie->file, ie->key, &ret))
 -                  {
 -                     DBG("loaded file head using module '%s' (%p): %s",
 -                         loader, em, ie->file);
 -                     goto end;
 -                  }
 -                evas_module_unload(em);
 -                DBG("failed to load file head using module '%s' (%p): "
 -                    "%s (%s)",
 -                    loader, em, ie->file, evas_load_error_str(ret));
 -             }
 -           else
 -             WRN("failed to load module '%s' (%p)", loader, em);
 -        }
 -      else
 -        DBG("image loader '%s' is not enabled or missing!", loader);
 -     }
 -
 -   fdata.ie = ie;
 -   fdata.error = &ret;
 -   fdata.em = NULL;
 -   ret = EVAS_LOAD_ERROR_NONE;
 -   evas_module_foreach_image_loader(_evas_image_foreach_loader, &fdata);
 -   em = fdata.em;
 -   evas_image_load_func = em ? em->functions : NULL;
 -   if (em) goto end;
 -
 -   /* This is our last chance, try all known image loader. */
 -   /* FIXME: We could use eina recursive module search ability. */
 -   for (i = 0; i < sizeof (loaders_name) / sizeof (char *); i++)
 -     {
 -      em = evas_module_find_type(EVAS_MODULE_TYPE_IMAGE_LOADER, loaders_name[i]);
 -      if (em)
 -        {
 -           if (evas_module_load(em))
 -             {
 -                evas_module_use(em);
 -                evas_image_load_func = em->functions;
 -                ret = EVAS_LOAD_ERROR_NONE;
 -                if (evas_image_load_func->file_head(ie, ie->file, ie->key, &ret))
 -                  {
 -                     DBG("brute force loader '%s' (%p) worked on %s",
 -                         loaders_name[i], em, ie->file);
 -                     goto end;
 -                  }
 -                else
 -                  DBG("brute force loader '%s' (%p) failed on %s (%s)",
 -                      loaders_name[i], em, ie->file,
 -                      evas_load_error_str(ret));
 -
 -                evas_module_unload(em);
 -             }
 -           else
 -             WRN("failed to load module '%s' (%p)", loaders_name[i], em);
 -        }
 -      else
 -        DBG("could not find module '%s'", loaders_name[i]);
 -     }
 -
 -   DBG("exhausted all means to load image '%s'", ie->file);
 -   return EVAS_LOAD_ERROR_UNKNOWN_FORMAT;
 -
 -   end:
 -
 -   if (ret != EVAS_LOAD_ERROR_NONE)
 -     {
 -      const char *modname = NULL;
 -      int modversion = -1;
 -      if (em && em->definition)
 -        {
 -           modname = em->definition->name;
 -           modversion = em->definition->version;
 -        }
 -      WRN("loader '%s' (version %d) "
 -          "handled file '%s', key '%s' with errors: %s",
 -          modname ? modname : "<UNKNOWN>", modversion,
 -          ie->file, ie->key ? ie->key : "",
 -          evas_load_error_str(ret));
 -      goto end;
 -     }
 -
 -   DBG("loader '%s' used for file %s",
 -       (em && em->definition && em->definition->name) ?
 -       em->definition->name : "<UNKNOWN>",
 -       ie->file);
 -
 -   ie->info.module = (void*) em;
 -   ie->info.loader = (void*) evas_image_load_func;
 -   evas_module_ref((Evas_Module*) ie->info.module);
 -   return ret;
 -}
 -
 -EAPI int
 -evas_common_load_rgba_image_data_from_file(Image_Entry *ie)
 -{
 -   Evas_Image_Load_Func *evas_image_load_func = NULL;
 -   int ret = EVAS_LOAD_ERROR_NONE;
 -
 -   if (ie->flags.loaded) return EVAS_LOAD_ERROR_GENERIC;
 -
 -#ifdef EVAS_CSERVE
 -   if (ie->data1)
 -     {
 -        if (evas_cserve_image_data_load(ie))
 -          {
 -             RGBA_Image *im = (RGBA_Image *)ie;
 -             Mem *mem = ie->data2;
 -             if (mem)
 -               {
 -                im->image.data = (void*) (mem->data + mem->offset);
 -                  im->image.no_free = 1;
 -                  return EVAS_LOAD_ERROR_NONE;
 -               }
 -          }
 -      return EVAS_LOAD_ERROR_GENERIC;
 -     }
 -#endif
 -
 -   if (!ie->info.module) return EVAS_LOAD_ERROR_GENERIC;
 -
 -//   printf("load data [%p] %s %s\n", ie, ie->file, ie->key);
 -           
 -   evas_image_load_func = ie->info.loader;
 -   evas_module_use((Evas_Module*) ie->info.module);
 -   if (!evas_image_load_func->file_data(ie, ie->file, ie->key, &ret))
 -     {
 -        return ret;
 -     }
 -
 -//   evas_module_unref((Evas_Module*) ie->info.module);
 -//   ie->info.module = NULL;
 -
 -   return EVAS_LOAD_ERROR_NONE;
 -}
 +#include "evas_common.h"\r
 +#include "evas_private.h"\r
 +#include "evas_cs.h"\r
 +\r
 +struct ext_loader_s\r
 +{\r
 +   const char *extention;\r
 +   const char *loader;\r
 +};\r
 +\r
 +static const struct ext_loader_s loaders[] =\r
 +{\r
 +   { "png", "png" },\r
 +   { "jpg", "jpeg" },\r
 +   { "jpeg", "jpeg" },\r
 +   { "jfif", "jpeg" },\r
 +   { "eet", "eet" },\r
 +   { "edj", "eet" },\r
 +   { "eap", "eet" },\r
 +   { "edb", "edb" },\r
 +   { "xpm", "xpm" },\r
 +   { "tiff", "tiff" },\r
 +   { "tif", "tiff" },\r
 +   { "svg", "svg" },\r
 +   { "svgz", "svg" },\r
 +   { "gif", "gif" },\r
 +   { "pbm", "pmaps" },\r
 +   { "pgm", "pmaps" },\r
 +   { "ppm", "pmaps" },\r
 +   { "pnm", "pmaps" },\r
 +   { "bmp", "bmp" },\r
 +   { "wbmp", "wbmp" },\r
 +   { "tga", "tga" }\r
 +};\r
 +\r
 +static const char *loaders_name[] =\r
 +{\r
 +  "png", "jpeg", "eet", "xpm", "tiff", "gif", "svg", "pmaps", "edb", "bmp", "wbmp", "tga"\r
 +};\r
 +\r
 +struct evas_image_foreach_loader_data\r
 +{\r
 +   Image_Entry *ie;\r
 +   int *error;\r
 +   Evas_Module *em;\r
 +};\r
 +\r
 +\r
 +static Eina_Bool\r
 +_evas_image_foreach_loader(const Eina_Hash *hash __UNUSED__, const void *key __UNUSED__, void *data, void *fdata)\r
 +{\r
 +   Evas_Image_Load_Func *evas_image_load_func = NULL;\r
 +   Evas_Module *em = data;\r
 +   struct evas_image_foreach_loader_data *d = fdata;\r
 +   Image_Entry *ie = d->ie;\r
 +\r
 +   if (!evas_module_load(em)) return EINA_TRUE;\r
 +   evas_image_load_func = em->functions;\r
 +   evas_module_use(em);\r
 +   *(d->error) = EVAS_LOAD_ERROR_NONE;\r
 +   if (evas_image_load_func &&\r
 +       evas_image_load_func->file_head(ie, ie->file, ie->key, d->error) &&\r
 +       (*(d->error) == EVAS_LOAD_ERROR_NONE))\r
 +     {\r
 +      d->em = em;\r
 +      return EINA_FALSE;\r
 +     }\r
 +\r
 +   return EINA_TRUE;\r
 +}\r
 +\r
 +EAPI int\r
 +evas_common_load_rgba_image_module_from_file(Image_Entry *ie)\r
 +{\r
 +   Evas_Image_Load_Func *evas_image_load_func = NULL;\r
 +   const char           *loader = NULL;\r
 +   Evas_Module          *em;\r
 +   char                 *dot;\r
 +   int                   i;\r
 +   int                   ret = EVAS_LOAD_ERROR_NONE;\r
 +   struct evas_image_foreach_loader_data fdata;\r
 +\r
 +\r
 +#ifdef EVAS_CSERVE\r
 +   if (evas_cserve_use_get())\r
 +     {\r
 +      // TODO: handle errors from server and return them?\r
 +      DBG("try cserve '%s' '%s'", ie->file, ie->key ? ie->key : "");\r
 +        if (evas_cserve_image_load(ie, ie->file, ie->key, &(ie->load_opts)))\r
 +          {\r
 +           DBG("try cserve '%s' '%s' loaded!",\r
 +               ie->file, ie->key ? ie->key : "");\r
 +             return EVAS_LOAD_ERROR_NONE;\r
 +          }\r
 +     }\r
 +#endif   \r
 +   dot = strrchr (ie->file, '.');\r
 +   if (dot)\r
 +     {\r
 +      for (i = 0, ++dot; i < (sizeof (loaders) / sizeof (struct ext_loader_s)); ++i)\r
 +        {\r
 +           if (!strcasecmp(dot, loaders[i].extention))\r
 +             {\r
 +                loader = loaders[i].loader;\r
 +                DBG("known loader '%s' handles extension '%s' of file '%s'",\r
 +                    loader, dot, ie->file);\r
 +                break;\r
 +             }\r
 +        }\r
 +     }\r
 +\r
 +   if (loader)\r
 +     {\r
 +      em = evas_module_find_type(EVAS_MODULE_TYPE_IMAGE_LOADER, loader);\r
 +      if (em)\r
 +        {\r
 +           DBG("found image loader '%s' (%p)", loader, em);\r
 +           if (evas_module_load(em))\r
 +             {\r
 +                evas_module_use(em);\r
 +                evas_image_load_func = em->functions;\r
 +                ret = EVAS_LOAD_ERROR_NONE;\r
 +                if (evas_image_load_func->file_head(ie, ie->file, ie->key, &ret))\r
 +                  {\r
 +                     DBG("loaded file head using module '%s' (%p): %s",\r
 +                         loader, em, ie->file);\r
 +                     goto end;\r
 +                  }\r
 +                evas_module_unload(em);\r
 +                DBG("failed to load file head using module '%s' (%p): "\r
 +                    "%s (%s)",\r
 +                    loader, em, ie->file, evas_load_error_str(ret));\r
 +             }\r
 +           else\r
 +             WRN("failed to load module '%s' (%p)", loader, em);\r
 +        }\r
 +      else\r
 +        DBG("image loader '%s' is not enabled or missing!", loader);\r
 +     }\r
 +\r
 +   fdata.ie = ie;\r
 +   fdata.error = &ret;\r
 +   fdata.em = NULL;\r
 +   ret = EVAS_LOAD_ERROR_NONE;\r
 +   evas_module_foreach_image_loader(_evas_image_foreach_loader, &fdata);\r
 +   em = fdata.em;\r
 +   evas_image_load_func = em ? em->functions : NULL;\r
 +   if (em) goto end;\r
 +\r
 +   /* This is our last chance, try all known image loader. */\r
 +   /* FIXME: We could use eina recursive module search ability. */\r
 +   for (i = 0; i < sizeof (loaders_name) / sizeof (char *); i++)\r
 +     {\r
 +      em = evas_module_find_type(EVAS_MODULE_TYPE_IMAGE_LOADER, loaders_name[i]);\r
 +      if (em)\r
 +        {\r
 +           if (evas_module_load(em))\r
 +             {\r
 +                evas_module_use(em);\r
 +                evas_image_load_func = em->functions;\r
 +                ret = EVAS_LOAD_ERROR_NONE;\r
 +                if (evas_image_load_func->file_head(ie, ie->file, ie->key, &ret))\r
 +                  {\r
 +                     DBG("brute force loader '%s' (%p) worked on %s",\r
 +                         loaders_name[i], em, ie->file);\r
 +                     goto end;\r
 +                  }\r
 +                else\r
 +                  DBG("brute force loader '%s' (%p) failed on %s (%s)",\r
 +                      loaders_name[i], em, ie->file,\r
 +                      evas_load_error_str(ret));\r
 +\r
 +                evas_module_unload(em);\r
 +             }\r
 +           else\r
 +             WRN("failed to load module '%s' (%p)", loaders_name[i], em);\r
 +        }\r
 +      else\r
 +        DBG("could not find module '%s'", loaders_name[i]);\r
 +     }\r
 +\r
 +   DBG("exhausted all means to load image '%s'", ie->file);\r
 +   return EVAS_LOAD_ERROR_UNKNOWN_FORMAT;\r
 +\r
 +   end:\r
 +\r
 +   if (ret != EVAS_LOAD_ERROR_NONE)\r
 +     {\r
 +      const char *modname = NULL;\r
 +      int modversion = -1;\r
 +      if (em && em->definition)\r
 +        {\r
 +           modname = em->definition->name;\r
 +           modversion = em->definition->version;\r
 +        }\r
 +      WRN("loader '%s' (version %d) "\r
 +          "handled file '%s', key '%s' with errors: %s",\r
 +          modname ? modname : "<UNKNOWN>", modversion,\r
 +          ie->file, ie->key ? ie->key : "",\r
 +          evas_load_error_str(ret));\r
 +      goto end;\r
 +     }\r
 +\r
 +   DBG("loader '%s' used for file %s",\r
 +       (em && em->definition && em->definition->name) ?\r
 +       em->definition->name : "<UNKNOWN>",\r
 +       ie->file);\r
 +\r
 +   ie->info.module = (void*) em;\r
 +   ie->info.loader = (void*) evas_image_load_func;\r
 +   evas_module_ref((Evas_Module*) ie->info.module);\r
 +   return ret;\r
 +}\r
 +\r
 +EAPI int\r
 +evas_common_load_rgba_image_data_from_file(Image_Entry *ie)\r
 +{\r
 +   Evas_Image_Load_Func *evas_image_load_func = NULL;\r
 +   int ret = EVAS_LOAD_ERROR_NONE;\r
 +\r
 +   if (ie->flags.loaded) return EVAS_LOAD_ERROR_GENERIC;\r
 +\r
 +#ifdef EVAS_CSERVE\r
 +   if (ie->data1)\r
 +     {\r
 +        if (evas_cserve_image_data_load(ie))\r
 +          {\r
 +             RGBA_Image *im = (RGBA_Image *)ie;\r
 +             Mem *mem = ie->data2;\r
 +             if (mem)\r
 +               {\r
 +                im->image.data = (void*) (mem->data + mem->offset);\r
 +                  im->image.no_free = 1;\r
 +                  return EVAS_LOAD_ERROR_NONE;\r
 +               }\r
 +          }\r
 +      return EVAS_LOAD_ERROR_GENERIC;\r
 +     }\r
 +#endif\r
 +\r
 +   if (!ie->info.module) return EVAS_LOAD_ERROR_GENERIC;\r
 +\r
 +//   printf("load data [%p] %s %s\n", ie, ie->file, ie->key);\r
 +           \r
 +   evas_image_load_func = ie->info.loader;\r
 +   evas_module_use((Evas_Module*) ie->info.module);\r
 +   if (!evas_image_load_func->file_data(ie, ie->file, ie->key, &ret))\r
 +     {\r
 +        return ret;\r
 +     }\r
 +\r
 +//   evas_module_unref((Evas_Module*) ie->info.module);\r
 +//   ie->info.module = NULL;\r
 +\r
 +   return EVAS_LOAD_ERROR_NONE;\r
 +}\r
@@@ -1,14 -1,13 +1,29 @@@
+ #define NEONDEBUG 0
+ #if NEONDEBUG
+ #define DEBUG_FNCOUNT(x)      \
+       do {                    \
+       static int _foo = 0;            \
+       if (_foo++%10000 ==0)           \
+               printf("%s %+d %s: %d (%s)\n",__FILE__,__LINE__,__FUNCTION__,\
+                               _foo, x " optimised");\
++      } while (0)
++#else
++#define       DEBUG_FNCOUNT(x)        ((void)x)
++#endif
++
 +
 +#define NEONDEBUG 0
 +
 +
 +#if NEONDEBUG
 +#define DEBUG_FNCOUNT(x)      \
 +      do {                    \
 +      static int _foo = 0;            \
 +      if (_foo++%10000 ==0)           \
 +              printf("%s %+d %s: %d (%s)\n",__FILE__,__LINE__,__FUNCTION__,\
 +                              _foo, x " optimised");\
        } while (0)
  #else
  #define       DEBUG_FNCOUNT(x)        ((void)x)
@@@ -357,24 -357,6 +357,25 @@@ eng_setup(Evas *e, void *in
               eng_window_use(re->win);
               evas_gl_common_context_resize(re->win->gl_context, re->win->w, re->win->h, re->win->rot);
            }
++        // added by gl77.lee
 +        else if (info->no_swap == 1)
 +          {
 +             info->num_deferred_swaps = 0;
 +          }
 +        else if (info->no_swap == 0)
 +          {
 +             if (info->num_deferred_swaps > 0)
 +               {
 +#if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
 +                  if (re->win->egl_disp && re->win->egl_surface[0])
 +                    eglSwapBuffers(re->win->egl_disp, re->win->egl_surface[0]);
 +#else
 +                  if (re->win->disp && re->win->win)
 +                     glXSwapBuffers(re->win->disp, re->win->win);
 +#endif
 +                  info->num_deferred_swaps = 0;
 +               }
 +          }
          
       }
     if (!re->win)
@@@ -568,8 -550,7 +569,8 @@@ eng_output_redraws_next_update_push(voi
     ta = t0 - pt;
     pt = t0;
  #endif
-    // to avoid rendering performance drop - yigl 100518
 -   eglWaitNative(EGL_CORE_NATIVE_ENGINE); // previous rendering should be done and swapped
++   // to avoid rendering performance drop - gl77.lee 100518
 +   //eglWaitNative(EGL_CORE_NATIVE_ENGINE); // previous rendering should be done and swapped
  #ifdef FRAMECOUNT
     double t1 = get_time();
     tb = t1 - t0;
@@@ -599,14 -580,12 +600,19 @@@ eng_output_flush(void *data
  #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
  #ifdef FRAMECOUNT
     double t0 = get_time();
- #endif   
+ #endif
 -   if (re->info->vsync)
 -      eglSwapInterval(re->win->egl_disp, 1);
++   // Don't need to set swap interval for every frame. - gl77.lee 100831
++   //if (re->info->vsync)
++   //   eglSwapInterval(re->win->egl_disp, 1);
++   //else
++   //   eglSwapInterval(re->win->egl_disp, 0);
 +   if (re->info->no_swap)
 +     {
 +        glFlush();
 +        re->info->num_deferred_swaps++;
 +     }
     else
 -      eglSwapInterval(re->win->egl_disp, 0);
 -   eglSwapBuffers(re->win->egl_disp, re->win->egl_surface[0]);
 +     eglSwapBuffers(re->win->egl_disp, re->win->egl_surface[0]);
  #ifdef FRAMECOUNT
     double t1 = get_time();
     printf("%1.5f\n", t1 - t0);
  //       (re->win->draw.y2 == (re->win->h - 1))
         )
       {
 -        glXSwapBuffers(re->win->disp, re->win->win);
++        // added by gl77.lee
 +        if (re->info->no_swap)
 +          {
 +             glFlush();
 +             re->info->num_deferred_swaps++;
 +          }
 +        else
 +          glXSwapBuffers(re->win->disp, re->win->win);
       }
     else
       {
@@@ -397,19 -411,16 +411,19 @@@ eng_window_free(Evas_GL_X11_Window *gw
  {
     int ref = 0;
     win_count--;
-    eng_window_use (gw);
+    eng_window_use(gw);
     if (gw == _evas_gl_x11_window) _evas_gl_x11_window = NULL;
     if (gw->gl_context)
-      {
-         ref = gw->gl_context->references - 1;
-         evas_gl_common_context_free(gw->gl_context);
-      }
+       {
+          ref = gw->gl_context->references - 1;
+          evas_gl_common_context_free(gw->gl_context);
+       }
  #if defined (GLES_VARIETY_S3C6410) || defined (GLES_VARIETY_SGX)
     if (gw->egl_surface[0] != EGL_NO_SURFACE)
 -     eglDestroySurface(gw->egl_disp, gw->egl_surface[0]);
 +     {
 +        eglDestroySurface(gw->egl_disp, gw->egl_surface[0]);
 +        gw->egl_surface[0] = EGL_NO_SURFACE;
 +     }
     if (ref == 0)
       {
          if (context) eglDestroyContext(gw->egl_disp, context);
index b4b72e5,6fd0aa0..104fe89
mode 100755,100644..100755
\r
 -#ifdef HAVE_CONFIG_H
 -# include <config.h>
 -#endif
 -
 -#ifndef _GNU_SOURCE
 -#define _GNU_SOURCE
 -#endif
 -
 -#include <stdio.h>
 -
 -#ifdef HAVE_EVIL
 -# include <Evil.h>
 -#endif
 -
 -#include "evas_common.h"
 -#include "evas_private.h"
 -
 -static Eina_Bool evas_image_load_file_head_bmp(Image_Entry *ie, const char *file, const char *key, int *error) EINA_ARG_NONNULL(1, 2, 4);
 -static Eina_Bool evas_image_load_file_data_bmp(Image_Entry *ie, const char *file, const char *key, int *error) EINA_ARG_NONNULL(1, 2, 4);
 -
 -static Evas_Image_Load_Func evas_image_load_bmp_func =
 -{
 -  EINA_TRUE,
 -  evas_image_load_file_head_bmp,
 -  evas_image_load_file_data_bmp
 -};
 -
 -static int
 -read_short(FILE *file, short *ret)
 -{
 -   unsigned char b[2];
 -   if (fread(b, sizeof(unsigned char), 2, file) != 2) return 0;
 -   *ret = (b[1] << 8) | b[0];
 -   return 1;
 -}
 -
 -static int
 -read_ushort(FILE *file, unsigned short *ret)
 -{
 -   unsigned char b[2];
 -   if (fread(b, sizeof(unsigned char), 2, file) != 2) return 0;
 -   *ret = (b[1] << 8) | b[0];
 -   return 1;
 -}
 -
 -static int
 -read_int(FILE *file, int *ret)
 -{
 -   unsigned char b[4];
 -   if (fread(b, sizeof(unsigned char), 4, file) != 4) return 0;
 -   *ret = ARGB_JOIN(b[3], b[2], b[1], b[0]);
 -   return 1;
 -}
 -
 -static int
 -read_uint(FILE *file, unsigned int *ret)
 -{
 -   unsigned char       b[4];
 -   if (fread(b, sizeof(unsigned char), 4, file) != 4) return 0;
 -   *ret = ARGB_JOIN(b[3], b[2], b[1], b[0]);
 -   return 1;
 -}
 -
 -static Eina_Bool
 -evas_image_load_file_head_bmp(Image_Entry *ie, const char *file, const char *key __UNUSED__, int *error)
 -{
 -   FILE *f;
 -   char buf[4096];
 -   char hasa = 0;
 -   int w = 0, h = 0, planes = 0, bit_count = 0,
 -     image_size = 0, comp = 0, hdpi = 0, vdpi = 0,
 -     palette_size = -1, important_colors = 0;
 -   unsigned int offset, head_size, rmask = 0, gmask = 0, bmask = 0, amask = 0;
 -   unsigned int pal_num = 0;
 -   int right_way_up = 0;
 -   int fsize = 0;
 -   unsigned int bmpsize;
 -   unsigned short res1, res2;
 -
 -   f = fopen(file, "rb");
 -   if (!f)
 -     {
 -      *error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;
 -      return EINA_FALSE;
 -     }
 -
 -   *error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT;
 -   fseek(f, 0, SEEK_END);
 -   fsize = ftell(f);
 -   fseek(f, 0, SEEK_SET);
 -   if (fsize < 2) goto close_file;
 -   
 -   if (fread(buf, 2, 1, f) != 1) goto close_file;
 -   if (strncmp(buf, "BM", 2)) goto close_file; // magic number
 -   *error = EVAS_LOAD_ERROR_CORRUPT_FILE;
 -   if (!read_uint(f, &bmpsize)) goto close_file;
 -   if (!read_ushort(f, &res1)) goto close_file;
 -   if (!read_ushort(f, &res2)) goto close_file;
 -   if (!read_uint(f, &offset)) goto close_file;
 -   if (!read_uint(f, &head_size)) goto close_file;
 -   if (head_size == 12) // OS/2 V1 + Windows 3.0
 -     {
 -        short tmp;
 -        
 -        if (!read_short(f, &tmp)) goto close_file;
 -        w = tmp; // width
 -        if (!read_short(f, &tmp)) goto close_file;
 -        h = tmp; // height
 -        if (!read_short(f, &tmp)) goto close_file;
 -        planes = tmp; // must be 1
 -        if (!read_short(f, &tmp)) goto close_file;
 -        bit_count = tmp; // bits per pixel: 1, 4, 8 & 24
 -     }
 -   else if (head_size == 64) // OS/2 V2
 -     {
 -        short tmp;
 -        int tmp2;
 -        
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        w = tmp2; // width
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        h = tmp2; // height
 -        if (!read_short(f, &tmp)) goto close_file;
 -        planes = tmp; // must be 1
 -        if (!read_short(f, &tmp)) goto close_file;
 -        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        comp = tmp2; // compression method
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        image_size = tmp2; // bitmap data size
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        important_colors = tmp2; // number of important colors - 0 if all
 -        if (fread(buf, 24, 1, f) != 1) goto close_file; // skip unused header
 -        if (image_size == 0) image_size = fsize - offset;
 -     }
 -   else if (head_size == 40) // Windows 3.0 + (v3)
 -     {
 -        short tmp;
 -        int tmp2;
 -        
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        w = tmp2; // width
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        h = tmp2; // height
 -        if (!read_short(f, &tmp)) goto close_file;
 -        planes = tmp; // must be 1
 -        if (!read_short(f, &tmp)) goto close_file;
 -        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        comp = tmp2; // compression method
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        image_size = tmp2; // bitmap data size
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        important_colors = tmp2; // number of important colors - 0 if all
 -        if (image_size == 0) image_size = fsize - offset;
 -     }
 -   else if (head_size == 108) // Windows 95/NT4 + (v4)
 -     {
 -        short tmp;
 -        int tmp2;
 -        
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        w = tmp2; // width
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        h = tmp2; // height
 -        if (!read_short(f, &tmp)) goto close_file;
 -        planes = tmp; // must be 1
 -        if (!read_short(f, &tmp)) goto close_file;
 -        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        comp = tmp2; // compression method
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        image_size = tmp2; // bitmap data size
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        important_colors = tmp2; // number of important colors - 0 if all
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        rmask = tmp2; // red mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        gmask = tmp2; // green mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        bmask = tmp2; // blue mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        amask = tmp2; // alpha mask
 -        if (fread(buf, 36, 1, f) != 1) goto close_file; // skip unused cie
 -        if (fread(buf, 12, 1, f) != 1) goto close_file; // skip unused gamma
 -        if (image_size == 0) image_size = fsize - offset;
 -        if ((amask) && (bit_count == 32)) hasa = 1;
 -     }
 -   else if (head_size == 124) // Windows 98/2000 + (v5)
 -     {
 -        short tmp;
 -        int tmp2;
 -        
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        w = tmp2; // width
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        h = tmp2; // height
 -        if (!read_short(f, &tmp)) goto close_file;
 -        planes = tmp; // must be 1
 -        if (!read_short(f, &tmp)) goto close_file;
 -        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        comp = tmp2; // compression method
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        image_size = tmp2; // bitmap data size
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        important_colors = tmp2; // number of important colors - 0 if all
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        rmask = tmp2; // red mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        gmask = tmp2; // green mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        bmask = tmp2; // blue mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        amask = tmp2; // alpha mask
 -        if (fread(buf, 36, 1, f) != 1) goto close_file; // skip unused cie
 -        if (fread(buf, 12, 1, f) != 1) goto close_file; // skip unused gamma
 -        if (fread(buf, 16, 1, f) != 1) goto close_file; // skip others
 -        if (image_size == 0) image_size = fsize - offset;
 -        if ((amask) && (bit_count == 32)) hasa = 1;
 -     }
 -   else
 -     goto close_file;
 -
 -   if (h < 0)
 -     {
 -        h = -h;
 -        right_way_up = 1;
 -     }
 -   
 -   if ((w < 1) || (h < 1) || (w > IMG_MAX_SIZE) || (h > IMG_MAX_SIZE) ||
 -       IMG_TOO_BIG(w, h))
 -     {
 -        if (IMG_TOO_BIG(w, h))
 -          *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
 -        else
 -          *error = EVAS_LOAD_ERROR_GENERIC;
 -      goto close_file;
 -     }
 -   
 -   if (bit_count < 16)
 -     {
 -        if ((palette_size < 0) || (palette_size > 256)) pal_num = 256;
 -        else pal_num = palette_size;
 -        if (bit_count == 1)
 -          {
 -             if (comp == 0) // no compression
 -               {
 -               }
 -             else
 -               goto close_file;
 -          }
 -        else if (bit_count == 4)
 -          {
 -             if (comp == 0) // no compression
 -               {
 -               }
 -             else if (comp == 2) // rle 4bit/pixel
 -               {
 -               }
 -             else
 -               goto close_file;
 -          }
 -        else if (bit_count == 8)
 -          {
 -             if (comp == 0) // no compression
 -               {
 -               }
 -             else if (comp == 1) // rle 8bit/pixel
 -               {
 -               }
 -             else
 -               goto close_file;
 -          }
 -     }
 -   else if ((bit_count == 16) || (bit_count == 24) || (bit_count == 32))
 -     {
 -        if (comp == 0) // no compression
 -          {
 -             // handled
 -          }
 -        else if (comp == 3) // bit field
 -          {
 -             // handled
 -          }
 -        else if (comp == 4) // jpeg - only printer drivers
 -          goto close_file;
 -        else if (comp == 3) // png - only printer drivers
 -          goto close_file;
 -        else
 -          goto close_file;
 -     }
 -   else
 -     goto close_file;
 -
 -   ie->w = w;
 -   ie->h = h;
 -   if (hasa) ie->flags.alpha = 1;
 -   
 -   fclose(f);
 -   *error = EVAS_LOAD_ERROR_NONE;
 -   return EINA_TRUE;
 -
 - close_file:
 -   fclose(f);
 -   return EINA_FALSE;
 -}
 -
 -static Eina_Bool
 -evas_image_load_file_data_bmp(Image_Entry *ie, const char *file, const char *key __UNUSED__, int *error)
 -{
 -   FILE *f;
 -   char buf[4096];
 -   unsigned char *buffer = NULL, *buffer_end = NULL, *p;
 -   char hasa = 0;
 -   int x = 0, y = 0, w = 0, h = 0, planes = 0, bit_count = 0, image_size = 0,
 -     comp = 0, hdpi = 0, vdpi = 0, palette_size = -1, important_colors = 0;
 -   unsigned int offset = 0, head_size = 0;
 -   unsigned int *pal = NULL, pal_num = 0, *pix = NULL, *surface = NULL, fix,
 -     rmask = 0, gmask = 0, bmask = 0, amask = 0;
 -   int right_way_up = 0;
 -   unsigned char r, g, b, a;
 -   int fsize = 0;
 -   unsigned int bmpsize;
 -   unsigned short res1, res2;
 -   
 -   f = fopen(file, "rb");
 -   if (!f)
 -     {
 -      *error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;
 -      return EINA_FALSE;
 -     }
 -   
 -   *error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT;
 -   fseek(f, 0, SEEK_END);
 -   fsize = ftell(f);
 -   fseek(f, 0, SEEK_SET);
 -   if (fsize < 2) goto close_file;
 -   
 -   if (fread(buf, 2, 1, f) != 1) goto close_file;
 -   if (strncmp(buf, "BM", 2)) goto close_file; // magic number
 -   *error = EVAS_LOAD_ERROR_CORRUPT_FILE;
 -   if (!read_uint(f, &bmpsize)) goto close_file;
 -   if (!read_ushort(f, &res1)) goto close_file;
 -   if (!read_ushort(f, &res2)) goto close_file;
 -   if (!read_uint(f, &offset)) goto close_file;
 -   if (!read_uint(f, &head_size)) goto close_file;
 -   image_size = fsize - offset;
 -   if (image_size < 1) goto close_file;
 -   
 -   if (head_size == 12) // OS/2 V1 + Windows 3.0
 -     {
 -        short tmp;
 -        
 -        if (!read_short(f, &tmp)) goto close_file;
 -        w = tmp; // width
 -        if (!read_short(f, &tmp)) goto close_file;
 -        h = tmp; // height
 -        if (!read_short(f, &tmp)) goto close_file;
 -        planes = tmp; // must be 1
 -        if (!read_short(f, &tmp)) goto close_file;
 -        bit_count = tmp; // bits per pixel: 1, 4, 8 & 24
 -     }
 -   else if (head_size == 64) // OS/2 V2
 -     {
 -        short tmp;
 -        int tmp2;
 -        
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        w = tmp2; // width
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        h = tmp2; // height
 -        if (!read_short(f, &tmp)) goto close_file;
 -        planes = tmp; // must be 1
 -        if (!read_short(f, &tmp)) goto close_file;
 -        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        comp = tmp2; // compression method
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        image_size = tmp2; // bitmap data size
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        important_colors = tmp2; // number of important colors - 0 if all
 -        if (fread(buf, 24, 1, f) != 1) goto close_file; // skip unused header
 -        if (image_size == 0) image_size = fsize - offset;
 -     }
 -   else if (head_size == 40) // Windows 3.0 + (v3)
 -     {
 -        short tmp;
 -        int tmp2;
 -        
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        w = tmp2; // width
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        h = tmp2; // height
 -        if (!read_short(f, &tmp)) goto close_file;
 -        planes = tmp; // must be 1
 -        if (!read_short(f, &tmp)) goto close_file;
 -        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        comp = tmp2; // compression method
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        image_size = tmp2; // bitmap data size
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        important_colors = tmp2; // number of important colors - 0 if all
 -        if (image_size == 0) image_size = fsize - offset;
 -     }
 -   else if (head_size == 108) // Windows 95/NT4 + (v4)
 -     {
 -        short tmp;
 -        int tmp2;
 -        
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        w = tmp2; // width
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        h = tmp2; // height
 -        if (!read_short(f, &tmp)) goto close_file;
 -        planes = tmp; // must be 1
 -        if (!read_short(f, &tmp)) goto close_file;
 -        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        comp = tmp2; // compression method
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        image_size = tmp2; // bitmap data size
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        important_colors = tmp2; // number of important colors - 0 if all
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        rmask = tmp2; // red mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        gmask = tmp2; // green mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        bmask = tmp2; // blue mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        amask = tmp2; // alpha mask
 -        if (fread(buf, 36, 1, f) != 1) goto close_file; // skip unused cie
 -        if (fread(buf, 12, 1, f) != 1) goto close_file; // skip unused gamma
 -        if (image_size == 0) image_size = fsize - offset;
 -        if ((amask) && (bit_count == 32)) hasa = 1;
 -     }
 -   else if (head_size == 124) // Windows 98/2000 + (v5)
 -     {
 -        short tmp;
 -        int tmp2;
 -        
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        w = tmp2; // width
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        h = tmp2; // height
 -        if (!read_short(f, &tmp)) goto close_file;
 -        planes = tmp; // must be 1
 -        if (!read_short(f, &tmp)) goto close_file;
 -        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        comp = tmp2; // compression method
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        image_size = tmp2; // bitmap data size
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        important_colors = tmp2; // number of important colors - 0 if all
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        rmask = tmp2; // red mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        gmask = tmp2; // green mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        bmask = tmp2; // blue mask
 -        if (!read_int(f, &tmp2)) goto close_file;
 -        amask = tmp2; // alpha mask
 -        if (fread(buf, 36, 1, f) != 1) goto close_file; // skip unused cie
 -        if (fread(buf, 12, 1, f) != 1) goto close_file; // skip unused gamma
 -        if (fread(buf, 16, 1, f) != 1) goto close_file; // skip others
 -        if (image_size == 0) image_size = fsize - offset;
 -        if ((amask) && (bit_count == 32)) hasa = 1;
 -     }
 -   else
 -     goto close_file;
 -
 -   if (h < 0)
 -     {
 -        h = -h;
 -        right_way_up = 1;
 -     }
 -   if ((w < 1) || (h < 1) || (w > IMG_MAX_SIZE) || (h > IMG_MAX_SIZE) ||
 -       IMG_TOO_BIG(w, h))
 -     {
 -        if (IMG_TOO_BIG(w, h))
 -          *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
 -        else
 -          *error = EVAS_LOAD_ERROR_GENERIC;
 -      goto close_file;
 -     }
 -   
 -   if ((w != ie->w) || (h != ie->h))
 -     {
 -      *error = EVAS_LOAD_ERROR_GENERIC;
 -      goto close_file;
 -     }
 -   evas_cache_image_surface_alloc(ie, w, h);
 -   surface = evas_cache_image_pixels(ie);
 -   if (!surface)
 -     {
 -      *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
 -      goto close_file;
 -     }
 -   
 -   if (bit_count < 16)
 -     {
 -        unsigned int i;
 -
 -        if (bit_count == 1)
 -          {
 -             if ((palette_size <= 0) || (palette_size > 2)) pal_num = 2;
 -             else pal_num = palette_size;
 -          }
 -        else if (bit_count == 4)
 -          {
 -             if ((palette_size <= 0) || (palette_size > 16)) pal_num = 16;
 -             else pal_num = palette_size;
 -          }
 -        else if (bit_count == 8)
 -          {
 -             if ((palette_size <= 0) || (palette_size > 256)) pal_num = 256;
 -             else pal_num = palette_size;
 -          }
 -        pal = alloca(256 * 4);
 -        for (i = 0; i < pal_num; i++)
 -          {
 -             if (fread(&b, 1, 1, f) != 1) goto close_file;
 -             if (fread(&g, 1, 1, f) != 1) goto close_file;
 -             if (fread(&r, 1, 1, f) != 1) goto close_file;
 -             if ((head_size != 12) /*&& (palette_size != 0)*/)
 -               { // OS/2 V1 doesnt do the pad byte
 -                  if (fread(&a, 1, 1, f) != 1) goto close_file;
 -               }
 -             a = 0xff; // fillin a as solid for paletted images
 -             pal[i] = ARGB_JOIN(a, r, g, b);
 -          }
 -        fseek(f, offset, SEEK_SET);
 -        buffer = malloc(image_size + 8); // add 8 for padding to avoid checks
 -        if (!buffer)
 -          {
 -             *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
 -             goto close_file;
 -          }
 -        buffer_end = buffer + image_size;
 -        p = buffer;
 -        if (fread(buffer, image_size, 1, f) != 1) goto close_file;
 -        
 -        if (bit_count == 1)
 -          {
 -             if (comp == 0) // no compression
 -               {
 -                  pix = surface;
 -                  for (y = 0; y < h; y++)
 -                    {
 -                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);
 -                       for (x = 0; x < w; x++)
 -                         {
 -                            if ((x & 0x7) == 0x0)
 -                              {
 -                                 *pix = pal[*p >> 7];
 -                              }
 -                            else if ((x & 0x7) == 0x1)
 -                              {
 -                                 *pix = pal[(*p >> 6) & 0x1];
 -                              }
 -                            else if ((x & 0x7) == 0x2)
 -                              {
 -                                 *pix = pal[(*p >> 5) & 0x1];
 -                              }
 -                            else if ((x & 0x7) == 0x3)
 -                              {
 -                                 *pix = pal[(*p >> 4) & 0x1];
 -                              }
 -                            else if ((x & 0x7) == 0x4)
 -                              {
 -                                 *pix = pal[(*p >> 3) & 0x1];
 -                              }
 -                            else if ((x & 0x7) == 0x5)
 -                              {
 -                                 *pix = pal[(*p >> 2) & 0x1];
 -                              }
 -                            else if ((x & 0x7) == 0x6)
 -                              {
 -                                 *pix = pal[(*p >> 1) & 0x1];
 -                              }
 -                            else
 -                              {
 -                                 *pix = pal[*p & 0x1];
 -                                 p++;
 -                              }
 -                            if (p >= buffer_end) break;
 -                            pix++;
 -                         }
 -                       if ((x & 0x7) != 0) p++;
 -                       fix = (int)(((unsigned long)p) & 0x3);
 -                       if (fix > 0) p += 4 - fix; // align row read
 -                       if (p >= buffer_end) break;
 -                    }
 -               }
 -             else
 -               goto close_file;
 -          }
 -        else if (bit_count == 4)
 -          {
 -             if (comp == 0) // no compression
 -               {
 -                  pix = surface;
 -                  for (y = 0; y < h; y++)
 -                    {
 -                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);
 -                       for (x = 0; x < w; x++)
 -                         {
 -                            if ((x & 0x1) == 0x1)
 -                              {
 -                                 *pix = pal[*p & 0x0f];
 -                                 p++;
 -                              }
 -                            else
 -                              {
 -                                 *pix = pal[*p >> 4];
 -                              }
 -                            if (p >= buffer_end) break;
 -                            pix++;
 -                         }
 -                       if ((x & 0x1) != 0) p++;
 -                       fix = (int)(((unsigned long)p) & 0x3);
 -                       if (fix > 0) p += 4 - fix; // align row read
 -                       if (p >= buffer_end) break;
 -                    }
 -               }
 -             else if (comp == 2) // rle 4bit/pixel
 -               {
 -                  int count = 0, done = 0, wpad;
 -
 -                  pix = surface;
 -                  if (!right_way_up) pix = surface + ((h - 1 - y) * w);
 -                  wpad = ((w + 1) / 2) * 2;
 -                  while (p < buffer_end)
 -                    {
 -                       if (p[0])
 -                         {
 -                            unsigned int col1 = pal[p[1] >> 4];
 -                            unsigned int col2 = pal[p[1] & 0xf];
 -                            
 -                            if ((x + p[0]) > wpad) break;
 -                            count = p[0] / 2;
 -                            while (count > 0)
 -                              {
 -                                 if (x < w)
 -                                   {
 -                                      pix[0] = col1;
 -                                      x++;
 -                                   }
 -                                 if (x < w)
 -                                   {
 -                                      pix[1] = col2;
 -                                      x++;
 -                                   }
 -                                 pix += 2;
 -                                 count--;
 -                              }
 -                            if (p[0] & 0x1)
 -                              {
 -                                 *pix = col1;
 -                                 x++;
 -                                 pix++;
 -                              }
 -                            p += 2;
 -                         }
 -                       else
 -                         {
 -                            switch (p[1])
 -                              {
 -                              case 0: // EOL
 -                                 x = 0;
 -                                 y++;
 -                                 if (!right_way_up)
 -                                   pix = surface + ((h - 1 - y) * w);
 -                                 else
 -                                   pix = surface + (y * w);
 -                                 if (y >= h)
 -                                   {
 -                                      p = buffer_end;
 -                                   }
 -                                 p += 2;
 -                                 break;
 -                              case 1: // EOB
 -                                 p = buffer_end;
 -                                 break;
 -                              case 2: // DELTA
 -                                 x += p[2];
 -                                 y += p[3];
 -                                 if ((x >= w) || (y >= h))
 -                                   {
 -                                      p = buffer_end;
 -                                   }
 -                                 if (!right_way_up)
 -                                   pix = surface + x + ((h - 1 - y) * w);
 -                                 else
 -                                   pix = surface + x + (y * w);
 -                                 p += 4;
 -                                 break;
 -                              default:
 -                                 count = p[1];
 -                                 if (((p + count) > buffer_end) ||
 -                                     ((x + count) > w))
 -                                   {
 -                                      p = buffer_end;
 -                                      break;
 -                                   }
 -                                 p += 2;
 -                                 done = count;
 -                                 count /= 2;
 -                                 while (count > 0)
 -                                   {
 -                                      pix[0] = pal[*p >> 4];
 -                                      pix[1] = pal[*p & 0xf];
 -                                      pix += 2;
 -                                      p++;
 -                                      count--;
 -                                   }
 -                                 x += done;
 -                                 if (done & 0x1)
 -                                   {
 -                                      *pix = pal[*p >> 4];
 -                                      p++;
 -                                   }
 -                                 if ((done & 0x3) == 0x1)
 -                                   p += 2;
 -                                 else if ((done & 0x3) == 0x2)
 -                                   p += 1;
 -                                 break;
 -                              }
 -                         }
 -                    }
 -               }
 -             else
 -               goto close_file;
 -          }
 -        else if (bit_count == 8)
 -          {
 -             if (comp == 0) // no compression
 -               {
 -                  pix = surface;
 -                  for (y = 0; y < h; y++)
 -                    {
 -                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);
 -                       for (x = 0; x < w; x++)
 -                         {
 -                            *pix = pal[*p];
 -                            p++;
 -                            if (p >= buffer_end) break;
 -                            pix++;
 -                         }
 -                       fix = (int)(((unsigned long)p) & 0x3);
 -                       if (fix > 0) p += 4 - fix; // align row read
 -                       if (p >= buffer_end) break;
 -                    }
 -               }
 -             else if (comp == 1) // rle 8bit/pixel
 -               {
 -                  int count = 0, done = 0;
 -
 -                  pix = surface;
 -                  if (!right_way_up) pix = surface + ((h - 1 - y) * w);
 -                  while (p < buffer_end)
 -                    {
 -                       if (p[0])
 -                         {
 -                            unsigned int col = pal[p[1]];
 -                            
 -                            count = p[0];
 -                            if ((x + p[0]) > w) break;
 -                            while (count > 0)
 -                              {
 -                                 *pix = col;
 -                                 pix++;
 -                                 count--;
 -                              }
 -                            x += p[0];
 -                            p += 2;
 -                         }
 -                       else
 -                         {
 -                            switch (p[1])
 -                              {
 -                              case 0: // EOL
 -                                 x = 0;
 -                                 y++;
 -                                 if (!right_way_up)
 -                                   pix = surface + ((h - 1 - y) * w);
 -                                 else
 -                                   pix = surface + (y * w);
 -                                 if (y >= h)
 -                                   {
 -                                      p = buffer_end;
 -                                   }
 -                                 p += 2;
 -                                 break;
 -                              case 1: // EOB
 -                                 p = buffer_end;
 -                                 break;
 -                              case 2: // DELTA
 -                                 x += p[2];
 -                                 y += p[3];
 -                                 if ((x >= w) || (y >= h))
 -                                   {
 -                                      p = buffer_end;
 -                                   }
 -                                 if (!right_way_up)
 -                                   pix = surface + x + ((h - 1 - y) * w);
 -                                 else
 -                                   pix = surface + x + (y * w);
 -                                 p += 4;
 -                                 break;
 -                              default:
 -                                 count = p[1];
 -                                 if (((p + count) > buffer_end) ||
 -                                     ((x + count) > w))
 -                                   {
 -                                      p = buffer_end;
 -                                      break;
 -                                   }
 -                                 p += 2;
 -                                 done = count;
 -                                 while (count > 0)
 -                                   {
 -                                      *pix = pal[*p];
 -                                      pix++;
 -                                      p++;
 -                                      count--;
 -                                   }
 -                                 x += done;
 -                                 if (done & 0x1) p++;
 -                                 break;
 -                              }
 -                         }
 -                    }
 -               }
 -             else
 -               goto close_file;
 -          }
 -     }
 -   else if ((bit_count == 16) || (bit_count == 24) || (bit_count == 32))
 -     {
 -        if (comp == 0) // no compression
 -          {
 -             fseek(f, offset, SEEK_SET);
 -             buffer = malloc(image_size + 8); // add 8 for padding to avoid checks
 -             if (!buffer)
 -               {
 -                  *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
 -                  goto close_file;
 -               }
 -             buffer_end = buffer + image_size;
 -             p = buffer;
 -             if (fread(buffer, image_size, 1, f) != 1) goto close_file;
 -             if (bit_count == 16)
 -               {
 -                  unsigned short tmp;
 -                  
 -                  pix = surface;
 -                  for (y = 0; y < h; y++)
 -                    {
 -                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);
 -                       for (x = 0; x < w; x++)
 -                         {
 -                            tmp = *((unsigned short *)(p));
 -
 -                            r = (tmp >> 7) & 0xf8; r |= r >> 5;
 -                            g = (tmp >> 2) & 0xf8; g |= g >> 5;
 -                            b = (tmp << 3) & 0xf8; b |= b >> 5;
 -                            *pix = ARGB_JOIN(0xff, r, g, b);
 -                            p += 2;
 -                            if (p >= buffer_end) break;
 -                            pix++;
 -                         }
 -                       fix = (int)(((unsigned long)p) & 0x3);
 -                       if (fix > 0) p += 4 - fix; // align row read
 -                       if (p >= buffer_end) break;
 -                    }
 -               }
 -             else if (bit_count == 24)
 -               {
 -                  pix = surface;
 -                  for (y = 0; y < h; y++)
 -                    {
 -                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);
 -                       for (x = 0; x < w; x++)
 -                         {
 -                            b = p[0];
 -                            g = p[1];
 -                            r = p[2];
 -                            *pix = ARGB_JOIN(0xff, r, g, b);
 -                            p += 3;
 -                            if (p >= buffer_end) break;
 -                            pix++;
 -                         }
 -                       fix = (int)(((unsigned long)p) & 0x3);
 -                       if (fix > 0) p += 4 - fix; // align row read
 -                       if (p >= buffer_end) break;
 -                    }
 -               }
 -             else if (bit_count == 32)
 -               {
 -                  pix = surface;
 -                  for (y = 0; y < h; y++)
 -                    {
 -                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);
 -                       for (x = 0; x < w; x++)
 -                         {
 -                            b = p[0];
 -                            g = p[1];
 -                            r = p[2];
 -                            a = p[3];
 -                            if (!hasa) a = 0xff;
 -                            *pix = ARGB_JOIN(a, r, g, b);
 -                            p += 4;
 -                            if (p >= buffer_end) break;
 -                            pix++;
 -                         }
 -                       fix = (int)(((unsigned long)p) & 0x3);
 -                       if (fix > 0) p += 4 - fix; // align row read
 -                       if (p >= buffer_end) break;
 -                    }
 -               }
 -             else
 -               goto close_file;
 -          }
 -        else if (comp == 3) // bit field
 -          {
 -             if (!read_uint(f, &rmask)) goto close_file;
 -             if (!read_uint(f, &gmask)) goto close_file;
 -             if (!read_uint(f, &bmask)) goto close_file;
 -
 -             fseek(f, offset, SEEK_SET);
 -             buffer = malloc(image_size + 8); // add 8 for padding to avoid checks
 -             if (!buffer)
 -               {
 -                  *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
 -                  goto close_file;
 -               }
 -             buffer_end = buffer + image_size;
 -             p = buffer;
 -             if (fread(buffer, image_size, 1, f) != 1) goto close_file;
 -             if ((bit_count == 16) && 
 -                 (rmask == 0xf800) && (gmask == 0x07e0) && (bmask == 0x001f)
 -                 )
 -               {
 -                  unsigned short tmp;
 -                  
 -                  pix = surface;
 -                  for (y = 0; y < h; y++)
 -                    {
 -                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);
 -                       for (x = 0; x < w; x++)
 -                         {
 -                            tmp = *((unsigned short *)(p));
 -
 -                            r = (tmp >> 8) & 0xf8; r |= r >> 5;
 -                            g = (tmp >> 3) & 0xfc; g |= g >> 6;
 -                            b = (tmp << 3) & 0xf8; b |= b >> 5;
 -                            *pix = ARGB_JOIN(0xff, r, g, b);
 -                            p += 2;
 -                            if (p >= buffer_end) break;
 -                            pix++;
 -                         }
 -                       fix = (int)(((unsigned long)p) & 0x3);
 -                       if (fix > 0) p += 4 - fix; // align row read
 -                       if (p >= buffer_end) break;
 -                    }
 -               }
 -             else if ((bit_count == 16) && 
 -                      (rmask == 0x7c00) && (gmask == 0x03e0) && (bmask == 0x001f)
 -                     )
 -               {
 -                  unsigned short tmp;
 -                  
 -                  pix = surface;
 -                  for (y = 0; y < h; y++)
 -                    {
 -                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);
 -                       for (x = 0; x < w; x++)
 -                         {
 -                            tmp = *((unsigned short *)(p));
 -
 -                            r = (tmp >> 7) & 0xf8; r |= r >> 5;
 -                            g = (tmp >> 2) & 0xf8; g |= g >> 5;
 -                            b = (tmp << 3) & 0xf8; b |= b >> 5;
 -                            *pix = ARGB_JOIN(0xff, r, g, b);
 -                            p += 2;
 -                            if (p >= buffer_end) break;
 -                            pix++;
 -                         }
 -                       fix = (int)(((unsigned long)p) & 0x3);
 -                       if (fix > 0) p += 4 - fix; // align row read
 -                       if (p >= buffer_end) break;
 -                    }
 -               }
 -             else if (bit_count == 32)
 -               {
 -                  pix = surface;
 -                  for (y = 0; y < h; y++)
 -                    {
 -                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);
 -                       for (x = 0; x < w; x++)
 -                         {
 -                            b = p[0];
 -                            g = p[1];
 -                            r = p[2];
 -                            a = p[3];
 -                            if (!hasa) a = 0xff;
 -                            *pix = ARGB_JOIN(a, r, g, b);
 -                            p += 4;
 -                            if (p >= buffer_end) break;
 -                            pix++;
 -                         }
 -                       fix = (int)(((unsigned long)p) & 0x3);
 -                       if (fix > 0) p += 4 - fix; // align row read
 -                       if (p >= buffer_end) break;
 -                    }
 -               }
 -             else
 -               goto close_file;
 -          }
 -        else if (comp == 4) // jpeg - only printer drivers
 -          {
 -             goto close_file;
 -          }
 -        else if (comp == 3) // png - only printer drivers
 -          {
 -             goto close_file;
 -          }
 -        else
 -          goto close_file;
 -     }
 -   else
 -     goto close_file;
 -   
 -   if (buffer) free(buffer);
 -   fclose(f);
 -
 -   evas_common_image_premul(ie);
 -   *error = EVAS_LOAD_ERROR_NONE;
 -   return EINA_TRUE;
 -
 - close_file:
 -   if (buffer) free(buffer);
 -   fclose(f);
 -   return EINA_FALSE;
 -}
 -
 -static int
 -module_open(Evas_Module *em)
 -{
 -   if (!em) return 0;
 -   em->functions = (void *)(&evas_image_load_bmp_func);
 -   return 1;
 -}
 -
 -static void
 -module_close(Evas_Module *em __UNUSED__)
 -{
 -}
 -
 -static Evas_Module_Api evas_modapi =
 -{
 -   EVAS_MODULE_API_VERSION,
 -   "bmp",
 -   "none",
 -   {
 -     module_open,
 -     module_close
 -   }
 -};
 -
 -EVAS_MODULE_DEFINE(EVAS_MODULE_TYPE_IMAGE_LOADER, image_loader, bmp);
 -
 -#ifndef EVAS_STATIC_BUILD_BMP
 -EVAS_EINA_MODULE_DEFINE(image_loader, bmp);
 -#endif
 +#ifdef HAVE_CONFIG_H\r
 +# include <config.h>\r
 +#endif\r
 +\r
 +#ifndef _GNU_SOURCE\r
 +#define _GNU_SOURCE\r
 +#endif\r
 +\r
 +#include <stdio.h>\r
 +\r
 +#ifdef HAVE_EVIL\r
 +# include <Evil.h>\r
 +#endif\r
 +\r
 +#include "evas_common.h"\r
 +#include "evas_private.h"\r
 +\r
- #define EVAS_WINK_MODULE_NAME bmp\r
- #include "evas_wink.h"\r
\r
 +static Eina_Bool evas_image_load_file_head_bmp(Image_Entry *ie, const char *file, const char *key, int *error) EINA_ARG_NONNULL(1, 2, 4);\r
 +static Eina_Bool evas_image_load_file_data_bmp(Image_Entry *ie, const char *file, const char *key, int *error) EINA_ARG_NONNULL(1, 2, 4);\r
 +\r
 +static Evas_Image_Load_Func evas_image_load_bmp_func =\r
 +{\r
 +  EINA_TRUE,\r
 +  evas_image_load_file_head_bmp,\r
 +  evas_image_load_file_data_bmp\r
 +};\r
 +\r
\r
 +static int\r
 +read_short(FILE *file, short *ret)\r
 +{\r
 +   unsigned char b[2];\r
 +   if (fread(b, sizeof(unsigned char), 2, file) != 2) return 0;\r
 +   *ret = (b[1] << 8) | b[0];\r
 +   return 1;\r
 +}\r
-       \r
++\r
++static int\r
++read_ushort(FILE *file, unsigned short *ret)\r
++{\r
++   unsigned char b[2];\r
++   if (fread(b, sizeof(unsigned char), 2, file) != 2) return 0;\r
++   *ret = (b[1] << 8) | b[0];\r
++   return 1;\r
++}\r
++\r
 +static int\r
 +read_int(FILE *file, int *ret)\r
 +{\r
++   unsigned char b[4];\r
++   if (fread(b, sizeof(unsigned char), 4, file) != 4) return 0;\r
++   *ret = ARGB_JOIN(b[3], b[2], b[1], b[0]);\r
++   return 1;\r
++}\r
++\r
++static int\r
++read_uint(FILE *file, unsigned int *ret)\r
++{\r
 +   unsigned char       b[4];\r
 +   if (fread(b, sizeof(unsigned char), 4, file) != 4) return 0;\r
-    *ret = (b[3] << 24) | (b[2] << 16) | (b[1] << 8) | b[0];\r
++   *ret = ARGB_JOIN(b[3], b[2], b[1], b[0]);\r
 +   return 1;\r
 +}\r
 +\r
 +static Eina_Bool\r
 +evas_image_load_file_head_bmp(Image_Entry *ie, const char *file, const char *key __UNUSED__, int *error)\r
 +{\r
- #ifdef USE_WINK_CODEC\r
-    return evas_image_load_file_head_bmp_wink(ie, file, key, error);\r
- #endif\r
\r
 +   FILE *f;\r
-    unsigned char buf[4096];\r
++   char buf[4096];\r
 +   char hasa = 0;\r
-    int w = 0, h = 0, planes = 0, bit_count = 0, \r
-      image_size = 0, comp = 0, hdpi = 0, vdpi = 0, \r
-      palette_size = -1, important_colors = 0, rowlen = 0;\r
++   int w = 0, h = 0, planes = 0, bit_count = 0,\r
++     image_size = 0, comp = 0, hdpi = 0, vdpi = 0,\r
++     palette_size = -1, important_colors = 0;\r
 +   unsigned int offset, head_size, rmask = 0, gmask = 0, bmask = 0, amask = 0;\r
-    unsigned int *pal = NULL, pal_num = 0;\r
++   unsigned int pal_num = 0;\r
 +   int right_way_up = 0;\r
 +   int fsize = 0;\r
 +   unsigned int bmpsize;\r
 +   unsigned short res1, res2;\r
 +\r
 +   f = fopen(file, "rb");\r
 +   if (!f)\r
 +     {\r
 +      *error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;\r
 +      return EINA_FALSE;\r
 +     }\r
 +\r
 +   *error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT;\r
 +   fseek(f, 0, SEEK_END);\r
 +   fsize = ftell(f);\r
 +   fseek(f, 0, SEEK_SET);\r
 +   if (fsize < 2) goto close_file;\r
 +   \r
 +   if (fread(buf, 2, 1, f) != 1) goto close_file;\r
 +   if (strncmp(buf, "BM", 2)) goto close_file; // magic number\r
 +   *error = EVAS_LOAD_ERROR_CORRUPT_FILE;\r
-    if (!read_int(f, &bmpsize)) goto close_file;\r
-    if (!read_short(f, &res1)) goto close_file;\r
-    if (!read_short(f, &res2)) goto close_file;\r
-    if (!read_int(f, &offset)) goto close_file;\r
-    if (!read_int(f, &head_size)) goto close_file;\r
++   if (!read_uint(f, &bmpsize)) goto close_file;\r
++   if (!read_ushort(f, &res1)) goto close_file;\r
++   if (!read_ushort(f, &res2)) goto close_file;\r
++   if (!read_uint(f, &offset)) goto close_file;\r
++   if (!read_uint(f, &head_size)) goto close_file;\r
 +   if (head_size == 12) // OS/2 V1 + Windows 3.0\r
 +     {\r
 +        short tmp;\r
 +        \r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        w = tmp; // width\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        h = tmp; // height\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        planes = tmp; // must be 1\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        bit_count = tmp; // bits per pixel: 1, 4, 8 & 24\r
 +     }\r
 +   else if (head_size == 64) // OS/2 V2\r
 +     {\r
 +        short tmp;\r
 +        int tmp2;\r
 +        \r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        w = tmp2; // width\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        h = tmp2; // height\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        planes = tmp; // must be 1\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        comp = tmp2; // compression method\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        image_size = tmp2; // bitmap data size\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        important_colors = tmp2; // number of important colors - 0 if all\r
 +        if (fread(buf, 24, 1, f) != 1) goto close_file; // skip unused header\r
 +        if (image_size == 0) image_size = fsize - offset;\r
 +     }\r
 +   else if (head_size == 40) // Windows 3.0 + (v3)\r
 +     {\r
 +        short tmp;\r
 +        int tmp2;\r
 +        \r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        w = tmp2; // width\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        h = tmp2; // height\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        planes = tmp; // must be 1\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        comp = tmp2; // compression method\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        image_size = tmp2; // bitmap data size\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        important_colors = tmp2; // number of important colors - 0 if all\r
 +        if (image_size == 0) image_size = fsize - offset;\r
 +     }\r
 +   else if (head_size == 108) // Windows 95/NT4 + (v4)\r
 +     {\r
 +        short tmp;\r
 +        int tmp2;\r
 +        \r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        w = tmp2; // width\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        h = tmp2; // height\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        planes = tmp; // must be 1\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        comp = tmp2; // compression method\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        image_size = tmp2; // bitmap data size\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        important_colors = tmp2; // number of important colors - 0 if all\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        rmask = tmp2; // red mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        gmask = tmp2; // green mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        bmask = tmp2; // blue mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        amask = tmp2; // alpha mask\r
 +        if (fread(buf, 36, 1, f) != 1) goto close_file; // skip unused cie\r
 +        if (fread(buf, 12, 1, f) != 1) goto close_file; // skip unused gamma\r
 +        if (image_size == 0) image_size = fsize - offset;\r
 +        if ((amask) && (bit_count == 32)) hasa = 1;\r
 +     }\r
 +   else if (head_size == 124) // Windows 98/2000 + (v5)\r
 +     {\r
 +        short tmp;\r
 +        int tmp2;\r
 +        \r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        w = tmp2; // width\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        h = tmp2; // height\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        planes = tmp; // must be 1\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        comp = tmp2; // compression method\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        image_size = tmp2; // bitmap data size\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        important_colors = tmp2; // number of important colors - 0 if all\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        rmask = tmp2; // red mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        gmask = tmp2; // green mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        bmask = tmp2; // blue mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        amask = tmp2; // alpha mask\r
 +        if (fread(buf, 36, 1, f) != 1) goto close_file; // skip unused cie\r
 +        if (fread(buf, 12, 1, f) != 1) goto close_file; // skip unused gamma\r
 +        if (fread(buf, 16, 1, f) != 1) goto close_file; // skip others\r
 +        if (image_size == 0) image_size = fsize - offset;\r
 +        if ((amask) && (bit_count == 32)) hasa = 1;\r
 +     }\r
 +   else\r
 +     goto close_file;\r
 +\r
 +   if (h < 0)\r
 +     {\r
 +        h = -h;\r
 +        right_way_up = 1;\r
 +     }\r
 +   \r
 +   if ((w < 1) || (h < 1) || (w > IMG_MAX_SIZE) || (h > IMG_MAX_SIZE) ||\r
 +       IMG_TOO_BIG(w, h))\r
 +     {\r
 +        if (IMG_TOO_BIG(w, h))\r
 +          *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;\r
 +        else\r
 +          *error = EVAS_LOAD_ERROR_GENERIC;\r
 +      goto close_file;\r
 +     }\r
 +   \r
 +   if (bit_count < 16)\r
 +     {\r
-         int i;\r
-         \r
 +        if ((palette_size < 0) || (palette_size > 256)) pal_num = 256;\r
 +        else pal_num = palette_size;\r
 +        if (bit_count == 1)\r
 +          {\r
 +             if (comp == 0) // no compression\r
 +               {\r
 +               }\r
 +             else\r
 +               goto close_file;\r
 +          }\r
 +        else if (bit_count == 4)\r
 +          {\r
 +             if (comp == 0) // no compression\r
 +               {\r
 +               }\r
 +             else if (comp == 2) // rle 4bit/pixel\r
 +               {\r
 +               }\r
 +             else\r
 +               goto close_file;\r
 +          }\r
 +        else if (bit_count == 8)\r
 +          {\r
 +             if (comp == 0) // no compression\r
 +               {\r
 +               }\r
 +             else if (comp == 1) // rle 8bit/pixel\r
 +               {\r
 +               }\r
 +             else\r
 +               goto close_file;\r
 +          }\r
 +     }\r
 +   else if ((bit_count == 16) || (bit_count == 24) || (bit_count == 32))\r
 +     {\r
 +        if (comp == 0) // no compression\r
 +          {\r
 +             // handled\r
 +          }\r
 +        else if (comp == 3) // bit field\r
 +          {\r
 +             // handled\r
 +          }\r
 +        else if (comp == 4) // jpeg - only printer drivers\r
 +          goto close_file;\r
 +        else if (comp == 3) // png - only printer drivers\r
 +          goto close_file;\r
 +        else\r
 +          goto close_file;\r
 +     }\r
 +   else\r
 +     goto close_file;\r
 +\r
 +   ie->w = w;\r
 +   ie->h = h;\r
 +   if (hasa) ie->flags.alpha = 1;\r
 +   \r
 +   fclose(f);\r
 +   *error = EVAS_LOAD_ERROR_NONE;\r
 +   return EINA_TRUE;\r
 +\r
 + close_file:\r
 +   fclose(f);\r
 +   return EINA_FALSE;\r
 +}\r
 +\r
 +static Eina_Bool\r
 +evas_image_load_file_data_bmp(Image_Entry *ie, const char *file, const char *key __UNUSED__, int *error)\r
 +{\r
- #ifdef USE_WINK_CODEC\r
-    return evas_image_load_file_data_bmp_wink(ie, file, key, error);\r
- #endif\r
\r
 +   FILE *f;\r
-    unsigned char buf[4096], *buffer = NULL, *buffer_end = NULL, *p;\r
++   char buf[4096];\r
++   unsigned char *buffer = NULL, *buffer_end = NULL, *p;\r
 +   char hasa = 0;\r
-    int x = 0, y = 0, w = 0, h = 0, planes = 0, bit_count = 0, image_size = 0, \r
-      comp = 0, hdpi = 0, vdpi = 0, palette_size = -1, important_colors = 0, \r
-      offset = 0, head_size = 0;\r
++   int x = 0, y = 0, w = 0, h = 0, planes = 0, bit_count = 0, image_size = 0,\r
++     comp = 0, hdpi = 0, vdpi = 0, palette_size = -1, important_colors = 0;\r
++   unsigned int offset = 0, head_size = 0;\r
 +   unsigned int *pal = NULL, pal_num = 0, *pix = NULL, *surface = NULL, fix,\r
 +     rmask = 0, gmask = 0, bmask = 0, amask = 0;\r
 +   int right_way_up = 0;\r
 +   unsigned char r, g, b, a;\r
 +   int fsize = 0;\r
 +   unsigned int bmpsize;\r
 +   unsigned short res1, res2;\r
 +   \r
 +   f = fopen(file, "rb");\r
 +   if (!f)\r
 +     {\r
 +      *error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;\r
 +      return EINA_FALSE;\r
 +     }\r
 +   \r
 +   *error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT;\r
 +   fseek(f, 0, SEEK_END);\r
 +   fsize = ftell(f);\r
 +   fseek(f, 0, SEEK_SET);\r
 +   if (fsize < 2) goto close_file;\r
 +   \r
 +   if (fread(buf, 2, 1, f) != 1) goto close_file;\r
 +   if (strncmp(buf, "BM", 2)) goto close_file; // magic number\r
 +   *error = EVAS_LOAD_ERROR_CORRUPT_FILE;\r
-    if (!read_int(f, &bmpsize)) goto close_file;\r
-    if (!read_short(f, &res1)) goto close_file;\r
-    if (!read_short(f, &res2)) goto close_file;\r
-    if (!read_int(f, &offset)) goto close_file;\r
-    if (!read_int(f, &head_size)) goto close_file;\r
++   if (!read_uint(f, &bmpsize)) goto close_file;\r
++   if (!read_ushort(f, &res1)) goto close_file;\r
++   if (!read_ushort(f, &res2)) goto close_file;\r
++   if (!read_uint(f, &offset)) goto close_file;\r
++   if (!read_uint(f, &head_size)) goto close_file;\r
 +   image_size = fsize - offset;\r
 +   if (image_size < 1) goto close_file;\r
 +   \r
 +   if (head_size == 12) // OS/2 V1 + Windows 3.0\r
 +     {\r
 +        short tmp;\r
 +        \r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        w = tmp; // width\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        h = tmp; // height\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        planes = tmp; // must be 1\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        bit_count = tmp; // bits per pixel: 1, 4, 8 & 24\r
 +     }\r
 +   else if (head_size == 64) // OS/2 V2\r
 +     {\r
 +        short tmp;\r
 +        int tmp2;\r
 +        \r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        w = tmp2; // width\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        h = tmp2; // height\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        planes = tmp; // must be 1\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        comp = tmp2; // compression method\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        image_size = tmp2; // bitmap data size\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        important_colors = tmp2; // number of important colors - 0 if all\r
 +        if (fread(buf, 24, 1, f) != 1) goto close_file; // skip unused header\r
 +        if (image_size == 0) image_size = fsize - offset;\r
 +     }\r
 +   else if (head_size == 40) // Windows 3.0 + (v3)\r
 +     {\r
 +        short tmp;\r
 +        int tmp2;\r
 +        \r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        w = tmp2; // width\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        h = tmp2; // height\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        planes = tmp; // must be 1\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        comp = tmp2; // compression method\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        image_size = tmp2; // bitmap data size\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        important_colors = tmp2; // number of important colors - 0 if all\r
 +        if (image_size == 0) image_size = fsize - offset;\r
 +     }\r
 +   else if (head_size == 108) // Windows 95/NT4 + (v4)\r
 +     {\r
 +        short tmp;\r
 +        int tmp2;\r
 +        \r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        w = tmp2; // width\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        h = tmp2; // height\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        planes = tmp; // must be 1\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        comp = tmp2; // compression method\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        image_size = tmp2; // bitmap data size\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        important_colors = tmp2; // number of important colors - 0 if all\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        rmask = tmp2; // red mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        gmask = tmp2; // green mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        bmask = tmp2; // blue mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        amask = tmp2; // alpha mask\r
 +        if (fread(buf, 36, 1, f) != 1) goto close_file; // skip unused cie\r
 +        if (fread(buf, 12, 1, f) != 1) goto close_file; // skip unused gamma\r
 +        if (image_size == 0) image_size = fsize - offset;\r
 +        if ((amask) && (bit_count == 32)) hasa = 1;\r
 +     }\r
 +   else if (head_size == 124) // Windows 98/2000 + (v5)\r
 +     {\r
 +        short tmp;\r
 +        int tmp2;\r
 +        \r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        w = tmp2; // width\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        h = tmp2; // height\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        planes = tmp; // must be 1\r
 +        if (!read_short(f, &tmp)) goto close_file;\r
 +        bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        comp = tmp2; // compression method\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        image_size = tmp2; // bitmap data size\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8)\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        important_colors = tmp2; // number of important colors - 0 if all\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        rmask = tmp2; // red mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        gmask = tmp2; // green mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        bmask = tmp2; // blue mask\r
 +        if (!read_int(f, &tmp2)) goto close_file;\r
 +        amask = tmp2; // alpha mask\r
 +        if (fread(buf, 36, 1, f) != 1) goto close_file; // skip unused cie\r
 +        if (fread(buf, 12, 1, f) != 1) goto close_file; // skip unused gamma\r
 +        if (fread(buf, 16, 1, f) != 1) goto close_file; // skip others\r
 +        if (image_size == 0) image_size = fsize - offset;\r
 +        if ((amask) && (bit_count == 32)) hasa = 1;\r
 +     }\r
 +   else\r
 +     goto close_file;\r
 +\r
 +   if (h < 0)\r
 +     {\r
 +        h = -h;\r
 +        right_way_up = 1;\r
 +     }\r
 +   if ((w < 1) || (h < 1) || (w > IMG_MAX_SIZE) || (h > IMG_MAX_SIZE) ||\r
 +       IMG_TOO_BIG(w, h))\r
 +     {\r
 +        if (IMG_TOO_BIG(w, h))\r
 +          *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;\r
 +        else\r
 +          *error = EVAS_LOAD_ERROR_GENERIC;\r
 +      goto close_file;\r
 +     }\r
 +   \r
 +   if ((w != ie->w) || (h != ie->h))\r
 +     {\r
 +      *error = EVAS_LOAD_ERROR_GENERIC;\r
 +      goto close_file;\r
 +     }\r
 +   evas_cache_image_surface_alloc(ie, w, h);\r
 +   surface = evas_cache_image_pixels(ie);\r
 +   if (!surface)\r
 +     {\r
 +      *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;\r
 +      goto close_file;\r
 +     }\r
 +   \r
 +   if (bit_count < 16)\r
 +     {\r
-         int i;\r
-         \r
++        unsigned int i;\r
++\r
 +        if (bit_count == 1)\r
 +          {\r
 +             if ((palette_size <= 0) || (palette_size > 2)) pal_num = 2;\r
 +             else pal_num = palette_size;\r
 +          }\r
 +        else if (bit_count == 4)\r
 +          {\r
 +             if ((palette_size <= 0) || (palette_size > 16)) pal_num = 16;\r
 +             else pal_num = palette_size;\r
 +          }\r
 +        else if (bit_count == 8)\r
 +          {\r
 +             if ((palette_size <= 0) || (palette_size > 256)) pal_num = 256;\r
 +             else pal_num = palette_size;\r
 +          }\r
 +        pal = alloca(256 * 4);\r
 +        for (i = 0; i < pal_num; i++)\r
 +          {\r
 +             if (fread(&b, 1, 1, f) != 1) goto close_file;\r
 +             if (fread(&g, 1, 1, f) != 1) goto close_file;\r
 +             if (fread(&r, 1, 1, f) != 1) goto close_file;\r
 +             if ((head_size != 12) /*&& (palette_size != 0)*/)\r
 +               { // OS/2 V1 doesnt do the pad byte\r
 +                  if (fread(&a, 1, 1, f) != 1) goto close_file;\r
 +               }\r
 +             a = 0xff; // fillin a as solid for paletted images\r
-              pal[i] = (a << 24) | (r << 16) | (g << 8) | b;\r
++             pal[i] = ARGB_JOIN(a, r, g, b);\r
 +          }\r
 +        fseek(f, offset, SEEK_SET);\r
 +        buffer = malloc(image_size + 8); // add 8 for padding to avoid checks\r
 +        if (!buffer)\r
 +          {\r
 +             *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;\r
 +             goto close_file;\r
 +          }\r
 +        buffer_end = buffer + image_size;\r
 +        p = buffer;\r
 +        if (fread(buffer, image_size, 1, f) != 1) goto close_file;\r
 +        \r
 +        if (bit_count == 1)\r
 +          {\r
 +             if (comp == 0) // no compression\r
 +               {\r
 +                  pix = surface;\r
 +                  for (y = 0; y < h; y++)\r
 +                    {\r
 +                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);\r
 +                       for (x = 0; x < w; x++)\r
 +                         {\r
 +                            if ((x & 0x7) == 0x0)\r
 +                              {\r
 +                                 *pix = pal[*p >> 7];\r
 +                              }\r
 +                            else if ((x & 0x7) == 0x1)\r
 +                              {\r
 +                                 *pix = pal[(*p >> 6) & 0x1];\r
 +                              }\r
 +                            else if ((x & 0x7) == 0x2)\r
 +                              {\r
 +                                 *pix = pal[(*p >> 5) & 0x1];\r
 +                              }\r
 +                            else if ((x & 0x7) == 0x3)\r
 +                              {\r
 +                                 *pix = pal[(*p >> 4) & 0x1];\r
 +                              }\r
 +                            else if ((x & 0x7) == 0x4)\r
 +                              {\r
 +                                 *pix = pal[(*p >> 3) & 0x1];\r
 +                              }\r
 +                            else if ((x & 0x7) == 0x5)\r
 +                              {\r
 +                                 *pix = pal[(*p >> 2) & 0x1];\r
 +                              }\r
 +                            else if ((x & 0x7) == 0x6)\r
 +                              {\r
 +                                 *pix = pal[(*p >> 1) & 0x1];\r
 +                              }\r
 +                            else\r
 +                              {\r
 +                                 *pix = pal[*p & 0x1];\r
 +                                 p++;\r
 +                              }\r
 +                            if (p >= buffer_end) break;\r
 +                            pix++;\r
 +                         }\r
 +                       if ((x & 0x7) != 0) p++;\r
 +                       fix = (int)(((unsigned long)p) & 0x3);\r
 +                       if (fix > 0) p += 4 - fix; // align row read\r
 +                       if (p >= buffer_end) break;\r
 +                    }\r
 +               }\r
 +             else\r
 +               goto close_file;\r
 +          }\r
 +        else if (bit_count == 4)\r
 +          {\r
 +             if (comp == 0) // no compression\r
 +               {\r
 +                  pix = surface;\r
 +                  for (y = 0; y < h; y++)\r
 +                    {\r
 +                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);\r
 +                       for (x = 0; x < w; x++)\r
 +                         {\r
 +                            if ((x & 0x1) == 0x1)\r
 +                              {\r
 +                                 *pix = pal[*p & 0x0f];\r
 +                                 p++;\r
 +                              }\r
 +                            else\r
 +                              {\r
 +                                 *pix = pal[*p >> 4];\r
 +                              }\r
 +                            if (p >= buffer_end) break;\r
 +                            pix++;\r
 +                         }\r
 +                       if ((x & 0x1) != 0) p++;\r
 +                       fix = (int)(((unsigned long)p) & 0x3);\r
 +                       if (fix > 0) p += 4 - fix; // align row read\r
 +                       if (p >= buffer_end) break;\r
 +                    }\r
 +               }\r
 +             else if (comp == 2) // rle 4bit/pixel\r
 +               {\r
 +                  int count = 0, done = 0, wpad;\r
 +\r
 +                  pix = surface;\r
 +                  if (!right_way_up) pix = surface + ((h - 1 - y) * w);\r
 +                  wpad = ((w + 1) / 2) * 2;\r
 +                  while (p < buffer_end)\r
 +                    {\r
 +                       if (p[0])\r
 +                         {\r
 +                            unsigned int col1 = pal[p[1] >> 4];\r
 +                            unsigned int col2 = pal[p[1] & 0xf];\r
 +                            \r
 +                            if ((x + p[0]) > wpad) break;\r
 +                            count = p[0] / 2;\r
 +                            while (count > 0)\r
 +                              {\r
 +                                 if (x < w)\r
 +                                   {\r
 +                                      pix[0] = col1;\r
 +                                      x++;\r
 +                                   }\r
 +                                 if (x < w)\r
 +                                   {\r
 +                                      pix[1] = col2;\r
 +                                      x++;\r
 +                                   }\r
 +                                 pix += 2;\r
 +                                 count--;\r
 +                              }\r
 +                            if (p[0] & 0x1)\r
 +                              {\r
 +                                 *pix = col1;\r
 +                                 x++;\r
 +                                 pix++;\r
 +                              }\r
 +                            p += 2;\r
 +                         }\r
 +                       else\r
 +                         {\r
 +                            switch (p[1])\r
 +                              {\r
 +                              case 0: // EOL\r
 +                                 x = 0;\r
 +                                 y++;\r
 +                                 if (!right_way_up)\r
 +                                   pix = surface + ((h - 1 - y) * w);\r
 +                                 else\r
 +                                   pix = surface + (y * w);\r
 +                                 if (y >= h)\r
 +                                   {\r
 +                                      p = buffer_end;\r
 +                                   }\r
 +                                 p += 2;\r
 +                                 break;\r
 +                              case 1: // EOB\r
 +                                 p = buffer_end;\r
 +                                 break;\r
 +                              case 2: // DELTA\r
 +                                 x += p[2];\r
 +                                 y += p[3];\r
 +                                 if ((x >= w) || (y >= h))\r
 +                                   {\r
 +                                      p = buffer_end;\r
 +                                   }\r
 +                                 if (!right_way_up)\r
 +                                   pix = surface + x + ((h - 1 - y) * w);\r
 +                                 else\r
 +                                   pix = surface + x + (y * w);\r
 +                                 p += 4;\r
 +                                 break;\r
 +                              default:\r
 +                                 count = p[1];\r
 +                                 if (((p + count) > buffer_end) ||\r
 +                                     ((x + count) > w))\r
 +                                   {\r
 +                                      p = buffer_end;\r
 +                                      break;\r
 +                                   }\r
 +                                 p += 2;\r
 +                                 done = count;\r
 +                                 count /= 2;\r
 +                                 while (count > 0)\r
 +                                   {\r
 +                                      pix[0] = pal[*p >> 4];\r
 +                                      pix[1] = pal[*p & 0xf];\r
 +                                      pix += 2;\r
 +                                      p++;\r
 +                                      count--;\r
 +                                   }\r
 +                                 x += done;\r
 +                                 if (done & 0x1)\r
 +                                   {\r
 +                                      *pix = pal[*p >> 4];\r
 +                                      p++;\r
 +                                   }\r
 +                                 if ((done & 0x3) == 0x1)\r
 +                                   p += 2;\r
 +                                 else if ((done & 0x3) == 0x2)\r
 +                                   p += 1;\r
 +                                 break;\r
 +                              }\r
 +                         }\r
 +                    }\r
 +               }\r
 +             else\r
 +               goto close_file;\r
 +          }\r
 +        else if (bit_count == 8)\r
 +          {\r
 +             if (comp == 0) // no compression\r
 +               {\r
 +                  pix = surface;\r
 +                  for (y = 0; y < h; y++)\r
 +                    {\r
 +                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);\r
 +                       for (x = 0; x < w; x++)\r
 +                         {\r
 +                            *pix = pal[*p];\r
 +                            p++;\r
 +                            if (p >= buffer_end) break;\r
 +                            pix++;\r
 +                         }\r
 +                       fix = (int)(((unsigned long)p) & 0x3);\r
 +                       if (fix > 0) p += 4 - fix; // align row read\r
 +                       if (p >= buffer_end) break;\r
 +                    }\r
 +               }\r
 +             else if (comp == 1) // rle 8bit/pixel\r
 +               {\r
 +                  int count = 0, done = 0;\r
 +\r
 +                  pix = surface;\r
 +                  if (!right_way_up) pix = surface + ((h - 1 - y) * w);\r
 +                  while (p < buffer_end)\r
 +                    {\r
 +                       if (p[0])\r
 +                         {\r
 +                            unsigned int col = pal[p[1]];\r
 +                            \r
 +                            count = p[0];\r
 +                            if ((x + p[0]) > w) break;\r
 +                            while (count > 0)\r
 +                              {\r
 +                                 *pix = col;\r
 +                                 pix++;\r
 +                                 count--;\r
 +                              }\r
 +                            x += p[0];\r
 +                            p += 2;\r
 +                         }\r
 +                       else\r
 +                         {\r
 +                            switch (p[1])\r
 +                              {\r
 +                              case 0: // EOL\r
 +                                 x = 0;\r
 +                                 y++;\r
 +                                 if (!right_way_up)\r
 +                                   pix = surface + ((h - 1 - y) * w);\r
 +                                 else\r
 +                                   pix = surface + (y * w);\r
 +                                 if (y >= h)\r
 +                                   {\r
 +                                      p = buffer_end;\r
 +                                   }\r
 +                                 p += 2;\r
 +                                 break;\r
 +                              case 1: // EOB\r
 +                                 p = buffer_end;\r
 +                                 break;\r
 +                              case 2: // DELTA\r
 +                                 x += p[2];\r
 +                                 y += p[3];\r
 +                                 if ((x >= w) || (y >= h))\r
 +                                   {\r
 +                                      p = buffer_end;\r
 +                                   }\r
 +                                 if (!right_way_up)\r
 +                                   pix = surface + x + ((h - 1 - y) * w);\r
 +                                 else\r
 +                                   pix = surface + x + (y * w);\r
 +                                 p += 4;\r
 +                                 break;\r
 +                              default:\r
 +                                 count = p[1];\r
 +                                 if (((p + count) > buffer_end) ||\r
 +                                     ((x + count) > w))\r
 +                                   {\r
 +                                      p = buffer_end;\r
 +                                      break;\r
 +                                   }\r
 +                                 p += 2;\r
 +                                 done = count;\r
 +                                 while (count > 0)\r
 +                                   {\r
 +                                      *pix = pal[*p];\r
 +                                      pix++;\r
 +                                      p++;\r
 +                                      count--;\r
 +                                   }\r
 +                                 x += done;\r
 +                                 if (done & 0x1) p++;\r
 +                                 break;\r
 +                              }\r
 +                         }\r
 +                    }\r
 +               }\r
 +             else\r
 +               goto close_file;\r
 +          }\r
 +     }\r
 +   else if ((bit_count == 16) || (bit_count == 24) || (bit_count == 32))\r
 +     {\r
 +        if (comp == 0) // no compression\r
 +          {\r
 +             fseek(f, offset, SEEK_SET);\r
 +             buffer = malloc(image_size + 8); // add 8 for padding to avoid checks\r
 +             if (!buffer)\r
 +               {\r
 +                  *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;\r
 +                  goto close_file;\r
 +               }\r
 +             buffer_end = buffer + image_size;\r
 +             p = buffer;\r
 +             if (fread(buffer, image_size, 1, f) != 1) goto close_file;\r
 +             if (bit_count == 16)\r
 +               {\r
 +                  unsigned short tmp;\r
 +                  \r
 +                  pix = surface;\r
 +                  for (y = 0; y < h; y++)\r
 +                    {\r
 +                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);\r
 +                       for (x = 0; x < w; x++)\r
 +                         {\r
 +                            tmp = *((unsigned short *)(p));\r
 +\r
 +                            r = (tmp >> 7) & 0xf8; r |= r >> 5;\r
 +                            g = (tmp >> 2) & 0xf8; g |= g >> 5;\r
 +                            b = (tmp << 3) & 0xf8; b |= b >> 5;\r
-                             *pix = 0xff000000 | (r << 16) | (g << 8) | (b);\r
++                            *pix = ARGB_JOIN(0xff, r, g, b);\r
 +                            p += 2;\r
 +                            if (p >= buffer_end) break;\r
 +                            pix++;\r
 +                         }\r
 +                       fix = (int)(((unsigned long)p) & 0x3);\r
 +                       if (fix > 0) p += 4 - fix; // align row read\r
 +                       if (p >= buffer_end) break;\r
 +                    }\r
 +               }\r
 +             else if (bit_count == 24)\r
 +               {\r
 +                  pix = surface;\r
 +                  for (y = 0; y < h; y++)\r
 +                    {\r
 +                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);\r
 +                       for (x = 0; x < w; x++)\r
 +                         {\r
 +                            b = p[0];\r
 +                            g = p[1];\r
 +                            r = p[2];\r
-                             *pix = 0xff000000 | (r << 16) | (g << 8) | (b);\r
++                            *pix = ARGB_JOIN(0xff, r, g, b);\r
 +                            p += 3;\r
 +                            if (p >= buffer_end) break;\r
 +                            pix++;\r
 +                         }\r
 +                       fix = (int)(((unsigned long)p) & 0x3);\r
 +                       if (fix > 0) p += 4 - fix; // align row read\r
 +                       if (p >= buffer_end) break;\r
 +                    }\r
 +               }\r
 +             else if (bit_count == 32)\r
 +               {\r
 +                  pix = surface;\r
 +                  for (y = 0; y < h; y++)\r
 +                    {\r
 +                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);\r
 +                       for (x = 0; x < w; x++)\r
 +                         {\r
 +                            b = p[0];\r
 +                            g = p[1];\r
 +                            r = p[2];\r
 +                            a = p[3];\r
 +                            if (!hasa) a = 0xff;\r
-                             *pix = (a << 24) | (r << 16) | (g << 8) | (b);\r
++                            *pix = ARGB_JOIN(a, r, g, b);\r
 +                            p += 4;\r
 +                            if (p >= buffer_end) break;\r
 +                            pix++;\r
 +                         }\r
 +                       fix = (int)(((unsigned long)p) & 0x3);\r
 +                       if (fix > 0) p += 4 - fix; // align row read\r
 +                       if (p >= buffer_end) break;\r
 +                    }\r
 +               }\r
 +             else\r
 +               goto close_file;\r
 +          }\r
 +        else if (comp == 3) // bit field\r
 +          {\r
-              if (!read_int(f, &rmask)) goto close_file;\r
-              if (!read_int(f, &gmask)) goto close_file;\r
-              if (!read_int(f, &bmask)) goto close_file;\r
++             if (!read_uint(f, &rmask)) goto close_file;\r
++             if (!read_uint(f, &gmask)) goto close_file;\r
++             if (!read_uint(f, &bmask)) goto close_file;\r
 +\r
 +             fseek(f, offset, SEEK_SET);\r
 +             buffer = malloc(image_size + 8); // add 8 for padding to avoid checks\r
 +             if (!buffer)\r
 +               {\r
 +                  *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;\r
 +                  goto close_file;\r
 +               }\r
 +             buffer_end = buffer + image_size;\r
 +             p = buffer;\r
 +             if (fread(buffer, image_size, 1, f) != 1) goto close_file;\r
 +             if ((bit_count == 16) && \r
 +                 (rmask == 0xf800) && (gmask == 0x07e0) && (bmask == 0x001f)\r
 +                 )\r
 +               {\r
 +                  unsigned short tmp;\r
 +                  \r
 +                  pix = surface;\r
 +                  for (y = 0; y < h; y++)\r
 +                    {\r
 +                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);\r
 +                       for (x = 0; x < w; x++)\r
 +                         {\r
 +                            tmp = *((unsigned short *)(p));\r
 +\r
 +                            r = (tmp >> 8) & 0xf8; r |= r >> 5;\r
 +                            g = (tmp >> 3) & 0xfc; g |= g >> 6;\r
 +                            b = (tmp << 3) & 0xf8; b |= b >> 5;\r
-                             *pix = 0xff000000 | (r << 16) | (g << 8) | (b);\r
++                            *pix = ARGB_JOIN(0xff, r, g, b);\r
 +                            p += 2;\r
 +                            if (p >= buffer_end) break;\r
 +                            pix++;\r
 +                         }\r
 +                       fix = (int)(((unsigned long)p) & 0x3);\r
 +                       if (fix > 0) p += 4 - fix; // align row read\r
 +                       if (p >= buffer_end) break;\r
 +                    }\r
 +               }\r
 +             else if ((bit_count == 16) && \r
 +                      (rmask == 0x7c00) && (gmask == 0x03e0) && (bmask == 0x001f)\r
 +                     )\r
 +               {\r
 +                  unsigned short tmp;\r
 +                  \r
 +                  pix = surface;\r
 +                  for (y = 0; y < h; y++)\r
 +                    {\r
 +                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);\r
 +                       for (x = 0; x < w; x++)\r
 +                         {\r
 +                            tmp = *((unsigned short *)(p));\r
 +\r
 +                            r = (tmp >> 7) & 0xf8; r |= r >> 5;\r
 +                            g = (tmp >> 2) & 0xf8; g |= g >> 5;\r
 +                            b = (tmp << 3) & 0xf8; b |= b >> 5;\r
-                             *pix = 0xff000000 | (r << 16) | (g << 8) | (b);\r
++                            *pix = ARGB_JOIN(0xff, r, g, b);\r
 +                            p += 2;\r
 +                            if (p >= buffer_end) break;\r
 +                            pix++;\r
 +                         }\r
 +                       fix = (int)(((unsigned long)p) & 0x3);\r
 +                       if (fix > 0) p += 4 - fix; // align row read\r
 +                       if (p >= buffer_end) break;\r
 +                    }\r
 +               }\r
 +             else if (bit_count == 32)\r
 +               {\r
 +                  pix = surface;\r
 +                  for (y = 0; y < h; y++)\r
 +                    {\r
 +                       if (!right_way_up) pix = surface + ((h - 1 - y) * w);\r
 +                       for (x = 0; x < w; x++)\r
 +                         {\r
 +                            b = p[0];\r
 +                            g = p[1];\r
 +                            r = p[2];\r
 +                            a = p[3];\r
 +                            if (!hasa) a = 0xff;\r
-                             *pix = (a << 24) | (r << 16) | (g << 8) | (b);\r
++                            *pix = ARGB_JOIN(a, r, g, b);\r
 +                            p += 4;\r
 +                            if (p >= buffer_end) break;\r
 +                            pix++;\r
 +                         }\r
 +                       fix = (int)(((unsigned long)p) & 0x3);\r
 +                       if (fix > 0) p += 4 - fix; // align row read\r
 +                       if (p >= buffer_end) break;\r
 +                    }\r
 +               }\r
 +             else\r
 +               goto close_file;\r
 +          }\r
 +        else if (comp == 4) // jpeg - only printer drivers\r
 +          {\r
 +             goto close_file;\r
 +          }\r
 +        else if (comp == 3) // png - only printer drivers\r
 +          {\r
 +             goto close_file;\r
 +          }\r
 +        else\r
 +          goto close_file;\r
 +     }\r
 +   else\r
 +     goto close_file;\r
 +   \r
 +   if (buffer) free(buffer);\r
 +   fclose(f);\r
 +\r
 +   evas_common_image_premul(ie);\r
 +   *error = EVAS_LOAD_ERROR_NONE;\r
 +   return EINA_TRUE;\r
 +\r
 + close_file:\r
 +   if (buffer) free(buffer);\r
 +   fclose(f);\r
 +   return EINA_FALSE;\r
 +}\r
 +\r
 +static int\r
 +module_open(Evas_Module *em)\r
 +{\r
 +   if (!em) return 0;\r
 +   em->functions = (void *)(&evas_image_load_bmp_func);\r
 +   return 1;\r
 +}\r
 +\r
 +static void\r
- module_close(Evas_Module *em)\r
++module_close(Evas_Module *em __UNUSED__)\r
 +{\r
 +}\r
 +\r
 +static Evas_Module_Api evas_modapi =\r
 +{\r
 +   EVAS_MODULE_API_VERSION,\r
 +   "bmp",\r
 +   "none",\r
 +   {\r
 +     module_open,\r
 +     module_close\r
 +   }\r
 +};\r
 +\r
 +EVAS_MODULE_DEFINE(EVAS_MODULE_TYPE_IMAGE_LOADER, image_loader, bmp);\r
 +\r
 +#ifndef EVAS_STATIC_BUILD_BMP\r
 +EVAS_EINA_MODULE_DEFINE(image_loader, bmp);\r
 +#endif\r
index 313fe36,0000000..900bfcf
mode 100755,000000..100755
--- /dev/null
@@@ -1,219 -1,0 +1,208 @@@
- #define EVAS_WINK_MODULE_NAME wbmp
- #include "evas_wink.h"
 +#ifdef HAVE_CONFIG_H
 +# include <config.h>
 +#endif
 +
 +#ifdef HAVE_EVIL
 +# include <Evil.h>
 +#endif
 +
 +#include <stdio.h>
 +#include <sys/stat.h>
 +
 +#include "evas_common.h"
 +#include "evas_private.h"
 +
- #ifdef USE_WINK_CODEC
-    return evas_image_load_file_head_wbmp_wink(ie, file, key, error);
- #endif
 +static Eina_Bool evas_image_load_file_head_wbmp(Image_Entry *ie, const char *file, const char *key, int *error) EINA_ARG_NONNULL(1, 2, 4);
 +static Eina_Bool evas_image_load_file_data_wbmp(Image_Entry *ie, const char *file, const char *key, int *error) EINA_ARG_NONNULL(1, 2, 4);
 +
 +static Evas_Image_Load_Func evas_image_load_wbmp_func =
 +{
 +  EINA_TRUE,
 +  evas_image_load_file_head_wbmp,
 +  evas_image_load_file_data_wbmp
 +};
 +
 +
 +static int read_mb(unsigned int * data, FILE * f) {
 +   int ac = 0;
 +   int ct = 0;
 +   unsigned char buf;
 +
 +   while (1) {
 +      if ((ct++) == 6)
 +         return -1;
 +
 +      if ((fread(&buf, 1, 1, f)) < 1)
 +         return -1;
 +
 +      ac = (ac << 7) | (buf & 0x7f);
 +      if ((buf & 0x80) == 0)
 +         break;
 +   }
 +   *data = ac;
 +   return 0;
 +}
 +
 +static Eina_Bool
 +evas_image_load_file_head_wbmp(Image_Entry *ie, const char *file, const char *key __UNUSED__, int *error)
 +{
- #ifdef USE_WINK_CODEC
-    return evas_image_load_file_data_wbmp_wink(ie, file, key, error);
- #endif
 +   FILE          * f;
 +   unsigned int       type;
 +   unsigned char      fixed_header;
 +   unsigned int       width, height;
 +
 +   struct stat    statbuf;
 +
 +   *error = EVAS_LOAD_ERROR_GENERIC;
 +
 +   f = fopen(file, "rb");
 +   if (!f)
 +   {
 +      *error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;
 +      return EINA_FALSE;
 +   }
 +
 +   if (stat(file, &statbuf) == -1)
 +      goto bail0;
 + 
 +   if (read_mb(&type, f) < 0)
 +      goto bail0;
 +
 +   if (type != 0)
 +   {
 +      *error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT;
 +      goto bail0;
 +   }
 + 
 +   if (fread(&fixed_header, 1, 1, f) != 1)
 +      goto bail0;
 + 
 +   if (read_mb(&width, f) < 0)
 +      goto bail0;
 + 
 +   if (read_mb(&height, f) < 0)
 +      goto bail0;
 +
 +   fclose(f);
 +
 +   ie->w = width;
 +   ie->h = height;
 +
 +   *error = EVAS_LOAD_ERROR_NONE;
 +
 +   return EINA_TRUE;
 +
 +bail0:
 +   fclose(f);
 +
 +   return EINA_FALSE;
 +}
 +
 +static Eina_Bool
 +evas_image_load_file_data_wbmp(Image_Entry *ie, const char *file, const char *key __UNUSED__, int *error)
 +{
 +   FILE          * f;
 +   unsigned int       width, height;
 +   unsigned int       dummy;
 +   unsigned char      * line = NULL;
 +   unsigned int       line_length;
 +   int           cur = 0;
 +   int           i, j;
 +   DATA32        * dst_data;
 +
 +   *error = EVAS_LOAD_ERROR_GENERIC;
 +   
 +   f = fopen(file, "rb");
 +   if (!f)
 +   {
 +      *error = EVAS_LOAD_ERROR_DOES_NOT_EXIST;
 +      return EINA_FALSE;
 +   }
 +
 +   if (read_mb(&dummy, f) < 0)
 +      goto bail0;
 +   if (fread(&dummy, 1, 1, f) != 1)
 +      goto bail0;
 +   if (read_mb(&dummy, f) < 0)
 +      goto bail0;
 +   if (read_mb(&dummy, f) < 0)
 +      goto bail0;
 +
 +   width = ie->w;
 +   height = ie->h;
 +
 +   evas_cache_image_surface_alloc(ie, ie->w, ie->h);
 +   dst_data = evas_cache_image_pixels(ie);
 +   if (!dst_data)
 +   {
 +      *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
 +      goto bail0;
 +   }
 +   
 +   line_length = (width + 7) >> 3;
 +   line = (unsigned char *) malloc(line_length);
 +
 +   for(i=0;i<height;i++)
 +   {
 +      if (fread(line, 1, line_length, f) != line_length)
 +         goto bail0;
 +
 +      for(j=0;j<width;j++)
 +      {
 +         int idx = j >> 3;
 +         int offset = 1 << (0x07 - (j & 0x07));
 +         if (line[idx] & offset)
 +            dst_data[cur] = 0xFFFFFFFF;
 +         else
 +            dst_data[cur] = 0xFF000000;
 +         cur++;
 +      }
 +   }
 +
 +   if (line)
 +      free(line);
 +
 +   fclose(f);
 +
 +   *error = EVAS_LOAD_ERROR_NONE;
 +
 +   return EINA_TRUE;
 +
 +bail0:
 +   fclose(f);
 +
 +   if (line)
 +      free(line);
 +
 +   return EINA_FALSE;
 +}
 +
 +static int
 +module_open(Evas_Module *em)
 +{
 +   if (!em) return 0;
 +   em->functions = (void *)(&evas_image_load_wbmp_func);
 +   return 1;
 +}
 +
 +static void
 +module_close(Evas_Module *em)
 +{
 +}
 +
 +static Evas_Module_Api evas_modapi =
 +{
 +  EVAS_MODULE_API_VERSION,
 +  "wbmp",
 +  "none",
 +  {
 +    module_open,
 +    module_close
 +  }
 +};
 +
 +EVAS_MODULE_DEFINE(EVAS_MODULE_TYPE_IMAGE_LOADER, image_loader, wbmp);
 +
 +#ifndef EVAS_STATIC_BUILD_WBMP
 +EVAS_EINA_MODULE_DEFINE(image_loader, wbmp);
 +#endif