开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Windows Mobile > 查看源码
Image.cpp
资源名称：TextViewNG.rar　[点击查看]
上传用户：hmc_gdtv
上传日期：2013-08-04
资源大小：798k
文件大小：23k
源码类别：

Windows Mobile

开发平台：

Visual C++

Image.cpp：源码内容
  1. /*
  2.  * Copyright (c) 2001,2002,2003 Mike Matsnev.  All Rights Reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions
  6.  * are met:
  7.  *
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice immediately at the beginning of the file, without modification,
  10.  *    this list of conditions, and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. Absolutely no warranty of function or purpose is made by the author
  15.  *    Mike Matsnev.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  * 
  28.  * $Id: Image.cpp,v 1.12.2.7 2003/09/21 12:07:35 mike Exp $
  29.  * 
  30.  */
  32. // XXX handle out of memory exceptions gracefully
  34. #ifdef STANDALONE
  35. #include <windows.h>
  36. #else
  37. #include <afxwin.h>
  38. #endif
  40. #include <string.h>
  41. #include <stdlib.h>
  42. #include <setjmp.h>
  43. #include <math.h>
  45. extern "C" {
  46.   #include <jpeglib.h>
  47.   #include <jerror.h>
  48.   #include <png.h>
  49. };
  51. #include "ptr.h"
  52. #include "Image.h"
  54. #ifndef STANDALONE
  55. #include "config.h"
  56. #include "TextViewNG.h"
  57. #endif
  59. #define INBUF_SIZE    4096
  61. // supported bitmap formats
  62. enum {
  63.   BF_UNKNOWN,
  64.   BF_565,
  65.   BF_555,
  66.   BF_888
  67. };
  69. struct GXDisplayProperties {
  70. DWORD cxWidth;
  71. DWORD cyHeight; // notice lack of 'th' in the word height.
  72. long cbxPitch; // number of bytes to move right one x pixel - can be negative.
  73. long cbyPitch; // number of bytes to move down one y pixel - can be negative.
  74. long cBPP; // # of bits in each pixel
  75. DWORD ffFormat; // format flags.
  76. };
  78. #define kfDirect555 0x40 // 5 bits each for red, green and blue values in a pixel.
  79. #define kfDirect565 0x80 // 5 red bits, 6 green bits and 5 blue bits per pixel
  80. #define kfDirect888 0x100 // 8 bits each for red, green and blue values in a pixel.
  81. #define kfDirect444 0x200 // 4 red, 4 green, 4 blue
  83. typedef unsigned char u8;
  84. typedef unsigned int u32;
  85. typedef signed int s32;
  86. typedef unsigned short u16;
  88. static u8   gamma_table[256];
  90. static void set_gamma(double image_gamma) {
  91.   double    disp_gamma=
  92. #ifdef STANDALONE
  93.     1.8;
  94. #else
  95.     CTVApp::GetInt(_T("Gamma"),DEF_GAMMA)/1000000.0;
  96. #endif
  97.   if (disp_gamma<1)
  98.     disp_gamma=1;
  99.   if (disp_gamma>5)
  100.     disp_gamma=5;
  101.   double    g=1/(image_gamma*disp_gamma);
  102.   int     i;
  104.   for (i=0;i<256;++i)
  105.     gamma_table[i]=((int)(pow(i/256.0,g)*256.0));
  106. }
  108. // returns resized line with pixels scaled by inw
  109. static void resize_line_plain(u8 *in,u32 inw,u32 *out,u32 outw,u8 * /* bg */) {
  110.   u32   inptr=0; // input pixel position inside the output pixel
  111.   u32   outptr=inw;
  112.   u8   *top=in+inw*3; // pixel after the last
  114.   out[0]=out[1]=out[2]=0; // initialize first output pixel
  115.   do { // for each input pixel
  116.     if (inptr+outw>outptr) { // input pixel crosses two output pixels
  117.       // red
  118.       out[0] += in[0] * (outptr - inptr); // add to current pixel
  119.       out[3] = in[0] * (outw - (outptr - inptr)); // and initialize the next one
  120.       // green
  121.       out[1] += in[1] * (outptr - inptr); // add to current pixel
  122.       out[4] = in[1] * (outw - (outptr - inptr)); // and initialize the next one
  123.       // blue
  124.       out[2] += in[2] * (outptr - inptr); // add to current pixel
  125.       out[5] = in[2] * (outw - (outptr - inptr)); // and initialize the next one
  126.       // advance to next pixel
  127.       out += 3;
  128.       outptr += inw;
  129.     } else { // completely contained
  130.       out[0] += in[0] * outw;
  131.       out[1] += in[1] * outw;
  132.       out[2] += in[2] * outw;
  133.     }
  134.     in+=3; // next input pixel
  135.     inptr+=outw;
  136.   } while (in<top);
  137. }
  139. // returns resized line with pixels scaled by inw
  140. static void resize_line_alpha(u8 *in,u32 inw,u32 *out,u32 outw,u8 *bg) {
  141.   u32   inptr=0; // input pixel position inside the output pixel
  142.   u32   outptr=inw;
  143.   u8   *top=in+inw*4; // pixel after the last
  144.   u8   pval; // current pixel value
  145.   u8   transp;
  146.   u8   opacity;
  148.   out[0]=out[1]=out[2]=0; // initialize first output pixel
  149.   do { // for each input pixel
  150.     opacity = in[3];
  151.     transp = 255 - in[3];
  152.     if (inptr+outw>outptr) { // input pixel crosses two output pixels
  153.       // red
  154.       pval = (in[0]*opacity + bg[0]*transp)>>8;
  155.       out[0] += pval * (outptr - inptr); // add to current pixel
  156.       out[3] = pval * (outw - (outptr - inptr)); // and initialize the next one
  157.       // green
  158.       pval = (in[1]*opacity + bg[1]*transp)>>8;
  159.       out[1] += pval * (outptr - inptr); // add to current pixel
  160.       out[4] = pval * (outw - (outptr - inptr)); // and initialize the next one
  161.       // blue
  162.       pval = (in[2]*opacity + bg[2]*transp)>>8;
  163.       out[2] += pval * (outptr - inptr); // add to current pixel
  164.       out[5] = pval * (outw - (outptr - inptr)); // and initialize the next one
  165.       // advance to next pixel
  166.       out += 3;
  167.       outptr += inw;
  168.     } else { // completely contained
  169.       out[0] += ((in[0]*opacity + bg[0]*transp) * outw) >> 8;
  170.       out[1] += ((in[1]*opacity + bg[1]*transp) * outw) >> 8;
  171.       out[2] += ((in[2]*opacity + bg[2]*transp) * outw) >> 8;
  172.     }
  173.     in+=4; // next input pixel
  174.     inptr+=outw;
  175.   } while (in<top);
  176. }
  178. struct imagestore {
  179.   HBITMAP bmp;
  181.   u8   *bits;
  182.   int   hstep;
  183.   int   vstep;
  184.   u32   width;
  185.   u32   height;
  186.   u32   realwidth;
  187.   u32   realheight;
  188.   int   bmformat;
  189.   void   (*packbits)(imagestore *is,u8* src);
  190. };
  192. struct resize_state {
  193.   u32   *accum;
  194.   u32   *lb;
  195.   s32   *error;
  196.   s32   *nexterror;
  197.   u32   inptr;
  198.   u32   outptr;
  199.   u8   *dest;
  200.   u32   inw,inh;
  201.   u32   outw,outh;
  202.   u32   outscale;
  203.   u32   inscale;
  204.   s32   max;
  205.   u32   mask[3];
  206.   u32   *membuf;
  207.   int   odd;
  208.   u8   bg[4]; // background color for transparent images
  209.   // we store a function pointer here to handle transparency properly
  210.   void   (*resize_line)(u8 *in,u32 inw,u32 *out,u32 outw,u8 *bg);
  211.   imagestore  *output;
  212. };
  214. static void packbits_24_to_15(imagestore *is,u8 *src) {
  215.   u32   i;
  216.   u8   *bits=is->bits;
  217.   s32   hstep=is->hstep;
  218.   u32   width=is->width;
  220.   for (i=0;i<width;++i) {
  221.     *(u16*)bits=((u16)(gamma_table[src[0]]&0xF8)<<7)|
  222.       ((u16)(gamma_table[src[1]]&0xF8)<<2)|
  223.       (gamma_table[src[2]]>>3);
  224.     src+=3;
  225.     bits+=hstep;
  226.   }
  227.   is->bits+=is->vstep;
  228. }
  230. static void packbits_24_to_16(imagestore *is,u8 *src) {
  231.   u32   i;
  232.   u8   *bits=is->bits;
  233.   s32   hstep=is->hstep;
  234.   u32   width=is->width;
  236.   for (i=0;i<width;++i) {
  237.     *(u16*)bits=((u16)(gamma_table[src[0]]&0xF8)<<8)|
  238.       ((u16)(gamma_table[src[1]]&0xFC)<<3)|
  239.       (gamma_table[src[2]]>>3);
  240.     src+=3;
  241.     bits+=hstep;
  242.   }
  243.   is->bits+=is->vstep;
  244. }
  246. static void packbits_24_to_24(imagestore *is,u8 *src) {
  247.   u32   i;
  248.   u8   *bits=is->bits;
  249.   s32   hstep=is->hstep;
  250.   u32   width=is->width;
  252.   for (i=0;i<width;i++) {
  253.     bits[0]=gamma_table[src[2]];
  254.     bits[1]=gamma_table[src[1]];
  255.     bits[2]=gamma_table[src[0]];
  256.     src+=3;
  257.     bits+=hstep;
  258.   }
  259.   is->bits+=is->vstep;
  260. }
  262. static bool resize_state_init(resize_state *rs,u32 iinw,u32 iinh,imagestore *iout)
  263. {
  264.   rs->output=iout;
  265.   rs->inw=iinw;
  266.   rs->inh=iinh;
  267.   rs->outw=iout->width;
  268.   rs->outh=iout->height;
  269.   u32 *p=(u32*)malloc(sizeof(u32)*13*(rs->outw+2));
  270.   if (!p)
  271.     return false;
  272.   memset(p,0,sizeof(u32)*(6*rs->outw+6*(rs->outw+2)+rs->outw));
  273.   rs->membuf=p;
  274.   rs->odd=0;
  275.   switch (iout->bmformat) {
  276.   case BF_555:
  277.     rs->mask[0]=rs->mask[1]=rs->mask[2]=0xfffffff8;
  278.     break;
  279.   case BF_565:
  280.     rs->mask[0]=0xfffffff8;
  281.     rs->mask[1]=0xfffffffc;
  282.     rs->mask[2]=0xfffffff8;
  283.     break;
  284.   case BF_888:
  285.     rs->mask[0]=rs->mask[1]=rs->mask[2]=0xffffffff;
  286.     break;
  287. #ifndef STANDALONE
  288.   default:
  289.     ASSERT(0);
  290. #endif
  291.   }
  292.   rs->inptr=0;
  293.   rs->outptr=rs->inh;
  294.   rs->accum=p; p+=3*(rs->outw+2);
  295.   rs->lb=p; p+=3*(rs->outw+2);
  296.   rs->nexterror=(s32*)p+3; p+=3*(rs->outw+2);
  297.   rs->error=(s32*)p+3; p+=3*(rs->outw+2);
  298.   rs->dest=(u8*)p; p+=rs->outw;
  299.   rs->outscale=(u32)(4294967296.0/(rs->inw*rs->inh));
  300.   rs->inscale=rs->inw*rs->inh;
  301.   rs->max=rs->inscale*256-1;
  302.   rs->resize_line=resize_line_plain;
  303.   return true;
  304. }
  306. static void resize_set_alpha(resize_state *rs,COLORREF bg) {
  307.   rs->resize_line=resize_line_alpha;
  308.   rs->bg[0]=GetRValue(bg);
  309.   rs->bg[1]=GetGValue(bg);
  310.   rs->bg[2]=GetBValue(bg);
  311. }
  313. static void resize_state_destroy(resize_state *rs) {
  314.   if (rs) {
  315.     free(rs->membuf);
  316.     free(rs);
  317.   }
  318. }
  320. static resize_state *resize_state_create(u32 iinw,u32 iinh,imagestore *out) {
  321.   resize_state *rs=(resize_state *)malloc(sizeof(resize_state));
  322.   if (rs && resize_state_init(rs,iinw,iinh,out))
  323.     return rs;
  324.   free(rs);
  325.   return NULL;
  326. }
  328. __inline s32 CLIP(s32 v,s32 m) {
  329.   return v<0 ? 0 : v>m ? m : v;
  330. }
  332. #define CLIPADD(rs,i,n) CLIP(rs->lb[i+n]+rs->error[i+n],rs->max)
  333. #define M64(a,b,m) ((unsigned int)(((__int64)(a)*(b))>>32)&(m))
  334. #define PIXEL_EVEN(rs,i,c) 
  335.   u = CLIPADD(rs,i,c); 
  336.   v = M64(u,rs->outscale,rs->mask[c]); 
  337.   e = u - v*rs->inscale; 
  338.   rs->error[i+3+c] += (e*7)>>4; 
  339.   rs->nexterror[i-3+c] += (e*3)>>4; 
  340.   rs->nexterror[i+0+c] += (e*5)>>4; 
  341.   rs->nexterror[i+3+c] += e>>4; 
  342.   rs->dest[i+c] = v;
  343. #define PIXEL_ODD(rs,i,c) 
  344.   u = CLIPADD(rs,i,c); 
  345.   v = M64(u,rs->outscale,rs->mask[c]); 
  346.   e = u-v*rs->inscale; 
  347.   rs->error[i-3+c] += (e*7)>>4; 
  348.   rs->nexterror[i+3+c] += (e*3)>>4; 
  349.   rs->nexterror[i+0+c] += (e*5)>>4; 
  350.   rs->nexterror[i-3+c] += e>>4; 
  351.   rs->dest[i+c]=v;
  353. // dither lb into dest, left to right
  354. void resize_dither_even(struct resize_state *rs) {
  355.   u32   i;
  356.   s32   u,v,e;
  358.   for (i=0;i<3*rs->outw;i+=3) {
  359.     PIXEL_EVEN(rs,i,0);
  360.     PIXEL_EVEN(rs,i,1);
  361.     PIXEL_EVEN(rs,i,2);
  362.   }
  363. }
  365. // dither lb into dest, right to left
  366. void resize_dither_odd(struct resize_state *rs) {
  367.   s32   i;
  368.   s32   u,v,e;
  370.   for (i=3*rs->outw-3;i>=0;i-=3) {
  371.     PIXEL_ODD(rs,i,0);
  372.     PIXEL_ODD(rs,i,1);
  373.     PIXEL_ODD(rs,i,2);
  374.   }
  375. }
  377. // dither lb into dest
  378. void  resize_dither(struct resize_state *rs) {
  379.   s32   *tmp;
  381.   if (rs->odd)
  382.     resize_dither_odd(rs);
  383.   else
  384.     resize_dither_even(rs);
  385.   tmp=rs->error;
  386.   rs->error=rs->nexterror;
  387.   rs->nexterror=tmp;
  388.   memset(tmp,0,sizeof(s32)*3*rs->outw);
  389.   rs->odd=!rs->odd;
  390.   rs->output->packbits(rs->output,rs->dest);
  391. }
  393. void resize_add_line(struct resize_state *rs,u8 *line) {
  394.   u32   i;
  396.   // resize the line horizontally
  397.   rs->resize_line(line,rs->inw,rs->lb,rs->outw,rs->bg);
  398.   // perform one loop iteration
  399.   if (rs->inptr+rs->outh>=rs->outptr) {
  400.     u32     c1=rs->outptr-rs->inptr;
  401.     u32     c2=rs->outh-c1;
  402.     u32     v;
  403.     for (i=0;i<3*rs->outw;i+=3) {
  404.       v = rs->accum[i+0]+rs->lb[i+0]*c1;
  405.       rs->accum[i+0] = rs->lb[i+0]*c2;
  406.       rs->lb[i+0] = v;
  407.       v = rs->accum[i+1]+rs->lb[i+1]*c1;
  408.       rs->accum[i+1] = rs->lb[i+1]*c2;
  409.       rs->lb[i+1] = v;
  410.       v = rs->accum[i+2]+rs->lb[i+2]*c1;
  411.       rs->accum[i+2] = rs->lb[i+2]*c2;
  412.       rs->lb[i+2] = v;
  413.     }
  414.     resize_dither(rs);
  415.     rs->outptr+=rs->inh;
  416.   } else {
  417.     for (i=0;i<3*rs->outw;i+=3) {
  418.       rs->accum[i+0] += rs->lb[i+0]*rs->outh;
  419.       rs->accum[i+1] += rs->lb[i+1]*rs->outh;
  420.       rs->accum[i+2] += rs->lb[i+2]*rs->outh;
  421.     }
  422.   }
  423.   rs->inptr+=rs->outh;
  424. }
  426. struct my_src_mgr {
  427.   struct jpeg_source_mgr  pub;
  428.   ImageLoader::BinReader  *rdr;
  429.   JOCTET   *buffer;
  430. };
  432. METHODDEF(void) jsrc_init_source (j_decompress_ptr cinfo) {
  433.   // do nothing
  434. }
  436. METHODDEF(boolean) jsrc_fill_input_buffer (j_decompress_ptr cinfo) {
  437.   my_src_mgr *mgr=(my_src_mgr*)cinfo->src;
  439.   int   nr=mgr->rdr->Read(mgr->buffer,INBUF_SIZE);
  440.   if (nr<=0) { // eof
  441.     // fake EOI marker
  442.     mgr->buffer[0]=(JOCTET)0xff;
  443.     mgr->buffer[1]=(JOCTET)JPEG_EOI;
  444.     nr=2;
  445.   }
  446.   mgr->pub.bytes_in_buffer=nr;
  447.   mgr->pub.next_input_byte=mgr->buffer;
  448.   return TRUE;
  449. }
  451. METHODDEF(void) jsrc_skip_input_data (j_decompress_ptr cinfo, long bytes) {
  452.   my_src_mgr *mgr=(my_src_mgr*)cinfo->src;
  454.   if (bytes > 0) {
  455.     while (bytes > (long) mgr->pub.bytes_in_buffer) {
  456.       bytes -= (long) mgr->pub.bytes_in_buffer;
  457.       jsrc_fill_input_buffer(cinfo);
  458.       /* note we assume that fill_input_buffer will never return FALSE,
  459.        * so suspension need not be handled.
  460.        */
  461.     }
  462.     mgr->pub.next_input_byte += (size_t) bytes;
  463.     mgr->pub.bytes_in_buffer -= (size_t) bytes;
  464.   }
  465. }
  467. METHODDEF(void) jsrc_term_source(j_decompress_ptr cinfo) {
  468.   // do nothing
  469. }
  471. static void prepare_buffer(j_decompress_ptr cinfo,ImageLoader::BinReader *rdr) {
  472.   my_src_mgr  *mgr;
  474.   if (cinfo->src==NULL) {
  475.     cinfo->src=(struct jpeg_source_mgr *)
  476.       (cinfo->mem->alloc_small((j_common_ptr)cinfo,JPOOL_PERMANENT,
  477. sizeof(my_src_mgr)));
  478.     mgr=(my_src_mgr*)cinfo->src;
  479.     mgr->buffer=(JOCTET*)
  480.       (cinfo->mem->alloc_small((j_common_ptr)cinfo,JPOOL_PERMANENT,
  481. INBUF_SIZE*sizeof(JOCTET)));
  482.   }
  483.   mgr=(my_src_mgr*)cinfo->src;
  484.   mgr->rdr=rdr;
  485.   mgr->pub.init_source=jsrc_init_source;
  486.   mgr->pub.fill_input_buffer=jsrc_fill_input_buffer;
  487.   mgr->pub.skip_input_data=jsrc_skip_input_data;
  488.   mgr->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
  489.   mgr->pub.term_source=jsrc_term_source;
  490.   mgr->pub.bytes_in_buffer=0;
  491.   mgr->pub.next_input_byte=NULL;
  492. }
  494. struct my_error_mgr {
  495.   struct jpeg_error_mgr   pub;
  496.   jmp_buf   jb;
  497. };
  499. METHODDEF(void) je_error_exit(j_common_ptr cinfo) {
  500.   my_error_mgr   *mgr=(my_error_mgr*)cinfo->err;
  501.   /* Always display the message */
  502.   (*cinfo->err->output_message) (cinfo);
  503.   jpeg_destroy(cinfo);
  504.   longjmp(mgr->jb,1);
  505. }
  507. METHODDEF(void) je_output_message(j_common_ptr cinfo) {
  508.   char buffer[JMSG_LENGTH_MAX];
  509.   /* Create the message */
  510.   (*cinfo->err->format_message) (cinfo, buffer);
  511.   // do nothing at this time
  512. #if 0
  513.   MessageBoxA(GetActiveWindow(),buffer,"JPEG Decompressor",MB_OK);
  514. #endif
  515. }
  517. static void PNGAPI pngr_read_data(png_structp png_ptr,png_bytep data,png_size_t length) {
  518.   ImageLoader::BinReader  *rdr=(ImageLoader::BinReader*)png_get_io_ptr(png_ptr);
  519.   if (!rdr || rdr->Read(data,length)!=(int)length)
  520.     png_error(png_ptr,"Read Error");
  521. }
  523. static int  get_bitmap_format() {
  524.   static int     format=BF_UNKNOWN;
  526. #ifdef _WIN32_WCE
  527.   if (format!=BF_UNKNOWN)
  528.     return format;
  530.   HINSTANCE hLib;
  532.   if ((hLib=LoadLibrary(_T("gx.dll")))!=NULL) {
  533.     GXDisplayProperties (*gp)();
  534.     gp=(GXDisplayProperties (*)())GetProcAddress(hLib,
  535.       _T("?GXGetDisplayProperties@@YA?AUGXDisplayProperties@@XZ"));
  536.     if (gp) {
  537.       GXDisplayProperties props=gp();
  538.       if (props.ffFormat&kfDirect555)
  539. format=BF_555;
  540.       else if (props.ffFormat&kfDirect565)
  541. format=BF_565;
  542.       else
  543. format=BF_888;
  544.     }
  545.     FreeLibrary(hLib);
  546.   }
  547. #endif
  548.   if (format!=BF_UNKNOWN)
  549.     return format;
  550.   HDC hDC=GetDC(NULL);
  551.   if (GetDeviceCaps(hDC,BITSPIXEL)==16)
  552.     format=BF_565;
  553.   else
  554.     format=BF_888;
  555.   ReleaseDC(NULL,hDC);
  556.   return format;
  557. }
  559. static imagestore *bminit(HDC hDC,int w,int h,int maxw,int maxh,int rotate)
  560. {
  561.   struct {
  562.     BITMAPINFOHEADER  h;
  563.     DWORD       masks[3];
  564.   } bi;
  565.   imagestore *im=(imagestore*)malloc(sizeof(imagestore));
  566.   if (!im)
  567.     return NULL;
  568.   void *data;
  569.   int bpp;
  570.   s32 rowstep;
  572.   im->bmformat=get_bitmap_format();
  573.   memset(&bi,0,sizeof(bi));
  574.   switch (im->bmformat) {
  575.   case BF_555:
  576.     bpp=2;
  577.     bi.masks[0]=0x7C00;
  578.     bi.masks[1]=0x03E0;
  579.     bi.masks[2]=0x001F;
  580.     bi.h.biCompression=BI_BITFIELDS;
  581.     im->packbits=packbits_24_to_15;
  582.     break;
  583.   case BF_565:
  584.     bpp=2;
  585.     bi.masks[0]=0xF800;
  586.     bi.masks[1]=0x07E0;
  587.     bi.masks[2]=0x001F;
  588.     bi.h.biCompression=BI_BITFIELDS;
  589.     im->packbits=packbits_24_to_16;
  590.     break;
  591.   case BF_888:
  592.     bpp=3;
  593. #ifdef _WIN32_WCE
  594.     bi.masks[0]=0xFF0000;
  595.     bi.masks[1]=0x00FF00;
  596.     bi.masks[2]=0x0000FF;
  597.     bi.h.biCompression=BI_BITFIELDS;
  598. #else
  599.     bi.h.biCompression=BI_RGB;
  600. #endif
  601.     im->packbits=packbits_24_to_24;
  602.     break;
  603. #ifndef STANDALONE
  604.   default:
  605.     ASSERT(0);
  606. #endif
  607.   }
  608.   if (w<=maxw && h<=maxh) {
  609.     im->width=w;
  610.     im->height=h;
  611.   } else {
  612.     if (maxw*h<maxh*w) {
  613.       im->width=maxw;
  614.       im->height=(h*maxw)/w;
  615.     } else {
  616.       im->width=(w*maxh)/h;
  617.       im->height=maxh;
  618.     }
  619.   }
  620.   if (rotate==0 || rotate==1800) {
  621.     im->realheight=im->height;
  622.     im->realwidth=im->width;
  623.   } else {
  624.     im->realheight=im->width;
  625.     im->realwidth=im->height;
  626.   }
  627.   if (!hDC)
  628.     return im;
  629.   rowstep=(im->realwidth*bpp+3)&~3;
  630.   bi.h.biSize=sizeof(bi.h);
  631.   bi.h.biWidth=im->realwidth;
  632.   bi.h.biHeight=im->realheight;
  633.   bi.h.biPlanes=1;
  634.   bi.h.biBitCount=bpp==2 ? 16 : 24;
  635.   if (!(im->bmp=CreateDIBSection(hDC,(BITMAPINFO*)&bi,DIB_RGB_COLORS,&data,NULL,0))) {
  636.     DWORD err=GetLastError();
  637.     free(im);
  638.     return NULL;
  639.   }
  640.   switch (rotate) {
  641.   case 2700:
  642.     im->hstep=-rowstep;
  643.     im->vstep=-bpp;
  644.     im->bits=(u8*)data+bpp*(im->realwidth-1)+rowstep*(im->realheight-1);
  645.     break;
  646.   case 1800:
  647.     im->hstep=-bpp;
  648.     im->vstep=rowstep;
  649.     im->bits=(u8*)data+bpp*(im->realwidth-1);
  650.     break;
  651.   case 900:
  652.     im->hstep=rowstep;
  653.     im->vstep=bpp;
  654.     im->bits=(u8*)data;
  655.     break;
  656.   case 0:
  657.     im->hstep=bpp;
  658.     im->vstep=-rowstep;
  659.     im->bits=(u8*)data+rowstep*(im->realheight-1);
  660.     break;
  661. #ifndef STANDALONE
  662.   default:
  663.     ASSERT(0);
  664. #endif
  665.   }
  666.   return im;
  667. }
  669. bool ImageLoader::Load(HDC hDC,const wchar_t *type,ImageLoader::BinReader *rdr,
  670.   int maxwidth,int maxheight,int rotation,HBITMAP& bmp,
  671.   int& width,int& height)
  672. {
  673.   imagestore     *is=NULL;
  674.   resize_state     *rs=NULL;
  676.   set_gamma(0.45455);
  677.   if (!wcscmp(type,L"image/jpeg")) { // only jpeg images are supported at the time
  678.     struct jpeg_decompress_struct   cinfo;
  679.     struct my_error_mgr     jerr;
  681.     cinfo.err=jpeg_std_error(&jerr.pub);
  682.     jerr.pub.error_exit=je_error_exit;
  683.     jerr.pub.output_message=je_output_message;
  684.     if (setjmp(jerr.jb))
  685.       goto common_exit;
  686.     jpeg_create_decompress(&cinfo);
  687.     prepare_buffer(&cinfo,rdr);
  688.     jpeg_read_header(&cinfo,TRUE);
  689.     // do some scaling
  690.     int scale,iw;
  691.     for (scale=1,iw=cinfo.image_width;scale<8;scale<<=1,iw>>=1)
  692.       if ((iw>>1)<maxwidth)
  693. break;
  694.     cinfo.scale_denom=scale;
  695.     cinfo.out_color_space=JCS_RGB;
  696.     jpeg_calc_output_dimensions(&cinfo);
  697.     is=bminit(hDC,cinfo.output_width,cinfo.output_height,maxwidth,maxheight,rotation);
  698.     if (is && hDC) {
  699.       if (is->width!=cinfo.output_width || is->height!=cinfo.output_height) {
  700. rs=resize_state_create(cinfo.output_width,cinfo.output_height,is);
  701. if (!rs)
  702.   goto outjpg;
  703.       }
  704.       jpeg_start_decompress(&cinfo);
  705.       JSAMPARRAY  line=cinfo.mem->alloc_sarray((j_common_ptr)&cinfo,
  706. JPOOL_IMAGE,cinfo.output_width*cinfo.output_components,
  707. 1);
  708.       if (rs) {
  709. while (cinfo.output_scanline<cinfo.output_height) {
  710.   jpeg_read_scanlines(&cinfo,line,1);
  711.   resize_add_line(rs,line[0]);
  712. }
  713.       } else {
  714. while (cinfo.output_scanline<cinfo.output_height) {
  715.   jpeg_read_scanlines(&cinfo,line,1);
  716.   is->packbits(is,line[0]);
  717. }
  718.       }
  719.       jpeg_finish_decompress(&cinfo);
  720.     }
  721. outjpg:
  722.     jpeg_destroy_decompress(&cinfo);
  723.   } else if (!wcscmp(type,L"image/png")) {
  724.     // create png read structures
  725.     png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,NULL,NULL,NULL);
  726.     if (!png_ptr) // out of memory?
  727.       return false;
  728.     png_infop info_ptr = png_create_info_struct(png_ptr);
  729.     if (!info_ptr) { // out of memory?
  730.       png_destroy_read_struct(&png_ptr,NULL,NULL);
  731.       return false;
  732.     }
  733.     // setup i/o routine
  734.     png_set_read_fn(png_ptr,rdr,pngr_read_data);
  736.     // init jmpbuf
  737.     if (setjmp(png_jmpbuf(png_ptr))) { // error occurred
  738.       png_destroy_read_struct(&png_ptr,&info_ptr,NULL);
  739.       goto common_exit;
  740.     }
  741.     png_read_info(png_ptr,info_ptr);
  742.     png_uint_32 width,height;
  743.     int bit_depth,color_type,interlace_type;
  744.     png_get_IHDR(png_ptr,info_ptr,&width,&height,&bit_depth,&color_type,
  745.  &interlace_type,NULL,NULL);
  746.     if (interlace_type!=PNG_INTERLACE_NONE) {
  747.       png_destroy_read_struct(&png_ptr,&info_ptr,NULL);
  748.       return false;
  749.     }
  750.     // configure transformations, we always want RGB data in the end
  751.     if (color_type == PNG_COLOR_TYPE_PALETTE)
  752.       png_set_palette_to_rgb(png_ptr);
  753.     if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
  754.       png_set_gray_1_2_4_to_8(png_ptr);
  755.     if (png_get_valid(png_ptr, info_ptr,PNG_INFO_tRNS))
  756.       png_set_tRNS_to_alpha(png_ptr);
  757.     if (bit_depth == 16)
  758.       png_set_strip_16(png_ptr);
  759.     if (bit_depth < 8)
  760.       png_set_packing(png_ptr);
  761.     if (color_type == PNG_COLOR_TYPE_GRAY ||
  762.         color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  763.       png_set_gray_to_rgb(png_ptr);
  765.     // update info after applying transformations
  766.     png_read_update_info(png_ptr,info_ptr);
  768.     // reload info
  769.     png_get_IHDR(png_ptr,info_ptr,&width,&height,&bit_depth,&color_type,
  770.  &interlace_type,NULL,NULL);
  772.     // ok, now configure storer and resizer
  773.     is=bminit(hDC,width,height,maxwidth,maxheight,rotation);
  774.     if (is && hDC) {
  775.       if (is->width!=width || is->height!=height) {
  776. rs=resize_state_create(width,height,is);
  777. if (!rs)
  778.   goto outpng;
  779.       }
  781.       // handle transparency
  782.       if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
  783. // create a resizer, because we use it to apply
  784. // transparency
  785. if (!rs) {
  786.   rs=resize_state_create(width,height,is);
  787.   if (!rs)
  788.     goto outpng;
  789. }
  791. png_color_16p image_background;
  792. if (png_get_bKGD(png_ptr, info_ptr, &image_background))
  793.   resize_set_alpha(rs,RGB(image_background->red>>8,
  794.   image_background->green>>8,
  795.   image_background->blue>>8));
  796. else
  797.   resize_set_alpha(rs,::GetBkColor(hDC));
  798.       }
  800.       // now read the image line by line
  801.       int rowbytes=png_get_rowbytes(png_ptr,info_ptr);
  802.       unsigned char *row=(unsigned char *)malloc(rowbytes);
  803.       if (!row)
  804. goto outpng;
  805.       if (rs) {
  806. for (int i=0;i<(int)height;++i) {
  807.   png_read_row(png_ptr,row,NULL);
  808.   resize_add_line(rs,row);
  809. }
  810.       } else {
  811. for (int i=0;i<(int)height;++i) {
  812.   png_read_row(png_ptr,row,NULL);
  813.   is->packbits(is,row);
  814. }
  815.       }
  816.       // destroy read struct
  817.       free(row);
  818.       png_read_end(png_ptr,NULL);
  819.     }
  820. outpng:
  821.     png_destroy_read_struct(&png_ptr,&info_ptr,NULL);
  822.   } else
  823.     return false;
  824. common_exit:
  825.   if (is) {
  826.     bmp=is->bmp;
  827.     width=is->width;
  828.     height=is->height;
  829.   }
  830.   resize_state_destroy(rs);
  831.   free(is);
  832.   return is!=NULL;
  833. }