diff options
author | Chris Xiong <chirs241097@gmail.com> | 2018-02-03 00:55:26 +0800 |
---|---|---|
committer | Chris Xiong <chirs241097@gmail.com> | 2018-02-03 00:55:26 +0800 |
commit | 1eb88d4f5d5cb05d62be1d4a0c88c7399f7c0de0 (patch) | |
tree | 4daf8fa3f4e8fff38a61b8e2da752df8b519f232 /smelt | |
parent | 6f955e10a71e364f527ea654156ea83785e9ada8 (diff) | |
download | SMELT-1eb88d4f5d5cb05d62be1d4a0c88c7399f7c0de0.tar.xz |
Added the GL 3.2+ port.
Fixed poor performance of the truetype renderer.
(Partially) Fixed texture locking.
Minor addition and fixes to the math library.
Diffstat (limited to 'smelt')
72 files changed, 2491 insertions, 28341 deletions
diff --git a/smelt/glfw/gfx_glfw.cpp b/smelt/glfw/gfx_glfw.cpp index 29841e9..485760d 100644 --- a/smelt/glfw/gfx_glfw.cpp +++ b/smelt/glfw/gfx_glfw.cpp @@ -538,11 +538,12 @@ void SMELT_IMPL::smTexutreUnlock(SMTEX tex) if(!ptex->locpx)return; if(!ptex->roloc) { - DWORD *src=ptex->locpx,*dst=ptex->px+((ptex->locy*ptex->rw)+ptex->locx); - for(int i=0;i<ptex->loch;++i)//TODO: flip it... + DWORD *src=ptex->locpx+ptex->locw*ptex->loch, + *dst=ptex->px+(((ptex->rh-ptex->locy-1)*ptex->rw)+ptex->locx); + for(int i=0;i<ptex->loch;++i) { memcpy(dst,src,ptex->locw*sizeof(DWORD)); - dst+=ptex->rw;src+=ptex->locw; + dst-=ptex->rw;src-=ptex->locw; } if(ptex->lost)configTexture(ptex,ptex->rw,ptex->rh,ptex->px); else diff --git a/smelt/glfw_m/CxImage b/smelt/glfw_m/CxImage new file mode 120000 index 0000000..07300ae --- /dev/null +++ b/smelt/glfw_m/CxImage @@ -0,0 +1 @@ +../glfw/CxImage
\ No newline at end of file diff --git a/smelt/glfw_m/gfx_glfw.cpp b/smelt/glfw_m/gfx_glfw.cpp new file mode 100644 index 0000000..ebd24bf --- /dev/null +++ b/smelt/glfw_m/gfx_glfw.cpp @@ -0,0 +1,1045 @@ +// -*- C++ -*- +/* + * Simple MultimEdia LiTerator(SMELT) + * by Chris Xiong 2015 + * GFX implementation based on GLFW/OpenGL 3.2+ + * + * WARNING: This library is in development and interfaces would be very + * unstable. + * + */ +#include "smelt_internal.hpp" +#include "CxImage/ximage.h" +#include "smmath_priv.hpp" +#define dbg printf("%d: 0x%X\n",__LINE__,glGetError()) +static const char* GFX_GLFW_SRCFN="smelt/glfw_m/gfx_glfw.cpp"; +static const char* fixedfunc_pipeline_vsh= + "#version 330 core\n" + "layout (location=0) in vec3 vp;" + "layout (location=1) in vec4 vc;" + "layout (location=2) in vec2 vtc;" + "out vec4 fc;" + "out vec2 ftc;" + "uniform mat4 mmodv;" + "uniform mat4 mproj;" + "void main(){" + "gl_Position=mproj*mmodv*vec4(vp,1.0f);" + "ftc=vec2(vtc.x,1.0f-vtc.y);"//do flipping at a lower level + "fc=vc;" + "}" +; +static const char* fixedfunc_pipeline_fsh= + "#version 330 core\n" + "in vec4 fc;" + "in vec2 ftc;" + "out vec4 color;" + "uniform sampler2D tex;" + "void main(){" + "color=fc*texture(tex,ftc);" + "if(color.a<1./256.)discard;"//alpha testing + "}" +; +struct glTexture +{ + GLuint name,rw,rh,dw,dh; + const char *fn; + DWORD *px,*locpx; + bool isTarget,lost,roloc; + GLint locx,locy,locw,loch; +}; +bool SMELT_IMPL::smRenderBegin2D(bool ztest,SMTRG trg) +{ + TRenderTargetList *targ=(TRenderTargetList*)trg; + if(vertexArray) + {smLog("%s:" SLINE ": Last frame not closed.\n",GFX_GLFW_SRCFN);return false;} + glBindFramebuffer(GL_FRAMEBUFFER,(targ)?targ->frame:0); + glDepthFunc(GL_GEQUAL); + ztest?glEnable(GL_DEPTH_TEST):glDisable(GL_DEPTH_TEST); + zbufenabled=ztest; + if(targ) + { + glScissor(0,0,targ->w,targ->h); + glViewport(0,0,targ->w,targ->h); + configProjectionMatrix2D(targ->w,targ->h); + } + else + { + glScissor(0,0,scrw,scrh); + glViewport(0,0,scrw,scrh); + configProjectionMatrix2D(scrw,scrh); + } + sm2DCamera5f3v(NULL,NULL,NULL); + curTarget=targ;tdmode=0; + vertexArray=vertexBuf; + return true; +} +bool SMELT_IMPL::smRenderBegin3D(float fov,bool ztest,SMTRG trg) +{ + TRenderTargetList *targ=(TRenderTargetList*)trg; + if(vertexArray) + {smLog("%s:" SLINE ": Last frame not closed.\n",GFX_GLFW_SRCFN);return false;} + glBindFramebuffer(GL_FRAMEBUFFER,(targ)?targ->frame:0); + glDepthFunc(GL_LESS); + ztest?glEnable(GL_DEPTH_TEST):glDisable(GL_DEPTH_TEST); + zbufenabled=ztest; + if(targ) + { + glScissor(0,0,targ->w,targ->h); + glViewport(0,0,targ->w,targ->h); + configProjectionMatrix3D(targ->w,targ->h,fov); + } + else + { + glScissor(0,0,scrw,scrh); + glViewport(0,0,scrw,scrh); + configProjectionMatrix3D(scrw,scrh,fov); + } + sm3DCamera6f2v(NULL,NULL); + curTarget=targ;tdmode=1; + vertexArray=vertexBuf; + return true; +} +bool SMELT_IMPL::smRenderEnd() +{ + batchOGL(true); + if(curTarget&&curTarget->ms) + { + glTexture *pTex=(glTexture*)curTarget->tex; + if(pTex&&pTex->lost) + configTexture(pTex,pTex->rw,pTex->rh,pTex->px); + int w=curTarget->w,h=curTarget->h; + glFinish(); + DWORD *px=new DWORD[w*h]; + glBindFramebuffer(GL_READ_FRAMEBUFFER,curTarget->frame); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER,curTarget->sframe); + glBlitFramebuffer(0,0,w,h,0,0,w,h,GL_COLOR_BUFFER_BIT,GL_NEAREST); + glBindFramebuffer(GL_FRAMEBUFFER,curTarget->sframe); + glReadPixels(0,0,w,h,GL_RGBA,GL_UNSIGNED_BYTE,px); + glBindTexture(GL_TEXTURE_2D,pTex->name); + glTexSubImage2D(GL_TEXTURE_2D,0,0,0,w,h,GL_RGBA,GL_UNSIGNED_BYTE,px); + glBindTexture(GL_TEXTURE_2D,primTex?(((glTexture*)primTex)->name):0); + delete[] px; + } + if(!curTarget)glfwSwapBuffers((GLFWwindow*)hwnd); + return true; +} +void SMELT_IMPL::smClrscr(DWORD color,bool clearcol,bool cleardep) +{ + GLfloat a=(GLfloat)(GETA(color))/255.f; + GLfloat r=(GLfloat)(GETR(color))/255.f; + GLfloat g=(GLfloat)(GETG(color))/255.f; + GLfloat b=(GLfloat)(GETB(color))/255.f; + if(clearcol) + glClearColor(r,g,b,a); + if(tdmode)glClearDepth(1); + else if(zbufenabled)glClearDepth(0); + glClear((clearcol?GL_COLOR_BUFFER_BIT:0)|(((zbufenabled||tdmode)&&cleardep)?GL_DEPTH_BUFFER_BIT:0)); +} +void SMELT_IMPL::sm3DCamera6f2v(float *pos,float *rot) +{ + batchOGL(); + smMatrix Mmodv; + Mmodv.loadIdentity(); + if(pos&&rot) + { + Mmodv.rotate(smMath::deg2rad(-rot[0]),1,0,0); + Mmodv.rotate(smMath::deg2rad(-rot[1]),0,1,0); + Mmodv.rotate(smMath::deg2rad(-rot[2]),0,0,1); + Mmodv.translate(-pos[0],-pos[1],-pos[2]); + } + memcpy(mmodv,Mmodv.m,sizeof(mmodv)); + glUniformMatrix4fv(loc_mmodv,1,0,mmodv); +} +void SMELT_IMPL::smMultViewMatrix(float *mat) +{ + smMatrix Mmodv(mmodv); + Mmodv=Mmodv*smMatrix(mat); + memcpy(mmodv,Mmodv.m,sizeof(mmodv)); +} +void SMELT_IMPL::sm2DCamera5f3v(float *pos,float *dpos,float *rot) +{ + batchOGL(); + smMatrix Mmodv; + Mmodv.loadIdentity(); + if(pos&&dpos&&rot) + { + Mmodv.translate(-pos[0],-pos[1],.0f); + Mmodv.rotate(*rot,.0f,.0f,1.0f); + Mmodv.translate(pos[0]+dpos[0],pos[1]+dpos[1],.0f); + } + memcpy(mmodv,Mmodv.m,sizeof(mmodv)); + glUniformMatrix4fv(loc_mmodv,1,0,mmodv); +} +void SMELT_IMPL::smRenderLinefd(float x1,float y1,float z1,float x2,float y2,float z2,DWORD color) +{ + if(vertexArray) + { + if(primType!=PRIM_LINES||primcnt>=VERTEX_BUFFER_SIZE/PRIM_LINES||primTex||primBlend!=BLEND_ALPHABLEND) + { + batchOGL(); + primType=PRIM_LINES; + if(primBlend!=BLEND_ALPHAADD)setBlend(BLEND_ALPHAADD); + bindTexture(NULL); + } + int i=(primcnt++)*PRIM_LINES; + vertexArray[i].x=x1,vertexArray[i+1].x=x2; + vertexArray[i].y=y1,vertexArray[i+1].y=y2; + vertexArray[i].x=z1,vertexArray[i+1].x=z2; + vertexArray[i].col=vertexArray[i+1].col=color; + vertexArray[i].tx=vertexArray[i+1].tx=.0; + vertexArray[i].ty=vertexArray[i+1].ty=.0; + } +} +void SMELT_IMPL::smRenderLinefvd(float *p1,float *p2,DWORD color) +{ + if(vertexArray&&p1&&p2) + { + if(primType!=PRIM_LINES||primcnt>=VERTEX_BUFFER_SIZE/PRIM_LINES||primTex||primBlend!=BLEND_ALPHABLEND) + { + batchOGL(); + primType=PRIM_LINES; + if(primBlend!=BLEND_ALPHAADD)setBlend(BLEND_ALPHAADD); + bindTexture(NULL); + } + int i=(primcnt++)*PRIM_LINES; + vertexArray[i].x=p1[0],vertexArray[i+1].x=p2[0]; + vertexArray[i].y=p1[1],vertexArray[i+1].y=p2[1]; + vertexArray[i].x=p2[2],vertexArray[i+1].x=p2[2]; + vertexArray[i].col=vertexArray[i+1].col=color; + vertexArray[i].tx=vertexArray[i+1].tx=.0; + vertexArray[i].ty=vertexArray[i+1].ty=.0; + } +} +void SMELT_IMPL::smRenderTriangle(smTriangle *t) +{ + if(vertexArray) + { + if(primType!=PRIM_TRIANGLES||primcnt>=VERTEX_BUFFER_SIZE/PRIM_TRIANGLES|| + primTex!=t->tex||primBlend!=t->blend) + { + batchOGL(); + primType=PRIM_TRIANGLES; + if(primBlend!=t->blend)setBlend(t->blend); + bindTexture((glTexture*)t->tex); + } + memcpy(&vertexArray[(primcnt++)*PRIM_TRIANGLES],t->v,sizeof(smVertex)*PRIM_TRIANGLES); + } +} +void SMELT_IMPL::smRenderQuad(smQuad *q) +{ + if(vertexArray) + { + if(primType!=PRIM_QUADS||primcnt>=VERTEX_BUFFER_SIZE/PRIM_QUADS|| + primTex!=q->tex||primBlend!=q->blend) + { + batchOGL(); + primType=PRIM_QUADS; + if(primBlend!=q->blend)setBlend(q->blend); + bindTexture((glTexture*)q->tex); + } + memcpy(&vertexArray[(primcnt++)*PRIM_QUADS],q->v,sizeof(smVertex)*PRIM_QUADS); + } +} +smVertex* SMELT_IMPL::smGetVertArray() +{ + if(vertexArray) + { + batchOGL(); + return vertexArray; + } + else return NULL; +} +void SMELT_IMPL::smDrawVertArray(int prim,SMTEX texture,int blend,int _primcnt) +{ + primType=prim; + bindTexture((glTexture*)texture); + if(primBlend!=blend)setBlend(blend); + primcnt=primcnt; +} +void SMELT_IMPL::smDrawCustomIndexedVertices(smVertex* vb,WORD* ib,int vbc,int ibc,int blend,SMTEX texture) +{ + if(vertexArray) + { + batchOGL(); + + float twm=1.,thm=1.; + if(texture) + { + glTexture *ptex=(glTexture*)texture; + if(ptex->dw&&ptex->dh) + { + twm=(ptex->rw)/(float)(ptex->dw); + thm=(ptex->rh)/(float)(ptex->dh); + } + } + if(!tdmode) + { + float h=curTarget?curTarget->h:scrh; + for(int i=0;i<vbc;++i) + { + vertexArray[i].y=h-vertexArray[i].y; + vertexArray[i].z=-vertexArray[i].z; + } + } + for(int i=0;i<vbc;++i) + { + vb[i].tx*=twm; + vb[i].ty=(1.-vb[i].ty)*thm; + DWORD color=vb[i].col; + BYTE *col=(BYTE*)&vb[i].col; + BYTE a=((color>>24)&0xFF); + BYTE r=((color>>16)&0xFF); + BYTE g=((color>> 8)&0xFF); + BYTE b=((color>> 0)&0xFF); + col[0]=r;col[1]=g; + col[2]=b;col[3]=a; + } + if(texture!=primTex)bindTexture((glTexture*)texture); + if(blend!=primBlend)setBlend(blend); + glBindVertexArray(VertexArrayObject); + glBindBuffer(GL_ARRAY_BUFFER,VertexBufferObject); + glBufferData(GL_ARRAY_BUFFER,sizeof(smVertex)*vbc,vb,GL_STATIC_DRAW); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,IndexBufferObject); + glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(GLushort)*ibc,ib,GL_STATIC_DRAW); + glDrawElements(GL_TRIANGLES,ibc,GL_UNSIGNED_SHORT,0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,IndexBufferObject); + glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(GLushort)*((VERTEX_BUFFER_SIZE*6)/4),indexBuf,GL_STATIC_DRAW); + glBindVertexArray(0); + if(texture!=primTex)bindTexture((glTexture*)primTex); + + } +} +SMTRG SMELT_IMPL::smTargetCreate(int w,int h,int ms) +{ + bool ok=false; + TRenderTargetList *pTarget=new TRenderTargetList; + memset(pTarget,0,sizeof(TRenderTargetList)); + pTarget->tex=buildTexture(w,h,NULL); + glTexture *gltex=(glTexture*)pTarget->tex; + gltex->isTarget=true;gltex->lost=false; + configTexture(gltex,w,h,NULL,false); + pTarget->w=w;pTarget->h=h; + ok=buildTarget(pTarget,gltex->name,w,h,ms); + if(!ok) + { + smLog("%s:" SLINE ": Failed to create render target.\n",GFX_GLFW_SRCFN); + smTextureFree(pTarget->tex); + delete pTarget; + return 0; + } + pTarget->next=targets; + targets=pTarget; + return (SMTRG)pTarget; +} +SMTEX SMELT_IMPL::smTargetTexture(SMTRG targ) +{ + TRenderTargetList *pTarg=(TRenderTargetList*)targ; + return targ?pTarg->tex:0; +} +void SMELT_IMPL::smTargetFree(SMTRG targ) +{ + TRenderTargetList *pTarget=targets,*pLastTarg=NULL; + while(pTarget) + { + if((TRenderTargetList*)targ==pTarget) + { + if(pLastTarg)pLastTarg->next=pTarget->next; + else targets=pTarget->next; + if(curTarget==(TRenderTargetList*)targ) + glBindFramebuffer(GL_FRAMEBUFFER_EXT,0); + if(pTarget->depth) + glDeleteRenderbuffers(1,&pTarget->depth); + glDeleteFramebuffers(1,&pTarget->frame); + if(pTarget->ms) + { + glDeleteRenderbuffers(1,&pTarget->colorms); + glDeleteRenderbuffers(1,&pTarget->scolor); + glDeleteRenderbuffers(1,&pTarget->sdepth); + glDeleteFramebuffers(1,&pTarget->sframe); + } + if(curTarget==(TRenderTargetList*)targ)curTarget=0; + smTextureFree(pTarget->tex); + delete pTarget; + return; + } + pLastTarg=pTarget; + pTarget=pTarget->next; + } +} +SMTEX SMELT_IMPL::smTextureCreate(int w,int h) +{ + DWORD *px=new DWORD[w*h]; + memset(px,0,sizeof(DWORD)*w*h); + SMTEX ret=buildTexture(w,h,px); + if(ret) + { + TTextureList *tex=new TTextureList; + tex->tex=ret; + tex->w=w; + tex->h=h; + tex->next=textures; + textures=tex; + } + return ret; +} +SMTEX SMELT_IMPL::smTextureLoad(const char *path) +{ + FILE *pFile;DWORD size,rsize;char *buff; + SMTEX ret=0; + pFile=fopen(path,"rb"); + if(!pFile)return 0; + fseek(pFile,0,SEEK_END);size=ftell(pFile);rewind(pFile); + buff=(char*)malloc(sizeof(char)*size); + if(!buff)return 0; + rsize=fread(buff,1,size,pFile); + if(rsize!=size)return 0; + ret=smTextureLoadFromMemory(buff,size);if(!ret)return 0; + glTexture *t=(glTexture*)ret; + configTexture(t,t->rw,t->rh,t->px); + delete[] t->px;t->px=NULL; + t->fn=strcpy(new char[strlen(path)+1],path); + free(buff); + fclose(pFile); + return ret; +} +SMTEX SMELT_IMPL::smTextureLoadFromMemory(const char *ptr,DWORD size) +{ + int w=0,h=0;SMTEX ret=0; + DWORD *px=decodeImage((BYTE*)ptr,NULL,size,w,h); + if(px)ret=buildTexture(w,h,px); + if(ret) + { + TTextureList *tex=new TTextureList; + tex->tex=ret;tex->w=w;tex->h=h; + tex->next=textures;textures=tex; + }else smLog("%s:" SLINE ": Unsupported texture format.\n",GFX_GLFW_SRCFN); + return ret; +} +void SMELT_IMPL::smTextureFree(SMTEX tex) +{ + if(!pOpenGLDevice)return; + TTextureList *ctex=textures,*lasttex=NULL; + while(ctex) + { + if(ctex->tex==tex) + { + if(lasttex)lasttex->next=ctex->next; + else textures=ctex->next; + delete ctex; + break; + } + lasttex=ctex; + ctex=ctex->next; + } + if(tex) + { + glTexture *ptex=(glTexture*)tex; + delete[] ptex->fn; + delete[] ptex->locpx; + delete[] ptex->px; + glDeleteTextures(1,&ptex->name); + delete ptex; + } +} +void SMELT_IMPL::smTextureOpt(int potopt,int filter) +{ + batchOGL(); + if(potopt==TPOT_NONPOT) + { + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE); + } + if(potopt==TPOT_POT) + { + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_R,GL_REPEAT); + } + filtermode=filter; + if(filter==TFLT_NEAREST) + { + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST); + } + if(filter==TFLT_LINEAR) + { + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); + } +} +int SMELT_IMPL::smTextureGetWidth(SMTEX tex,bool original) +{ + if(original) + { + TTextureList *ctex=textures; + while(ctex){if(ctex->tex==tex)return ctex->w;ctex=ctex->next;} + } + else return ((glTexture*)tex)->rw; + return 0; +} +int SMELT_IMPL::smTextureGetHeight(SMTEX tex,bool original) +{ + if(original) + { + TTextureList *ctex=textures; + while(ctex){if(ctex->tex==tex)return ctex->h;ctex=ctex->next;} + } + else return ((glTexture*)tex)->rh; + return 0; +} +DWORD* SMELT_IMPL::smTextureLock(SMTEX tex,int l,int t,int w,int h,bool ro) +{ + glTexture *ptex=(glTexture*)tex; + if(ptex->locpx)return NULL; + bool fromfile=(ptex->px==NULL&&ptex->fn); + if(fromfile) + { + FILE *pFile;DWORD size,rsize;char *buff; + pFile=fopen(ptex->fn,"rb"); + if(!pFile)return 0; + fseek(pFile,0,SEEK_END);size=ftell(pFile);rewind(pFile); + buff=(char*)malloc(sizeof(char)*size); + if(!buff)return 0; + rsize=fread(buff,1,size,pFile); + if(rsize!=size)return 0; + int _w,_h; + ptex->px=decodeImage((BYTE*)buff,ptex->fn,size,_w,_h); + if(_w!=(int)ptex->rw||_h!=(int)ptex->rh) + {delete[] ptex->px;ptex->px=NULL;} + free(buff); + fclose(pFile); + if(ptex->px&&!ro){delete[] ptex->fn;ptex->fn=NULL;} + } + if(!ptex->px&&!ptex->isTarget)return 0; + if(!w)w=ptex->rw;if(!h)h=ptex->rh; + //asserts... + ptex->roloc=ro;ptex->locx=l;ptex->locy=t;ptex->locw=w;ptex->loch=h; + ptex->locpx=new DWORD[w*h]; + if(!ptex->isTarget) + { + DWORD *dst=ptex->locpx,*src=ptex->px+((t*ptex->rw)+l); + for(int i=0;i<h;++i)//TODO: flip it... + { + memcpy(dst,src,w*sizeof(DWORD)); + dst+=w;src+=ptex->rw; + } + } + else return 0; + return ptex->locpx; +} +void SMELT_IMPL::smTexutreUnlock(SMTEX tex) +{ + glTexture *ptex=(glTexture*)tex; + if(!ptex->locpx)return; + if(!ptex->roloc) + { + DWORD *src=ptex->locpx+ptex->locw*ptex->loch, + *dst=ptex->px+(((ptex->rh-ptex->locy-1)*ptex->rw)+ptex->locx); + for(int i=0;i<ptex->loch;++i) + { + memcpy(dst,src,ptex->locw*sizeof(DWORD)); + dst-=ptex->rw;src-=ptex->locw; + } + if(ptex->lost)configTexture(ptex,ptex->rw,ptex->rh,ptex->px); + else + { + glBindTexture(GL_TEXTURE_2D,ptex->name); + glTexSubImage2D(GL_TEXTURE_2D,0,ptex->locx, + (ptex->rh-ptex->locy)-ptex->loch,ptex->locw,ptex->loch,GL_RGBA, + GL_UNSIGNED_BYTE,ptex->locpx); + glBindTexture(GL_TEXTURE_2D,primTex?(((glTexture*)primTex)->name):0); + } + } + if(ptex->fn&&ptex->roloc){delete[] ptex->px;ptex->px=NULL;} + delete[] ptex->locpx;ptex->locpx=NULL; + ptex->roloc=false; + ptex->locx=ptex->locy=ptex->locw=ptex->loch=-1; +} + +inline bool ispot(GLuint x){return((x&(x-1))==0);} +inline GLuint npot(GLuint x) +{ + --x; + for(unsigned i=1;i<sizeof(GLuint)*8;i<<=1)x|=x>>i; + return x+1; +} +DWORD* SMELT_IMPL::decodeImage(BYTE *data,const char *fn,DWORD size,int &w,int &h) +{ + w=h=0; + DWORD *px=NULL; + int fnlen=fn?strlen(fn):0; + if((fnlen>5)&&(strcasecmp((fn+fnlen)-5,".rgba"))==0)//raw image... pending remove + { + DWORD *ptr=(DWORD*)data; + DWORD _w=ptr[0],_h=ptr[1]; + if(((_w*_h*4)+8)==size) + { + w=_w;h=_h; + px=new DWORD[w*h]; + memcpy(px,ptr+2,w*h*4); + } + return px; + } + CxImage img; + img.Decode(data,size,CXIMAGE_FORMAT_UNKNOWN); + if(img.IsValid()) + { + w=img.GetWidth();h=img.GetHeight(); + px=new DWORD[w*h]; + BYTE *sptr=(BYTE*)px; + bool atunnel=img.AlphaIsValid(); + for(int i=0;i<h;++i) + for(int j=0;j<w;++j) + { + RGBQUAD rgb=img.GetPixelColor(j,i,true); + *(sptr++)=rgb.rgbRed; + *(sptr++)=rgb.rgbGreen; + *(sptr++)=rgb.rgbBlue; + *(sptr++)=atunnel?rgb.rgbReserved:0xFF; + } + } + return px; +} +void SMELT_IMPL::bindTexture(glTexture *t) +{ + if(t&&t->lost) + configTexture(t,t->rw,t->rh,t->px); + if(((SMTEX)t)!=primTex) + { + glBindTexture(GL_TEXTURE_2D,t?t->name:((glTexture*)emptyTex)->name); + glUniform1i(loc_tex,0); + primTex=(SMTEX)t; + } +} +bool SMELT_IMPL::buildTarget(TRenderTargetList *pTarget,GLuint texid,int w,int h,int ms=0) +{ + bool ok=true; + if(ms) + { + glGenFramebuffers(1,&pTarget->sframe); + glBindFramebuffer(GL_FRAMEBUFFER,pTarget->sframe); + glGenRenderbuffers(1,&pTarget->scolor); + glBindRenderbuffer(GL_RENDERBUFFER,pTarget->scolor); + glRenderbufferStorage(GL_RENDERBUFFER,GL_RGBA,w,h); + glGenRenderbuffers(1,&pTarget->sdepth); + glBindRenderbuffer(GL_RENDERBUFFER,pTarget->sdepth); + glRenderbufferStorage(GL_RENDERBUFFER,GL_DEPTH_COMPONENT24,w,h); + glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_RENDERBUFFER,pTarget->scolor); + glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_RENDERBUFFER,pTarget->sdepth); + + glGenFramebuffers(1,&pTarget->frame); + glBindFramebuffer(GL_FRAMEBUFFER,pTarget->frame); + glGenRenderbuffers(1,&pTarget->colorms); + glBindRenderbuffer(GL_RENDERBUFFER,pTarget->colorms); + glRenderbufferStorageMultisample(GL_RENDERBUFFER,ms,GL_RGBA,w,h); + glGenRenderbuffers(1,&pTarget->depth); + glBindRenderbuffer(GL_RENDERBUFFER,pTarget->depth); + glRenderbufferStorageMultisample(GL_RENDERBUFFER,ms,GL_DEPTH_COMPONENT24,w,h); + glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_RENDERBUFFER,pTarget->colorms); + glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_RENDERBUFFER,pTarget->depth); + GLenum rc=glCheckFramebufferStatus(GL_FRAMEBUFFER); + if((rc==GL_FRAMEBUFFER_COMPLETE)&&(glGetError()==GL_NO_ERROR)) + { + glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); + ok=true;pTarget->ms=ms; + } + else + { + glBindFramebuffer(GL_FRAMEBUFFER,0); + glDeleteRenderbuffers(1,&pTarget->colorms); + glDeleteRenderbuffers(1,&pTarget->depth); + glDeleteFramebuffers(1,&pTarget->frame); + glDeleteFramebuffers(1,&pTarget->sframe); + ok=false;ms=0; + } + glBindFramebuffer(GL_FRAMEBUFFER,curTarget?curTarget->frame:0); + } + if(!ms) + { + glGenFramebuffers(1,&pTarget->frame); + glGenRenderbuffers(1,&pTarget->depth); + glBindFramebuffer(GL_FRAMEBUFFER,pTarget->frame); + glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D,texid,0); + glBindRenderbuffer(GL_RENDERBUFFER,pTarget->depth); + glRenderbufferStorage(GL_RENDERBUFFER,GL_DEPTH_COMPONENT24,w,h); + glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_RENDERBUFFER,pTarget->depth); + GLenum rc=glCheckFramebufferStatus(GL_FRAMEBUFFER); + if((rc==GL_FRAMEBUFFER_COMPLETE)&&(glGetError()==GL_NO_ERROR)) + { + glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); + ok=true;pTarget->ms=0; + } + else + { + glBindFramebuffer(GL_FRAMEBUFFER,0); + glDeleteRenderbuffers(1,&pTarget->depth); + glDeleteFramebuffers(1,&pTarget->frame); + ok=false; + } + glBindFramebuffer(GL_FRAMEBUFFER,curTarget?curTarget->frame:0); + } + return ok; +} +void SMELT_IMPL::configTexture(glTexture *t,int w,int h,DWORD *px,bool compressed) +{ + GLuint tex=0; + glGenTextures(1,&tex); + t->lost=false;t->name=tex;t->rw=w;t->rh=h;t->px=px; + t->dw=t->dh=0; + bool fromfile=(!px&&(t->fn)); + if(fromfile) + { + FILE *pFile;DWORD size,rsize;char *buff; + pFile=fopen(t->fn,"rb"); + if(!pFile)return; + fseek(pFile,0,SEEK_END);size=ftell(pFile);rewind(pFile); + buff=(char*)malloc(sizeof(char)*size); + if(!buff)return; + rsize=fread(buff,1,size,pFile); + if(rsize!=size)return; + int _w,_h; + px=decodeImage((BYTE*)buff,t->fn,size,_w,_h); + if(_w!=w||_h!=h){delete[] px;px=NULL;} + free(buff); + fclose(pFile); + } + glBindTexture(GL_TEXTURE_2D,tex); + glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_LOD,0.0f); + glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAX_LOD,0.0f); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,0); + compressed=false;//compression is unusable at this moment + const GLenum fmt=compressed?/*GL_COMPRESSED_RGBA_S3TC_DXT5_EXT*/GL_COMPRESSED_RGBA_ARB:GL_RGBA8; + glTexImage2D(GL_TEXTURE_2D,0,fmt,w,h,0,GL_RGBA,GL_UNSIGNED_BYTE,px); + glBindTexture(GL_TEXTURE_2D,primTex?(((glTexture*)primTex)->name):0); + if(fromfile)delete[] px; +} +SMTEX SMELT_IMPL::buildTexture(int w,int h,DWORD *px) +{ + glTexture *ret=new glTexture; + memset(ret,0,sizeof(glTexture)); + ret->lost=true; + ret->rw=w;ret->rh=h;ret->px=px; + return (SMTEX)ret; +} +void SMELT_IMPL::configProjectionMatrix2D(int w,int h) +{ + memset(mproj,0,sizeof(mproj)); + mproj[0]=2./w; + mproj[5]=2./h; + mproj[10]=-2.; + mproj[15]=1.; + mproj[12]=mproj[13]=mproj[14]=-1.; + glUniformMatrix4fv(loc_mproj,1,0,mproj); +} +void SMELT_IMPL::configProjectionMatrix3D(int w,int h,float fov) +{ + memset(mproj,0,sizeof(mproj)); + float f=1./tanf(M_PI*fov/360.); + float ar=(float)w/(float)h; + float Near=0.1,Far=1000.; + mproj[0]=f/ar;mproj[5]=f; + mproj[10]=(Far+Near)/(Near-Far);mproj[11]=-1.0f; + mproj[14]=(2*Far*Near)/(Near-Far); + glUniformMatrix4fv(loc_mproj,1,0,mproj); +} +void SMELT_IMPL::batchOGL(bool endScene) +{ + if(vertexArray&&primcnt) + { + float twm=1.,thm=1.; + if(primTex) + { + glTexture *ptex=(glTexture*)primTex; + if(ptex->dw&&ptex->dh) + { + twm=(ptex->rw)/(float)(ptex->dw); + thm=(ptex->rh)/(float)(ptex->dh); + } + } + if(!tdmode) + { + float h=curTarget?curTarget->h:scrh; + for(int i=0;i<primcnt*primType;++i) + { + vertexArray[i].y=h-vertexArray[i].y; + vertexArray[i].z=-vertexArray[i].z; + } + } + for(int i=0;i<primcnt*primType;++i) + { + vertexArray[i].tx*=twm; + vertexArray[i].ty*=thm; + DWORD color=vertexArray[i].col; + BYTE *col=(BYTE*)&vertexArray[i].col; + BYTE a=((color>>24)&0xFF); + BYTE r=((color>>16)&0xFF); + BYTE g=((color>> 8)&0xFF); + BYTE b=((color>> 0)&0xFF); + col[0]=r;col[1]=g; + col[2]=b;col[3]=a; + } + glBindVertexArray(VertexArrayObject); + glBindBuffer(GL_ARRAY_BUFFER,VertexBufferObject); + glBufferData(GL_ARRAY_BUFFER,sizeof(smVertex)*primcnt*primType,vertexBuf,GL_STATIC_DRAW); + switch(primType) + { + case PRIM_LINES: + glDrawArrays(GL_LINES,0,2*primcnt); + break; + case PRIM_TRIANGLES: + glDrawArrays(GL_TRIANGLES,0,3*primcnt); + break; + case PRIM_QUADS: + glDrawElements(GL_TRIANGLES,6*primcnt,GL_UNSIGNED_SHORT,0); +#if 0 + for (int i=0;i<primcnt*6;i+=3) + { + printf("idxbuf:%d\n",indexBuf[i]); + printf("QUAD'S TRIANGLE:\n"); +#define printVertex(a) printf("(%.2f,%.2f,%.2f),0x%X,(%.2f,%.2f)\n",a.x,a.y,a.z,a.col,a.tx,a.ty); + printf("#%d: ",indexBuf[i+0]);printVertex(vertexBuf[indexBuf[i+0]]); + printf("#%d: ",indexBuf[i+1]);printVertex(vertexBuf[indexBuf[i+1]]); + printf("#%d: ",indexBuf[i+2]);printVertex(vertexBuf[indexBuf[i+2]]); +#undef printVertex + } +#endif + break; + } + glBindVertexArray(0); + primcnt=0; + } + if(vertexArray)vertexArray=endScene?0:vertexBuf; +} +void SMELT_IMPL::setBlend(int blend) +{ + if((blend&BLEND_ALPHABLEND)!=(primBlend&BLEND_ALPHABLEND)) + { + if(blend&BLEND_ALPHABLEND)glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); + else glBlendFunc(blend&BLEND_COLORINV?GL_ONE_MINUS_DST_COLOR:GL_SRC_ALPHA,blend&BLEND_COLORINV?GL_ZERO:GL_ONE); + } + if((blend&BLEND_ZWRITE)!=(primBlend&BLEND_ZWRITE)) + { + if(blend&BLEND_ZWRITE||tdmode)glDepthMask(GL_TRUE); + else glDepthMask(GL_FALSE); + } + if((blend&BLEND_COLORADD)!=(primBlend&BLEND_COLORADD)) + { + if(blend&BLEND_COLORADD)glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_ADD); + else glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE); + } + if((blend&BLEND_COLORINV)!=(primBlend&BLEND_COLORINV)) + { + if(blend&BLEND_COLORINV)glBlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ZERO); + else glBlendFunc(GL_SRC_ALPHA,blend&BLEND_ALPHABLEND?GL_ONE_MINUS_SRC_ALPHA:GL_ONE); + } + primBlend=blend; +} +void SMELT_IMPL::unloadGLEntryPoints() +{ +} +bool SMELT_IMPL::checkGLExtension(const char *extlist,const char *ext) +{ + return true;/*shit* + const char *ptr=strstr(extlist,ext); + if(ptr==NULL)return false; + const char endchar=ptr[strlen(ext)]; + if((endchar=='\0')||(endchar==' '))return true; + return false;*/ +} +bool SMELT_IMPL::loadGLEntryPoints() +{ + smLog("%s:" SLINE ": Initializing with OpenGL core profile...\n",GFX_GLFW_SRCFN); + pOpenGLDevice->have_base_opengl=true; + /* + * All OpenGL features utilized by SMELT are in the core profile + * for OpenGL >= 3.2. So this function is essentially useless. + */ + glewExperimental=true; + GLenum glewret=glewInit(); + if(glewret) + { + smLog("%s:" SLINE ": glewInit() failed with error %s\n",GFX_GLFW_SRCFN,glewGetErrorString(glewret)); + pOpenGLDevice->have_base_opengl=false; + return false; + } + if (!pOpenGLDevice->have_base_opengl) + { + unloadGLEntryPoints(); + return false; + } + smLog("%s:" SLINE ": GL_RENDERER: %s\n",GFX_GLFW_SRCFN,(const char *)glGetString(GL_RENDERER)); + smLog("%s:" SLINE ": GL_VENDOR: %s\n",GFX_GLFW_SRCFN,(const char *)glGetString(GL_VENDOR)); + smLog("%s:" SLINE ": GL_VERSION: %s\n",GFX_GLFW_SRCFN,(const char *)glGetString(GL_VERSION)); + const char *verstr=(const char*)glGetString(GL_VERSION); + int maj=0,min=0; + sscanf(verstr,"%d.%d",&maj,&min); + if((maj<3)||((maj==3)&&(min<2))) + { + smLog("%s:" SLINE ": OpenGL implementation must be at least version 3.2.\n",GFX_GLFW_SRCFN); + unloadGLEntryPoints(); + return false; + } + return true; +} +bool SMELT_IMPL::initOGL() +{ + primTex=0;emptyTex=0; + if(pOpenGLDevice){smLog("%s:" SLINE ": Multiple initialization!\n",GFX_GLFW_SRCFN);return false;} + pOpenGLDevice=new TOpenGLDevice; + if(!loadGLEntryPoints())return false; + smLog("%s:" SLINE ": Mode: %d x %d\n",GFX_GLFW_SRCFN,scrw,scrh); + vertexArray=NULL;textures=NULL; + ShaderProgram=vertshader=fragshader=0; + VertexBufferObject=VertexArrayObject=IndexBufferObject=0; + if(!confOGL())return false; + glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); + if(!curTarget)glfwSwapBuffers((GLFWwindow*)hwnd); + return true; +} +void SMELT_IMPL::finiOGL() +{ + while(textures)smTextureFree(textures->tex); + while(targets)smTargetFree((SMTRG)targets); + textures=NULL;targets=NULL;vertexArray=NULL; + delete[] vertexBuf;vertexBuf=NULL; + delete[] indexBuf;indexBuf=NULL; + if(pOpenGLDevice) + { + if(1) + { + if(VertexBufferObject!=0) + { + glBindVertexArray(VertexArrayObject); + glBindBuffer(GL_ARRAY_BUFFER,0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); + glDeleteBuffers(1,&VertexBufferObject); + glDeleteBuffers(1,&IndexBufferObject); + glBindVertexArray(0); + glDeleteVertexArrays(1,&VertexArrayObject); + VertexArrayObject=0; + VertexBufferObject=0; + IndexBufferObject=0; + } + } + glDeleteProgram(ShaderProgram); + delete pOpenGLDevice; + pOpenGLDevice=NULL; + } +} +bool SMELT_IMPL::restOGL() +{ + if(!pOpenGLDevice)return false; + delete[] vertexBuf;vertexBuf=NULL; + delete[] indexBuf;indexBuf=NULL; + unloadGLEntryPoints(); + if(!loadGLEntryPoints())return false; + if(!confOGL())return false; + //if()return();//TODO: rest func + return true; +} +bool SMELT_IMPL::confOGL() +{ + bindTexture(NULL); + DWORD ones=~0U; + if(!emptyTex) + {emptyTex=buildTexture(1,1,&ones);} + configTexture((glTexture*)emptyTex,1,1,&ones,false); + for(TTextureList *i=textures;i;i=i->next) + { + glTexture *t=(glTexture*)i->tex; + if(!t)continue;t->lost=true;t->name=0; + } + TRenderTargetList *target=targets; + while(target) + { + glTexture *tex=(glTexture*)target->tex; + bindTexture(tex);bindTexture(NULL); + buildTarget(target,tex?tex->name:0,target->w,target->h); + target=target->next; + } + int compret=0; + ShaderProgram=glCreateProgram(); + vertshader=glCreateShader(GL_VERTEX_SHADER); + fragshader=glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(vertshader,1,&fixedfunc_pipeline_vsh,NULL); + glShaderSource(fragshader,1,&fixedfunc_pipeline_fsh,NULL); + glCompileShader(vertshader); + glGetShaderiv(vertshader,GL_COMPILE_STATUS,&compret); + //char log[1024]; + //glGetShaderInfoLog(vertshader,1024,NULL,log); + //puts(log); + if(!compret) + smLog("%s:" SLINE ": Warning: Your shitty vertex shader failed to compile!\n",GFX_GLFW_SRCFN); + glCompileShader(fragshader); + glGetShaderiv(fragshader,GL_COMPILE_STATUS,&compret); + //glGetShaderInfoLog(fragshader,1024,NULL,log); + //puts(log); + if(!compret) + smLog("%s:" SLINE ": Warning: Your shitty fragment shader failed to compile!\n",GFX_GLFW_SRCFN); + glAttachShader(ShaderProgram,vertshader); + glAttachShader(ShaderProgram,fragshader); + glLinkProgram(ShaderProgram); + //glGetProgramInfoLog(ShaderProgram,1024,NULL,log); + //puts(log); + glGetProgramiv(ShaderProgram,GL_LINK_STATUS,&compret); + if(!compret) + smLog("%s:" SLINE ": Warning: Default shader linkage failure!\n",GFX_GLFW_SRCFN); + glDeleteShader(vertshader); + glDeleteShader(fragshader); + glUseProgram(ShaderProgram); + loc_tex=glGetUniformLocation(ShaderProgram,"tex"); + loc_mmodv=glGetUniformLocation(ShaderProgram,"mmodv"); + loc_mproj=glGetUniformLocation(ShaderProgram,"mproj"); + vertexBuf=new smVertex[VERTEX_BUFFER_SIZE]; + indexBuf=new GLushort[VERTEX_BUFFER_SIZE*6/4]; + GLushort* indices=indexBuf; + for(int i=0,n=0;i<VERTEX_BUFFER_SIZE/4;++i) + { + *indices++=n;*indices++=n+1; + *indices++=n+2;*indices++=n+2; + *indices++=n+3;*indices++=n; + n+=4; + } + glGenBuffers(1,&VertexBufferObject); + glGenVertexArrays(1,&VertexArrayObject); + glGenBuffers(1,&IndexBufferObject); + glBindVertexArray(VertexArrayObject); + glBindBuffer(GL_ARRAY_BUFFER,VertexBufferObject); + glBufferData(GL_ARRAY_BUFFER,sizeof(smVertex)*VERTEX_BUFFER_SIZE,vertexBuf,GL_STATIC_DRAW); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,IndexBufferObject); + glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(GLushort)*((VERTEX_BUFFER_SIZE*6)/4),indexBuf,GL_STATIC_DRAW); + glVertexAttribPointer(0,3,GL_FLOAT,0,sizeof(smVertex),(void*)offsetof(smVertex,x));//vp + glVertexAttribPointer(1,4,GL_UNSIGNED_BYTE,1,sizeof(smVertex),(void*)offsetof(smVertex,col));//vc + glVertexAttribPointer(2,2,GL_FLOAT,0,sizeof(smVertex),(void*)offsetof(smVertex,tx));//vtc + glEnableVertexAttribArray(0); + glEnableVertexAttribArray(1); + glEnableVertexAttribArray(2); + glBindVertexArray(0); + glPixelStorei(GL_UNPACK_ALIGNMENT,1); + glPixelStorei(GL_PACK_ALIGNMENT,1); + glEnable(GL_SCISSOR_TEST); + glDisable(GL_CULL_FACE); + glActiveTexture(GL_TEXTURE0); + glDepthFunc(GL_GEQUAL); + glEnable(GL_DEPTH_TEST); + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); + filtermode=TFLT_LINEAR; + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); + //GL_REPEAT doesn't work with non-pot textures... + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE); + primcnt=0;primType=PRIM_QUADS;primBlend=BLEND_ALPHABLEND;primTex=0; + glScissor(0,0,scrw,scrh); + glViewport(0,0,scrw,scrh); + glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); + configProjectionMatrix2D(scrw,scrh); + smMatrix Mmodv;Mmodv.loadIdentity(); + memcpy(mmodv,Mmodv.m,sizeof(mmodv)); + glUniformMatrix4fv(loc_mmodv,1,0,mmodv); + return true; +} diff --git a/smelt/glfw_m/inp_glfw.cpp b/smelt/glfw_m/inp_glfw.cpp new file mode 100644 index 0000000..4bbd43e --- /dev/null +++ b/smelt/glfw_m/inp_glfw.cpp @@ -0,0 +1,204 @@ +// -*- C++ -*- +/* + * Simple MultimEdia LiTerator(SMELT) + * by Chris Xiong 2015 + * Input manager implementation + * + * WARNING: This library is in development and interfaces would be very + * unstable. + * + */ +#include "smelt_internal.hpp" +//static const char* INP_GLFW_SRCFN="smelt/glfw/inp_glfw.cpp"; +bool SMELT_IMPL::smGetInpEvent(smInpEvent *e) +{ + TInputEventList *eptr; + if(inpQueue) + { + eptr=inpQueue;memcpy(e,&eptr->e,sizeof(smInpEvent)); + inpQueue=inpQueue->next;delete eptr;return true; + } + return false; +} +void SMELT_IMPL::smGetMouse2f(float *x,float *y){*x=posx,*y=posy;} +void SMELT_IMPL::smSetMouse2f(float x,float y){glfwSetInputMode((GLFWwindow*)hwnd,x,y);} +void SMELT_IMPL::smSetMouseGrab(bool enabled){glfwSetInputMode((GLFWwindow*)hwnd,GLFW_CURSOR,enabled?GLFW_CURSOR_DISABLED:GLFW_CURSOR_NORMAL);} +int SMELT_IMPL::smGetWheel(){return posz;} +bool SMELT_IMPL::smIsMouseOver(){return mouseOver;} +int SMELT_IMPL::smGetKey(){return lkey;} +int SMELT_IMPL::smGetKeyState(int key) +{ + if(!(keyz[key]&4)&&keylst[key])return SMKST_RELEASE; + if(!(keyz[key]&4))return SMKST_NONE; + if((keyz[key]&4)&&!keylst[key])return SMKST_HIT; + return SMKST_KEEP; +} + +void SMELT_IMPL::buildEvent(int type,int k,int scan,int flags,int x,int y) +{ + TInputEventList *last,*eptr=new TInputEventList; + eptr->e.type=type;eptr->e.chcode=0; + int ptx=x,pty=y; + if(type==INPUT_KEYDOWN) + { + k=GLFWKeyToSMKey(k); + if((k<0)||(k>(int)(sizeof(keyz)/sizeof(keyz[0]))))return; + keyz[k]|=4;if(!(flags&SMINP_REPEAT))keyz[k]|=1; + eptr->e.chcode=(k>=32&&k<=127)?k:0; + } + if(type==INPUT_KEYUP) + { + k=GLFWKeyToSMKey(k); + if((k<0)||(k>(int)(sizeof(keyz)/sizeof(keyz[0]))))return; + keyz[k]&=~4;keyz[k]|=2; + eptr->e.chcode=(k>=32&&k<=127)?k:0; + } + if(type==INPUT_MOUSEWHEEL) + {eptr->e.sccode=0;eptr->e.wheel=k;} + else{eptr->e.sccode=k;eptr->e.wheel=0;} + if(type==INPUT_MBUTTONDOWN){keyz[k]|=1|4;captured=true;} + if(type==INPUT_MBUTTONUP){keyz[k]|=2;keyz[k]&=~4;ptx=(int)posx;pty=(int)posy;captured=false;} + if(keymods&GLFW_MOD_SHIFT)flags|=SMINP_SHIFT; + if(keymods&GLFW_MOD_CONTROL)flags|=SMINP_CTRL; + if(keymods&GLFW_MOD_ALT)flags|=SMINP_ALT; + //if(keymods&KMOD_CAPS)flags|=SMINP_CAPSLOCK; + //if(keymods&KMOD_MODE)flags|=SMINP_SCROLLLOCK; + //if(keymods&KMOD_NUM)flags|=SMINP_NUMLOCK; + eptr->e.flag=flags; + if(ptx==-1){eptr->e.x=posx;eptr->e.y=posy;} + else + { + ptx<0?ptx=0:0;pty<0?pty=0:0; + ptx>=scrw?ptx=scrw-1:0;pty>=scrh?pty=scrh-1:0; + eptr->e.x=(float)ptx;eptr->e.y=(float)pty; + } + eptr->next=0; + if(!inpQueue)inpQueue=eptr; + else + { + last=inpQueue; + while(last->next)last=last->next; + last->next=eptr; + } + if(eptr->e.type==INPUT_KEYDOWN||eptr->e.type==INPUT_MBUTTONDOWN) + lkey=eptr->e.sccode; + if(eptr->e.type==INPUT_MOUSEMOVE)posx=eptr->e.x,posy=eptr->e.y; + if(eptr->e.type==INPUT_MOUSEWHEEL)posz=eptr->e.wheel; +} +void SMELT_IMPL::initInput(){posx=posy=.0;memset(keyz,0,sizeof(keyz));} +void SMELT_IMPL::clearQueue() +{ + TInputEventList *nxt,*eptr=inpQueue; + for(unsigned i=0;i<sizeof(keyz)/sizeof(keyz[0]);++i)keyz[i]&=~3; + while(eptr){nxt=eptr->next;delete eptr;eptr=nxt;} + inpQueue=NULL;posz=0;lkey=0; +} +int SMELT_IMPL::GLFWKeyToSMKey(int glfwkey) +{ + switch (glfwkey) + { + case GLFW_KEY_ESCAPE: return SMK_ESCAPE; + case GLFW_KEY_BACKSPACE: return SMK_BACKSPACE; + case GLFW_KEY_TAB: return SMK_TAB; + case GLFW_KEY_ENTER: return SMK_ENTER; + case GLFW_KEY_SPACE: return SMK_SPACE; + case GLFW_KEY_LEFT_SHIFT: return SMK_SHIFT; + case GLFW_KEY_RIGHT_SHIFT: return SMK_SHIFT; + case GLFW_KEY_LEFT_CONTROL: return SMK_CTRL; + case GLFW_KEY_RIGHT_CONTROL: return SMK_CTRL; + case GLFW_KEY_LEFT_ALT: return SMK_ALT; + case GLFW_KEY_RIGHT_ALT: return SMK_ALT; + case GLFW_KEY_LEFT_SUPER: return SMK_LWIN; + case GLFW_KEY_RIGHT_SUPER: return SMK_RWIN; + case GLFW_KEY_PAUSE: return SMK_PAUSE; + case GLFW_KEY_CAPS_LOCK: return SMK_CAPSLOCK; + case GLFW_KEY_NUM_LOCK: return SMK_NUMLOCK; + case GLFW_KEY_SCROLL_LOCK: return SMK_SCROLLLOCK; + case GLFW_KEY_PAGE_UP: return SMK_PGUP; + case GLFW_KEY_PAGE_DOWN: return SMK_PGDN; + case GLFW_KEY_HOME: return SMK_HOME; + case GLFW_KEY_END: return SMK_END; + case GLFW_KEY_INSERT: return SMK_INSERT; + case GLFW_KEY_DELETE: return SMK_DELETE; + case GLFW_KEY_LEFT: return SMK_LEFT; + case GLFW_KEY_UP: return SMK_UP; + case GLFW_KEY_RIGHT: return SMK_RIGHT; + case GLFW_KEY_DOWN: return SMK_DOWN; + case GLFW_KEY_0: return SMK_0; + case GLFW_KEY_1: return SMK_1; + case GLFW_KEY_2: return SMK_2; + case GLFW_KEY_3: return SMK_3; + case GLFW_KEY_4: return SMK_4; + case GLFW_KEY_5: return SMK_5; + case GLFW_KEY_6: return SMK_6; + case GLFW_KEY_7: return SMK_7; + case GLFW_KEY_8: return SMK_8; + case GLFW_KEY_9: return SMK_9; + case GLFW_KEY_A: return SMK_A; + case GLFW_KEY_B: return SMK_B; + case GLFW_KEY_C: return SMK_C; + case GLFW_KEY_D: return SMK_D; + case GLFW_KEY_E: return SMK_E; + case GLFW_KEY_F: return SMK_F; + case GLFW_KEY_G: return SMK_G; + case GLFW_KEY_H: return SMK_H; + case GLFW_KEY_I: return SMK_I; + case GLFW_KEY_J: return SMK_J; + case GLFW_KEY_K: return SMK_K; + case GLFW_KEY_L: return SMK_L; + case GLFW_KEY_M: return SMK_M; + case GLFW_KEY_N: return SMK_N; + case GLFW_KEY_O: return SMK_O; + case GLFW_KEY_P: return SMK_P; + case GLFW_KEY_Q: return SMK_Q; + case GLFW_KEY_R: return SMK_R; + case GLFW_KEY_S: return SMK_S; + case GLFW_KEY_T: return SMK_T; + case GLFW_KEY_U: return SMK_U; + case GLFW_KEY_V: return SMK_V; + case GLFW_KEY_W: return SMK_W; + case GLFW_KEY_X: return SMK_X; + case GLFW_KEY_Y: return SMK_Y; + case GLFW_KEY_Z: return SMK_Z; + case GLFW_KEY_MINUS: return SMK_MINUS; + case GLFW_KEY_EQUAL: return SMK_EQUALS; + case GLFW_KEY_BACKSLASH: return SMK_BACKSLASH; + case GLFW_KEY_LEFT_BRACKET: return SMK_LBRACKET; + case GLFW_KEY_RIGHT_BRACKET: return SMK_RBRACKET; + case GLFW_KEY_SEMICOLON: return SMK_SEMICOLON; + case GLFW_KEY_APOSTROPHE: return SMK_APOSTROPHE; + case GLFW_KEY_COMMA: return SMK_COMMA; + case GLFW_KEY_PERIOD: return SMK_PERIOD; + case GLFW_KEY_SLASH: return SMK_SLASH; + case GLFW_KEY_KP_0: return SMK_NUMPAD0; + case GLFW_KEY_KP_1: return SMK_NUMPAD1; + case GLFW_KEY_KP_2: return SMK_NUMPAD2; + case GLFW_KEY_KP_3: return SMK_NUMPAD3; + case GLFW_KEY_KP_4: return SMK_NUMPAD4; + case GLFW_KEY_KP_5: return SMK_NUMPAD5; + case GLFW_KEY_KP_6: return SMK_NUMPAD6; + case GLFW_KEY_KP_7: return SMK_NUMPAD7; + case GLFW_KEY_KP_8: return SMK_NUMPAD8; + case GLFW_KEY_KP_9: return SMK_NUMPAD9; + case GLFW_KEY_KP_MULTIPLY: return SMK_MULTIPLY; + case GLFW_KEY_KP_DIVIDE: return SMK_DIVIDE; + case GLFW_KEY_KP_ADD: return SMK_ADD; + case GLFW_KEY_KP_SUBTRACT: return SMK_SUBTRACT; + case GLFW_KEY_KP_DECIMAL: return SMK_DECIMAL; + case GLFW_KEY_KP_ENTER:return SMK_ENTER; + case GLFW_KEY_F1: return SMK_F1; + case GLFW_KEY_F2: return SMK_F2; + case GLFW_KEY_F3: return SMK_F3; + case GLFW_KEY_F4: return SMK_F4; + case GLFW_KEY_F5: return SMK_F5; + case GLFW_KEY_F6: return SMK_F6; + case GLFW_KEY_F7: return SMK_F7; + case GLFW_KEY_F8: return SMK_F8; + case GLFW_KEY_F9: return SMK_F9; + case GLFW_KEY_F10: return SMK_F10; + case GLFW_KEY_F11: return SMK_F11; + case GLFW_KEY_F12: return SMK_F12; + default: return -1; + } + return -1; +} diff --git a/smelt/glfw_m/makefile b/smelt/glfw_m/makefile new file mode 100644 index 0000000..d487454 --- /dev/null +++ b/smelt/glfw_m/makefile @@ -0,0 +1,27 @@ +CC= g++ +CXXFLAGS= -c -g -O2 -std=c++11 -Wall -I../../include -D_LINUX -fPIC +TARGET= libsmelt.a + +all: objects-normal archive-normal + +dumb: CXXFLAGS += -DENABLE_DUMB +dumb: TARGET= libsmelt-dumb.a +dumb: all + +objects-normal: gfx inp sfx sys + +gfx: + $(CC) gfx_glfw.cpp $(CXXFLAGS) +sfx: + $(CC) sfx_oal.cpp $(CXXFLAGS) +inp: + $(CC) inp_glfw.cpp $(CXXFLAGS) +sys: + $(CC) sys_glfw.cpp $(CXXFLAGS) +archive-normal: + $(AR) rcs $(TARGET) gfx_glfw.o sfx_oal.o inp_glfw.o sys_glfw.o + +clean: + rm -f *.o +clean-all: clean + rm *.a diff --git a/smelt/glfw_m/sfx_dumb.cpp b/smelt/glfw_m/sfx_dumb.cpp new file mode 100644 index 0000000..4464da1 --- /dev/null +++ b/smelt/glfw_m/sfx_dumb.cpp @@ -0,0 +1,63 @@ +// -*- C++ -*- +/* + * Simple MultimEdia LiTerator(SMELT) + * by Chris Xiong 2015 + * SFX dumb implementation + * This dumb implementation has everything stubbed, useful if you don't + * use the audio routines here. + * + * WARNING: This file is not intended to be used on its own! + * + */ + +SMSFX SMELT_IMPL::smSFXLoad(const char *path) +{return 0;} +SMSFX SMELT_IMPL::smSFXLoadFromMemory(const char *ptr,DWORD size) +{return 0;} +SMCHN SMELT_IMPL::smSFXPlay(SMSFX fx,int vol,int pan,float pitch,bool loop) +{return 0;} +float SMELT_IMPL::smSFXGetLengthf(SMSFX fx) +{return 0.0;} +DWORD SMELT_IMPL::smSFXGetLengthd(SMSFX fx) +{return -1;} +void SMELT_IMPL::smSFXSetLoopPoint(SMSFX fx,DWORD l,DWORD r) +{} +void SMELT_IMPL::smSFXFree(SMSFX fx) +{} +void SMELT_IMPL::smChannelVol(SMCHN chn,int vol) +{} +void SMELT_IMPL::smChannelPan(SMCHN chn,int pan) +{} +void SMELT_IMPL::smChannelPitch(SMCHN chn,float pitch) +{} +void SMELT_IMPL::smChannelPause(SMCHN chn) +{} +void SMELT_IMPL::smChannelResume(SMCHN chn) +{} +void SMELT_IMPL::smChannelStop(SMCHN chn) +{} +void SMELT_IMPL::smChannelPauseAll() +{} +void SMELT_IMPL::smChannelResumeAll() +{} +void SMELT_IMPL::smChannelStopAll() +{} +bool SMELT_IMPL::smChannelIsPlaying(SMCHN chn) +{return false;} +float SMELT_IMPL::smChannelGetPosf(SMCHN chn) +{return -1.;} +void SMELT_IMPL::smChannelSetPosf(SMCHN chn,float pos) +{} +int SMELT_IMPL::smChannelGetPosd(SMCHN chn) +{return -1;} +void SMELT_IMPL::smChannelSetPosd(SMCHN chn,int pos) +{} + +bool SMELT_IMPL::initOAL() +{ + smLog("%s:" SLINE ": I'm dumb!\n",SFX_OAL_SRCFN); + return true; +} +void SMELT_IMPL::finiOAL() +{ +} diff --git a/smelt/glfw_m/sfx_oal.cpp b/smelt/glfw_m/sfx_oal.cpp new file mode 100644 index 0000000..5b8d135 --- /dev/null +++ b/smelt/glfw_m/sfx_oal.cpp @@ -0,0 +1,368 @@ +// -*- C++ -*- +/* + * Simple MultimEdia LiTerator(SMELT) + * by Chris Xiong 2015 + * GFX implementation based on OpenAL + * + * WARNING: This library is in development and interfaces would be very + * unstable. + * + */ +#include "smelt_internal.hpp" + +static const char* SFX_OAL_SRCFN="smelt/glfw/sfx_oal.cpp"; +#ifndef ENABLE_DUMB +#ifdef ENABLE_OGG_SUPPORT +struct oggdata{const BYTE *data;DWORD size,pos;}; +static void* readVorbis(const BYTE *data,const DWORD size, ALsizei *decomp_size,ALenum *fmt,ALsizei *freq); +#endif +static void* readRiffWv(const BYTE *data,const DWORD size, ALsizei *decomp_size,ALenum *fmt,ALsizei *freq); +SMSFX SMELT_IMPL::smSFXLoad(const char *path) +{ + FILE *pFile;DWORD size,rsize; char *buff; + pFile=fopen(path,"rb"); + if(!pFile)return 0; + fseek(pFile,0,SEEK_END);size=ftell(pFile);rewind(pFile); + buff=(char*)malloc(sizeof(char)*size); + if(!buff)return 0; + rsize=fread(buff,1,size,pFile); + if(rsize!=size)return 0; + SMSFX ret=smSFXLoadFromMemory(buff,size); + free(buff); + fclose(pFile); + return ret; +} +SMSFX SMELT_IMPL::smSFXLoadFromMemory(const char *ptr,DWORD size) +{ + if(pOpenALDevice&&!mute) + { +#ifdef ENABLE_OGG_SUPPORT + bool isOgg=size>4&&ptr[0]=='O'&&ptr[1]=='g'&&ptr[2]=='g'&&ptr[3]=='S'; +#endif + void *decompdata=NULL,*decomp=NULL; + ALsizei decompsize=0,freq=0; + ALenum fmt=AL_FORMAT_STEREO16; + decompdata=readRiffWv((const BYTE*)ptr,size,&decompsize,&fmt,&freq); +#ifdef ENABLE_OGG_SUPPORT + if(!decompdata) + { + if(!isOgg)return 0; + else decompdata=readVorbis((const BYTE*)ptr,size,&decompsize,&fmt,&freq); + } +#endif + if(!decompdata)return 0; + decomp=decompdata; + ALuint buff=0;alGenBuffers(1,&buff); + alBufferData(buff,fmt,decomp,decompsize,freq); + free(decompdata);return(SMSFX)buff; + } + return 0; +} +SMCHN SMELT_IMPL::smSFXPlay(SMSFX fx,int vol,int pan,float pitch,bool loop) +{ + if(pOpenALDevice) + { + ALuint src=getSource(); + if(src) + { + if(vol<0)vol=0;if(vol>100)vol=100; + if(pan<-100)pan=-100;if(pan>100)pan=100; + alSourceStop(src); + alSourcei(src,AL_BUFFER,(ALint)fx); + alSourcef(src,AL_GAIN,((ALfloat)vol)/100.); + alSourcef(src,AL_PITCH,pitch); + alSource3f(src,AL_POSITION,((ALfloat)pan)/100.,.0,.0); + alSourcei(src,AL_LOOPING,loop?AL_TRUE:AL_FALSE); + alSourcePlay(src); + } + return src; + } + return 0; +} +float SMELT_IMPL::smSFXGetLengthf(SMSFX fx) +{ + ALuint buff=(ALuint)fx; + ALint freq; + DWORD lend=smSFXGetLengthd(fx); + alGetBufferi(buff,AL_FREQUENCY,&freq); + float ret=lend/(float)freq; + return ret; +} +DWORD SMELT_IMPL::smSFXGetLengthd(SMSFX fx) +{ + if(pOpenALDevice) + { + ALint size_b,chnc,bit; + ALuint buff=(ALuint)fx; + alGetBufferi(buff,AL_SIZE,&size_b); + alGetBufferi(buff,AL_CHANNELS,&chnc); + alGetBufferi(buff,AL_BITS,&bit); + DWORD ret=size_b*8/(chnc*bit); + return ret; + } + return -1; +} +void SMELT_IMPL::smSFXSetLoopPoint(SMSFX fx,DWORD l,DWORD r) +{ + if(pOpenALDevice) + { + ALint pt[2];pt[0]=l;pt[1]=r; + alBufferiv((ALuint)fx,AL_LOOP_POINTS_SOFT,pt); + } +} +void SMELT_IMPL::smSFXFree(SMSFX fx) +{ + if(pOpenALDevice) + { + ALuint buff=(ALuint)fx; + alDeleteBuffers(1,&buff); + } +} +void SMELT_IMPL::smChannelVol(SMCHN chn,int vol) +{ + if(pOpenALDevice) + { + if(vol<0)vol=0;if(vol>100)vol=100; + alSourcef((ALuint)chn,AL_GAIN,((ALfloat)vol)/100.); + } +} +void SMELT_IMPL::smChannelPan(SMCHN chn,int pan) +{ + if(pOpenALDevice) + { + if(pan<-100)pan=-100;if(pan>100)pan=100; + alSource3f((ALuint)chn,AL_POSITION,((ALfloat)pan)/100.,.0,.0); + } +} +void SMELT_IMPL::smChannelPitch(SMCHN chn,float pitch) +{ + if(pOpenALDevice)alSourcef((ALuint)chn,AL_PITCH,pitch); +} +void SMELT_IMPL::smChannelPause(SMCHN chn) +{ + if(pOpenALDevice)alSourcePause((ALuint)chn); +} +void SMELT_IMPL::smChannelResume(SMCHN chn) +{ + if(pOpenALDevice)alSourcePlay((ALuint)chn); +} +void SMELT_IMPL::smChannelStop(SMCHN chn) +{ + if(pOpenALDevice)alSourceStop((ALuint)chn); +} +void SMELT_IMPL::smChannelPauseAll() +{ + if(pOpenALDevice) + { + ALCcontext *ctx=alcGetCurrentContext(); + alcSuspendContext(ctx); + } +} +void SMELT_IMPL::smChannelResumeAll() +{ + if(pOpenALDevice) + { + ALCcontext *ctx=alcGetCurrentContext(); + alcProcessContext(ctx); + } +} +void SMELT_IMPL::smChannelStopAll() +{ + if(pOpenALDevice) + { + for(int i=0;i<scnt;++i)alSourceStop(src[i]); + } +} +bool SMELT_IMPL::smChannelIsPlaying(SMCHN chn) +{ + if(pOpenALDevice) + { + ALint state=AL_STOPPED; + alGetSourceiv((ALuint)chn,AL_SOURCE_STATE,&state); + return state==AL_PLAYING; + } + return false; +} +float SMELT_IMPL::smChannelGetPosf(SMCHN chn) +{ + if(pOpenALDevice) + { + ALfloat ret; + alGetSourcef((ALuint)chn,AL_SEC_OFFSET,&ret); + return (float)ret; + } + return -1.; +} +void SMELT_IMPL::smChannelSetPosf(SMCHN chn,float pos) +{ + if(pOpenALDevice)alSourcef((ALuint)chn,AL_SEC_OFFSET,(ALfloat)pos); +} +int SMELT_IMPL::smChannelGetPosd(SMCHN chn) +{ + if(pOpenALDevice) + { + ALint ret; + alGetSourcei((ALuint)chn,AL_SAMPLE_OFFSET,&ret); + return (int)ret; + } + return -1; +} +void SMELT_IMPL::smChannelSetPosd(SMCHN chn,int pos) +{ + if(pOpenALDevice)alSourcei((ALuint)chn,AL_SAMPLE_OFFSET,(ALint)pos); +} + +#ifdef ENABLE_OGG_SUPPORT +static size_t oggRead(void *ptr,size_t size,size_t nmemb,void *ds) +{ + oggdata *data=(oggdata*)ds; + const DWORD avail=data->size-data->pos; + size_t want=nmemb*size; + if(want>avail)want=avail-(avail%size); + if(want>0) + { + memcpy(ptr,data->data+data->pos,want); + data->pos+=want; + } + return want/size; +} +static int oggSeek(void *ds,ogg_int64_t offset,int whence) +{ + oggdata *data=(oggdata*)ds; + ogg_int64_t pos=0; + switch(whence) + { + case SEEK_SET:pos=offset;break; + case SEEK_CUR:pos=((ogg_int64_t)data->pos)+offset;break; + case SEEK_END:pos=((ogg_int64_t)data->size)+offset;break; + default: return -1; + } + if((pos<0)||(pos>((ogg_int64_t)data->size)))return -1; + data->pos=(DWORD)pos; + return 0; +} +static long oggLocate(void *ds) +{ + oggdata* data=(oggdata*)ds; + return (long)data->pos; +} +static int oggClose(void *ds){return 0;} + +static ov_callbacks oggrt={oggRead,oggSeek,oggClose,oggLocate}; +static void* readVorbis(const BYTE *data,const DWORD size, ALsizei *decomp_size,ALenum *fmt,ALsizei *freq) +{ + oggdata adata={data,size,0}; + OggVorbis_File vf; + memset(&vf,0,sizeof(vf)); + if(ov_open_callbacks(&adata,&vf,NULL,0,oggrt)==0) + { + int bs=0; + vorbis_info *info=ov_info(&vf,-1); + *decomp_size=0; + *fmt=(info->channels==1)?AL_FORMAT_MONO16:AL_FORMAT_STEREO16; + *freq=info->rate; + if(!(info->channels==1||info->channels==2)){ov_clear(&vf);return NULL;} + char buf[1024*16];long rc=0;size_t allocated=1024*16; + BYTE *ret=(ALubyte*)malloc(allocated); + while((rc=ov_read(&vf,buf,sizeof(buf),0,2,1,&bs))!=0) + { + if(rc>0) + { + *decomp_size+=rc; + if((unsigned)*decomp_size>=allocated) + { + allocated<<=1; + ALubyte *tmp=(ALubyte*)realloc(ret,allocated); + if(!tmp){free(ret);ret=NULL;break;} + ret=tmp; + } + memcpy(ret+(*decomp_size-rc),buf,rc); + } + } + ov_clear(&vf); + return ret; + } + return NULL; +} +#endif +static void* readRiffWv(const BYTE *data,const DWORD size, ALsizei *decomp_size,ALenum *fmt,ALsizei *freq) +{ + if(data[0x0]!='R'||data[0x1]!='I'||data[0x2]!='F'||data[0x3]!='F')return NULL; + if(data[0x8]!='W'||data[0x9]!='A'||data[0xA]!='V'||data[0xB]!='E')return NULL; + if(data[0xC]!='f'||data[0xD]!='m'||data[0xE]!='t'||data[0xF]!=' ')return NULL; + if(data[0x16]==2) + { + if(data[0x22]==16)*fmt=AL_FORMAT_STEREO16; + else if(data[0x22]==8)*fmt=AL_FORMAT_STEREO8; + else return NULL; + } + else if(data[0x16]==1) + { + if(data[0x22]==16)*fmt=AL_FORMAT_MONO16; + else if(data[0x22]==8)*fmt=AL_FORMAT_MONO8; + else return NULL; + }else return NULL; + *decomp_size=(ALsizei)(data[0x28]|(data[0x29]<<8L)|(data[0x2A]<<16L)|(data[0x2B]<<24L)); + *freq=(ALsizei)(data[0x18]|(data[0x19]<<8L)|(data[0x1A]<<16L)|(data[0x1B]<<24L)); + ALubyte *ret=(ALubyte*)malloc(*decomp_size); + memcpy(ret,data+44,*decomp_size); + return ret; +} +ALuint SMELT_IMPL::getSource() +{ + for(int i=0;i<scnt;++i) + { + ALint state=AL_PLAYING; + alGetSourceiv(src[i],AL_SOURCE_STATE,&state); + if(!(state==AL_PLAYING||state==AL_PAUSED))return src[i]; + } + if(scnt>=SRC_MAX)return 0; + ALuint ret=0; + alGenSources(1,&ret);if(!ret)return 0; + src[scnt++]=ret;return ret; +} +bool SMELT_IMPL::initOAL() +{ + if(pOpenALDevice)return true; + scnt=0;memset(src,0,sizeof(src)); + smLog("%s:" SLINE ": Initializing OpenAL...\n",SFX_OAL_SRCFN); + ALCdevice *dev=alcOpenDevice(NULL); + if(!dev) + { + smLog("%s:" SLINE ": alcOpenDevice() failed.\n",SFX_OAL_SRCFN); + return mute=true; + } + ALint caps[]={ALC_FREQUENCY,44100,0}; + ALCcontext *ctx=alcCreateContext(dev,caps); + if(!ctx) + { + smLog("%s:" SLINE ": alcCreateContext() failed.\n",SFX_OAL_SRCFN); + return mute=true; + } + alcMakeContextCurrent(ctx);alcProcessContext(ctx); + smLog("%s:" SLINE ": Done OpenAL initialization\n",SFX_OAL_SRCFN); + smLog("%s:" SLINE ": AL_VENDOR: %s\n",SFX_OAL_SRCFN,(char*)alGetString(AL_VENDOR)); + smLog("%s:" SLINE ": AL_RENDERER: %s\n",SFX_OAL_SRCFN,(char*)alGetString(AL_RENDERER)); + smLog("%s:" SLINE ": AL_VERSION: %s\n",SFX_OAL_SRCFN,(char*)alGetString(AL_VERSION)); + const char* ext=(const char*)alGetString(AL_EXTENSIONS); + lpp=strstr(ext,"AL_SOFT_loop_points")!=NULL; + if(!lpp)smLog("%s:" SLINE ": Warning: loop points not supported. Please recompile with OpenAL Soft.\n",SFX_OAL_SRCFN); + pOpenALDevice=(void*)dev; + return true; +} +void SMELT_IMPL::finiOAL() +{ + if(pOpenALDevice) + { + for(int i=0;i<scnt;++i)alSourceStop(src[i]); + alDeleteSources(scnt,src);scnt=0;memset(src,0,sizeof(src)); + ALCcontext *ctx=alcGetCurrentContext(); + ALCdevice *dev=alcGetContextsDevice(ctx); + alcMakeContextCurrent(NULL); + alcSuspendContext(ctx);alcDestroyContext(ctx); + alcCloseDevice(dev);pOpenALDevice=NULL; + } +} +#else +#include "sfx_dumb.cpp" +#endif //ifndef ENABLE_DUMB diff --git a/smelt/glfw_m/smelt_config.hpp b/smelt/glfw_m/smelt_config.hpp new file mode 100644 index 0000000..d215d36 --- /dev/null +++ b/smelt/glfw_m/smelt_config.hpp @@ -0,0 +1,30 @@ +// -*- C++ -*- +/* + * Simple MultimEdia LiTerator(SMELT) + * by Chris Xiong 2015 + * Configuration header for SDL version + * + * Modify this header according to your own requirements. + * + */ + +/* + * Maximum audio channels. + * (How many audio can be played simultaneously?) + */ +#define SRC_MAX 128 + +/* + * Vertex buffer size. + */ +#define VERTEX_BUFFER_SIZE 4000 + +/* + * Uncomment this to build a "dumb" version with no audio routines. + */ +//#define ENABLE_DUMB + +/* + * Undefine this to disable ogg support. + */ +#define ENABLE_OGG_SUPPORT diff --git a/smelt/glfw_m/smelt_internal.hpp b/smelt/glfw_m/smelt_internal.hpp new file mode 100644 index 0000000..2619b12 --- /dev/null +++ b/smelt/glfw_m/smelt_internal.hpp @@ -0,0 +1,249 @@ +// -*- C++ -*- +/* + * Simple MultimEdia LiTerator(SMELT) + * by Chris Xiong 2015 + * Internal header for GLFW version + * + * WARNING: This library is in development and interfaces would be very + * unstable. + * + */ +#ifndef SMELT_INTERNAL_H +#define SMELT_INTERNAL_H + +#include "../../include/smelt.hpp" +#include "smelt_config.hpp" +#include <cstdio> +#include <cstring> +#include <cstdlib> +#include <ctime> +#include <cstdarg> +#include <dirent.h> +#include <unistd.h> +#define GLEW_STATIC +#include <GL/glew.h> +#include <GLFW/glfw3.h> +#ifndef ENABLE_DUMB +#include <AL/al.h> +#include <AL/alc.h> +#include <AL/alext.h> +#ifdef ENABLE_OGG_SUPPORT +#include <ogg/ogg.h> +#include <vorbis/vorbisfile.h> +#endif +#endif +#ifdef WIN32 +#include <windows.h> +#include <intrin.h> +#endif + +#define xstr(s) str(s) +#define str(s) #s +#define SLINE xstr(__LINE__) + +class TOpenGLDevice +{ +public: + bool have_base_opengl; +}; + +struct glTexture; +class TRenderTargetList +{ +public: + int w,h,ms; + SMTEX tex; + GLuint depth,frame,colorms,sframe,sdepth,scolor; + TRenderTargetList *next; +}; +class TTextureList +{ +public: + SMTEX tex; + int w,h; + TTextureList *next; +}; +class TInputEventList +{ +public: + smInpEvent e; + TInputEventList *next; +}; + +class SMELT_IMPL:public SMELT +{ +public: + virtual void smRelease(); + virtual bool smInit(); + virtual void smFinale(); + virtual void smMainLoop(); + virtual void smUpdateFunc(smHook func); + virtual void smUpdateFunc(smHandler* h); + virtual void smUnFocFunc(smHook func); + virtual void smUnFocFunc(smHandler* h); + virtual void smFocFunc(smHook func); + virtual void smFocFunc(smHandler* h); + virtual void smQuitFunc(smHook func); + virtual void smQuitFunc(smHandler* h); + virtual void smWinTitle(const char* title); + virtual bool smIsActive(); + virtual void smNoSuspend(bool para); + virtual void smVidMode(int resX,int resY,bool _windowed); + virtual void smLogFile(const char* path); + virtual void smLog(const char* format,...); + virtual void smScreenShot(const char* path); + + virtual void smSetFPS(int fps); + virtual float smGetFPS(); + virtual float smGetDelta(); + virtual float smGetTime(); + + virtual SMSFX smSFXLoad(const char *path); + virtual SMSFX smSFXLoadFromMemory(const char *ptr,DWORD size); + virtual SMCHN smSFXPlay(SMSFX fx,int vol=100,int pan=0,float pitch=1.,bool loop=0); + virtual float smSFXGetLengthf(SMSFX fx); + virtual DWORD smSFXGetLengthd(SMSFX fx); + virtual void smSFXSetLoopPoint(SMSFX fx,DWORD l,DWORD r); + virtual void smSFXFree(SMSFX fx); + + virtual void smChannelVol(SMCHN chn,int vol); + virtual void smChannelPan(SMCHN chn,int pan); + virtual void smChannelPitch(SMCHN chn,float pitch); + virtual void smChannelPause(SMCHN chn); + virtual void smChannelResume(SMCHN chn); + virtual void smChannelStop(SMCHN chn); + virtual void smChannelPauseAll(); + virtual void smChannelResumeAll(); + virtual void smChannelStopAll(); + virtual bool smChannelIsPlaying(SMCHN chn); + virtual float smChannelGetPosf(SMCHN chn); + virtual void smChannelSetPosf(SMCHN chn,float pos); + virtual int smChannelGetPosd(SMCHN chn); + virtual void smChannelSetPosd(SMCHN chn,int pos); + + virtual void smGetMouse2f(float *x,float *y); + virtual void smSetMouse2f(float x,float y); + virtual void smSetMouseGrab(bool enabled); + virtual int smGetWheel(); + virtual bool smIsMouseOver(); + virtual int smGetKeyState(int key); + virtual int smGetKey(); + virtual bool smGetInpEvent(smInpEvent *e); + + virtual bool smRenderBegin2D(bool ztest=0,SMTRG trg=0); + virtual bool smRenderBegin3D(float fov,bool ztest=0,SMTRG trg=0); + virtual bool smRenderEnd(); + virtual void sm3DCamera6f2v(float *pos,float *rot); + virtual void sm2DCamera5f3v(float *pos,float *dpos,float *rot); + virtual void smMultViewMatrix(float *mat); + virtual void smClrscr(DWORD color,bool clearcol=true,bool cleardep=true); + virtual void smRenderLinefd(float x1,float y1,float z1,float x2,float y2,float z2,DWORD color); + virtual void smRenderLinefvd(float *p1,float *p2,DWORD color); + virtual void smRenderTriangle(smTriangle *t); + virtual void smRenderQuad(smQuad *q); + virtual smVertex* smGetVertArray(); + virtual void smDrawVertArray(int prim,SMTEX texture,int blend,int _primcnt); + virtual void smDrawCustomIndexedVertices(smVertex* vb,WORD* ib,int vbc,int ibc,int blend,SMTEX texture); + + virtual SMTRG smTargetCreate(int w,int h,int ms=0); + virtual SMTEX smTargetTexture(SMTRG targ); + virtual void smTargetFree(SMTRG targ); + + virtual SMTEX smTextureCreate(int w,int h); + virtual SMTEX smTextureLoad(const char *path); + virtual SMTEX smTextureLoadFromMemory(const char *ptr,DWORD size); + virtual void smTextureFree(SMTEX tex); + virtual void smTextureOpt(int potopt=TPOT_NONPOT,int filter=TFLT_LINEAR); + virtual int smTextureGetWidth(SMTEX tex,bool original=false); + virtual int smTextureGetHeight(SMTEX tex,bool original=false); + virtual DWORD* smTextureLock(SMTEX tex,int l,int t,int w,int h,bool ro=true); + virtual void smTexutreUnlock(SMTEX tex); +//internal routines&variables... + static SMELT_IMPL* getInterface(); + void focusChange(bool actif); + + void *hwnd; + bool Active; + char curError[256]; + + bool (*pUpdateFunc)(); + bool (*pUnFocFunc)(); + bool (*pFocFunc)(); + bool (*pQuitFunc)(); + smHandler *updateHandler,*unFocHandler,*focHandler,*quitHandler; + const char *Icon; + char winTitle[256]; + int scrw,scrh; + int dispw,disph; + bool windowed,vsync; + char logFile[256]; + int limfps; + bool hideMouse,noSuspend; + + TOpenGLDevice *pOpenGLDevice; + smVertex *vertexArray; + smVertex *vertexBuf; + GLushort *indexBuf; + GLuint IndexBufferObject; + GLuint VertexBufferObject; + GLuint VertexArrayObject; + GLuint ShaderProgram; + GLuint fragshader,vertshader; + int loc_tex,loc_mmodv,loc_mproj; + float mmodv[16],mproj[16]; + TRenderTargetList *targets; + TRenderTargetList *curTarget; + TTextureList *textures; + bool tdmode; + int primcnt,primType,primBlend,filtermode; + SMTEX primTex,emptyTex; + bool zbufenabled; + bool checkGLExtension(const char *extlist,const char *ext); + void unloadGLEntryPoints(); + bool loadGLEntryPoints(); + bool initOGL(); + void finiOGL(); + bool restOGL(); + bool confOGL(); + void batchOGL(bool endScene=false); + void configTexture(glTexture *t,int w,int h,DWORD *px,bool compress=true); + void bindTexture(glTexture *t); + bool buildTarget(TRenderTargetList *pTarget,GLuint texid,int w,int h,int ms); + SMTEX buildTexture(int w,int h,DWORD *px); + void setBlend(int blend); + void configProjectionMatrix2D(int w,int h); + void configProjectionMatrix3D(int w,int h,float fov); + DWORD* decodeImage(BYTE *data,const char *fn,DWORD size,int &w,int &h); + + void *pOpenALDevice; + bool mute,lpp; + bool initOAL(); + void finiOAL(); +#ifndef ENABLE_DUMB + int scnt; + ALuint src[SRC_MAX]; + ALuint getSource(); +#endif + + int posz,lkey; + float posx,posy; + int keymods; + bool mouseOver,captured; + char keyz[256]; + bool keylst[256]; + TInputEventList *inpQueue; + void initInput(); + void clearQueue(); + void buildEvent(int type,int k,int scan,int flags,int x,int y); + bool procGLFWEvent(); + int GLFWKeyToSMKey(int glfwkey); + + float timeDelta,updateFPSDelay,fps,timeS; + DWORD fixDelta,t0; + int fcnt; + DWORD dt; +private: + SMELT_IMPL(); +}; +extern SMELT_IMPL *pSM; +#endif diff --git a/smelt/glfw_m/smmath_priv.hpp b/smelt/glfw_m/smmath_priv.hpp new file mode 100644 index 0000000..90f0e2a --- /dev/null +++ b/smelt/glfw_m/smmath_priv.hpp @@ -0,0 +1,165 @@ +// -*- C++ -*- +/* + * Simple MultimEdia LiTerator(SMELT) + * by Chris Xiong 2015 + * Math header & implementation for the core + * + * WARNING: This library is in development and interfaces would be very + * unstable. + * + */ +#ifndef SMMATH_H +#define SMMATH_H +#include <cmath> +#include <cstddef> +#define sqr(x) ((x)*(x)) +#define EPS 1e-6 +#ifndef PI +#define PI 3.14159265358979323846f +#endif + +class smMath +{ +public: + static double deg2rad(double deg){return deg/180.*PI;} + static double rad2deg(double rad){return rad/PI*180.;} + static double clamprad(double a){while(a<0)a+=2*PI;while(a>2*PI)a-=2*PI;return a;} + static double clampdeg(double a){while(a<0)a+=360.;while(a>360)a-=360.;return a;} +}; +class smvec2d +{ +public: + float x,y; + smvec2d(float _x,float _y){x=_x;y=_y;} + smvec2d(){x=y=.0;} + float l(){return sqrtf(sqr(x)+sqr(y));} + void normalize(){float L=l();if(L<EPS)return;x/=L;y/=L;} + smvec2d getNormalized(){float L=l();if(L<EPS)return smvec2d(0,0);return smvec2d(x/L,y/L);} + void swap(){float t=x;x=y;y=t;} + void rotate(float rad){float tx=x*cosf(rad)+y*sinf(rad),ty=y*cosf(rad)-x*sinf(rad);x=tx,y=ty;} + smvec2d getRotate(float rad){float tx=x*cosf(rad)+y*sinf(rad),ty=y*cosf(rad)-x*sinf(rad);return smvec2d(tx,ty);} + friend smvec2d operator -(smvec2d a,smvec2d b){return smvec2d(a.x-b.x,a.y-b.y);} + friend smvec2d operator +(smvec2d a,smvec2d b){return smvec2d(a.x+b.x,a.y+b.y);} + friend float operator |(smvec2d a,smvec2d b){return a.x*b.x+a.y*b.y;} + friend float operator *(smvec2d a,smvec2d b){return a.x*b.y-b.x*a.y;} + friend smvec2d operator *(float a,smvec2d b){return smvec2d(a*b.x,a*b.y);} + friend smvec2d operator *(smvec2d a,float b){return smvec2d(b*a.x,b*a.y);} + friend float operator ^(smvec2d a,smvec2d b){return (a|b)/a.l()/b.l();} +}; + +class smvec3d +{ +public: + float x,y,z; + smvec3d(float _x,float _y,float _z){x=_x;y=_y;z=_z;} + smvec3d(smvec2d a,float _z=.0){x=a.x;y=a.y;z=_z;} + smvec3d(){x=y=z=.0;} + float l(){return sqrtf(sqr(x)+sqr(y)+sqr(z));} + void normalize(){float L=l();if(L<EPS)return;x/=L;y/=L;z/=L;} + smvec3d getNormalized(){float L=l();if(L<EPS)return smvec3d(0,0,0);return smvec3d(x/L,y/L,z/L);} + friend smvec3d operator -(smvec3d a,smvec3d b){return smvec3d(a.x-b.x,a.y-b.y,a.z-b.z);} + friend smvec3d operator +(smvec3d a,smvec3d b){return smvec3d(a.x+b.x,a.y+b.y,a.z+b.z);} + friend float operator |(smvec3d a,smvec3d b){return a.x*b.x+a.y*b.y+a.z*b.z;} + friend smvec3d operator *(smvec3d a,smvec3d b){return smvec3d(a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x);} + friend smvec3d operator *(float a,smvec3d b){return smvec3d(a*b.x,a*b.y,a*b.z);} + friend smvec3d operator *(smvec3d a,float b){return smvec3d(b*a.x,b*a.y,b*a.z);} + friend float operator ^(smvec3d a,smvec3d b){return (a|b)/a.l()/b.l();} +}; + +class smvec4d +{ +public: + float x,y,z,w; + smvec4d(float _x,float _y,float _z,float _w){x=_x;y=_y;z=_z;w=_w;} + smvec4d(smvec3d a,float _w=.0){x=a.x;y=a.y;z=a.z;w=_w;} + smvec4d(){x=y=z=w=.0;} + float l(){return sqrt(sqr(x)+sqr(y)+sqr(z)+sqr(w));} + void normalize(){float L=l();if(L<EPS)return;x/=L;y/=L;z/=L;w/=L;} + smvec4d getNormalized(){float L=l();if(L<EPS)return smvec4d(0,0,0,0);return smvec4d(x/L,y/L,z/L,w/L);} + friend smvec4d operator -(smvec4d a,smvec4d b){return smvec4d(a.x-b.x,a.y-b.y,a.z-b.z,a.w-b.w);} + friend smvec4d operator +(smvec4d a,smvec4d b){return smvec4d(a.x+b.x,a.y+b.y,a.z+b.z,a.w+b.w);} + friend float operator |(smvec4d a,smvec4d b){return a.x*b.x+a.y*b.y+a.z*b.z+a.w*b.w;} + //Note: this doesn't do a real 4D cross product. + friend smvec4d operator *(smvec4d a,smvec4d b){return smvec4d(a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x,1);} + friend smvec4d operator *(float a,smvec4d b){return smvec4d(a*b.x,a*b.y,a*b.z,a*b.w);} + friend smvec4d operator *(smvec4d a,float b){return smvec4d(b*a.x,b*a.y,b*a.z,b*a.w);} + friend float operator ^(smvec4d a,smvec4d b){return (a|b)/a.l()/b.l();} +}; + +class smMatrix +{ +public: + float m[16]; + /* sf 0 1 2 3 + * 0 00 04 08 12 + * 1 01 05 09 13 + * 2 02 06 10 14 + * 3 03 07 11 15 + */ + smMatrix(){for(int i=0;i<16;++i)m[i]=.0;} + smMatrix(const float* _m){memcpy(m,_m,sizeof(m));} + smMatrix(const smMatrix ©){for(int i=0;i<16;++i)m[i]=copy.m[i];} + float* operator [](int s){if(s>=0&&s<4)return m+s*4;else return NULL;} + void clear(){for(int i=0;i<16;++i)m[i]=.0;} + void loadIdentity(){clear();m[0]=m[5]=m[10]=m[15]=1.;} + void translate(float x,float y,float z) + { + smMatrix tmp;tmp.loadIdentity(); + tmp.m[12]=x;tmp.m[13]=y;tmp.m[14]=z; + *this=*this*tmp; + } + void rotate(float a,float x,float y,float z) + { + if(smvec3d(x,y,z).l()<=EPS)return; + if(fabsf(smvec3d(x,y,z).l()-1)>EPS) + { + smvec3d a(x,y,z);a.normalize(); + x=a.x;y=a.y;z=a.z; + } + smMatrix tmp; + float c=cosf(a),s=sinf(a); + tmp.m[ 0]=x*x*(1-c)+c; + tmp.m[ 4]=x*y*(1-c)-z*s; + tmp.m[ 8]=x*z*(1-c)+y*s; + tmp.m[ 1]=y*x*(1-c)+z*s; + tmp.m[ 5]=y*y*(1-c)+c; + tmp.m[ 9]=y*z*(1-c)-x*s; + tmp.m[ 2]=x*z*(1-c)-y*s; + tmp.m[ 6]=y*z*(1-c)+x*s; + tmp.m[10]=z*z*(1-c)+c; + tmp.m[15]=1; + *this=*this*tmp; + } + void lookat(smvec3d eye,smvec3d at,smvec3d up) + { + smvec3d f=at-eye;f.normalize();up.normalize(); + smvec3d s=f*up;smvec3d u=s.getNormalized()*f; + m[0]= s.x;m[4]= s.y;m[ 8]= s.z;m[12]=0; + m[1]= u.x;m[5]= u.y;m[ 9]= u.z;m[13]=0; + m[2]=-f.x;m[6]=-f.y;m[10]=-f.z;m[14]=0; + m[3]= 0;m[7]= 0;m[11]= 0;m[15]=1; + } + friend smMatrix operator *(smMatrix a,smMatrix b) + { + smMatrix ret; + for(int i=0;i<4;++i) + for(int j=0;j<4;++j) + for(int k=0;k<4;++k) + ret[j][i]+=a[k][i]*b[j][k]; + return ret; + } + friend smvec3d operator *(smMatrix a,smvec3d b) + { + return smvec3d(a[0][0]*b.x+a[1][0]*b.y+a[2][0]*b.z, + a[0][1]*b.x+a[1][1]*b.y+a[2][1]*b.z, + a[0][2]*b.x+a[1][2]*b.y+a[2][2]*b.z); + } + friend smvec4d operator *(smMatrix a,smvec4d b) + { + return smvec4d(a[0][0]*b.x+a[1][0]*b.y+a[2][0]*b.z+a[3][0]*b.w, + a[0][1]*b.x+a[1][1]*b.y+a[2][1]*b.z+a[3][1]*b.w, + a[0][2]*b.x+a[1][2]*b.y+a[2][2]*b.z+a[3][2]*b.w, + a[0][3]*b.x+a[1][3]*b.y+a[2][3]*b.z+a[3][3]*b.w); + } +}; +#endif diff --git a/smelt/glfw_m/sys_glfw.cpp b/smelt/glfw_m/sys_glfw.cpp new file mode 100644 index 0000000..a5829f3 --- /dev/null +++ b/smelt/glfw_m/sys_glfw.cpp @@ -0,0 +1,334 @@ +// -*- C++ -*- +/* + * Simple MultimEdia LiTerator(SMELT) + * by Chris Xiong 2015 + * SMELT system implementation + * + * WARNING: This library is in development and interfaces would be very + * unstable. + * + */ +#include "smelt_internal.hpp" +#include <thread> +#include <chrono> +static const char* SYS_GLFW_SRCFN="smelt/glfw_m/sys_glfw.cpp"; +int refcnt=0; +SMELT_IMPL *pSM=0; +char lasterr[1024]; + +void glfwErrorHandler(int err,const char* desc); +void glfwFocChangeHandler(GLFWwindow*,int foc); +void glfwCursorEnterHandler(GLFWwindow*,int ent); +void glfwKBEventHandler(GLFWwindow* window,int key,int scancode,int action,int mods); +void glfwMouseButtonHandler(GLFWwindow* w,int btn,int action,int mods); +void glfwMouseMotionHandler(GLFWwindow*,double x,double y); +void glfwMouseWheelHandler(GLFWwindow* w,double x,double y); + +SMELT* smGetInterface(int apilevel) +{ + if(apilevel==SMELT_APILEVEL) + return(SMELT*)SMELT_IMPL::getInterface(); + else return 0; +} + +SMELT_IMPL* SMELT_IMPL::getInterface() +{ + if(!pSM)pSM=new SMELT_IMPL(); + ++refcnt;return pSM; +} + +void SMELT_IMPL::smRelease() +{ + --refcnt; + if(!refcnt) + { + if(pSM->hwnd)pSM->smFinale(); + delete pSM;pSM=0; + } +} + +bool SMELT_IMPL::smInit() +{ + smLog("%s:" SLINE ": Initalizing SMELT...\n",SYS_GLFW_SRCFN); + smLog("%s:" SLINE ": SMELT api version %d\n",SYS_GLFW_SRCFN,SMELT_APILEVEL); + time_t t=time(NULL); + smLog("%s:" SLINE ": Date %s",SYS_GLFW_SRCFN,asctime(localtime(&t))); +#ifdef WIN32 + OSVERSIONINFO os_ver; MEMORYSTATUS mem_st; + os_ver.dwOSVersionInfoSize=sizeof(os_ver); + GetVersionEx(&os_ver); + smLog("%s:" SLINE ": OS: Windows %ld.%ld.%ld\n", SYS_GLFW_SRCFN,os_ver.dwMajorVersion,os_ver.dwMinorVersion,os_ver.dwBuildNumber); + + int CPUInfo[4]={-1}; + __cpuid(CPUInfo,0x80000000); + unsigned int nExIds=CPUInfo[0]; + char *cpuName,*loced;cpuName=(char*)calloc(0x40,sizeof(char));loced=cpuName; + for(unsigned int i=0x80000000;i<=nExIds;++i) + { + __cpuid(CPUInfo, i); + if(i==0x80000002) + memcpy(cpuName,CPUInfo,sizeof(CPUInfo)); + else if(i==0x80000003) + memcpy(cpuName+16,CPUInfo,sizeof(CPUInfo)); + else if(i==0x80000004) + memcpy(cpuName+32, CPUInfo, sizeof(CPUInfo)); + } + while(*cpuName==' ')++cpuName; + smLog("%s:" SLINE ": CPU: %s\n", SYS_GLFW_SRCFN,cpuName); + free(loced); + + GlobalMemoryStatus(&mem_st); + smLog("%s:" SLINE ": Memory: %ldK total, %ldK free\n", SYS_GLFW_SRCFN,mem_st.dwTotalPhys/1024L,mem_st.dwAvailPhys/1024L); +#else + system("uname -svm > /tmp/os.out"); + char osv[100];FILE* a=fopen("/tmp/os.out","r");fgets(osv,100,a);fclose(a); + osv[strlen(osv)-1]='\0'; + smLog("%s:" SLINE ": OS: %s\n",SYS_GLFW_SRCFN,osv); + system("rm /tmp/os.out"); + + system("cat /proc/cpuinfo | grep name -m 1 > /tmp/cpu.out"); + a=fopen("/tmp/cpu.out","r");fgets(osv,100,a);fclose(a); + osv[strlen(osv)-1]='\0';char *ptr=osv;while(*ptr!=':')++ptr;ptr+=2; + smLog("%s:" SLINE ": CPU: %s\n",SYS_GLFW_SRCFN,osv); + system("rm /tmp/cpu.out"); + + a=fopen("/proc/meminfo","r"); + unsigned totalm,freem; + fscanf(a,"MemTotal: %u kB\n",&totalm); + fscanf(a,"MemFree: %u kB\n",&freem); + smLog("%s:" SLINE ": RAM: %ukB installed, %ukB free\n",SYS_GLFW_SRCFN,totalm,freem); + fclose(a); +#endif + glfwSetErrorCallback(glfwErrorHandler); + if(!glfwInit()) + { + smLog("%s:" SLINE ": glfwInit() failed with error %s\n",SYS_GLFW_SRCFN,lasterr); + return false; + } + GLFWmonitor *moninfo=glfwGetPrimaryMonitor(); + dispw=glfwGetVideoMode(moninfo)->width; + disph=glfwGetVideoMode(moninfo)->height; + smLog("%s:" SLINE ": Screen: %d x %d\n",SYS_GLFW_SRCFN,dispw,disph); + glfwWindowHint(GLFW_RED_BITS,8); + glfwWindowHint(GLFW_GREEN_BITS,8); + glfwWindowHint(GLFW_BLUE_BITS,8); + glfwWindowHint(GLFW_ALPHA_BITS,8); + glfwWindowHint(GLFW_DEPTH_BITS,16); + glfwWindowHint(GLFW_DOUBLEBUFFER,1); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR,3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR,3); + glfwWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE); + GLFWwindow *screen=glfwCreateWindow(windowed?scrw:dispw,windowed?scrh:disph,winTitle,NULL,NULL); + hwnd=(void*)screen; + if(!hwnd) + { + smLog("%s:" SLINE ": glfwCreateWindow() failed with error %s\n",SYS_GLFW_SRCFN,lasterr); + glfwTerminate(); + return false; + } + glfwMakeContextCurrent(screen); + glfwSwapInterval(vsync?1:0); + if(!windowed) + { + mouseOver=true; + if(!pSM->Active)pSM->focusChange(true); + } + if(hideMouse)glfwSetInputMode(screen,GLFW_CURSOR,GLFW_CURSOR_HIDDEN); + glfwSetWindowFocusCallback(screen,glfwFocChangeHandler); + glfwSetCursorEnterCallback(screen,glfwCursorEnterHandler); + glfwSetKeyCallback(screen,glfwKBEventHandler); + glfwSetCursorPosCallback(screen,glfwMouseMotionHandler); + glfwSetMouseButtonCallback(screen,glfwMouseButtonHandler); + glfwSetScrollCallback(screen,glfwMouseWheelHandler); + initInput(); + if(!initOGL()){smFinale();return false;} + if(!initOAL()){smFinale();return false;} + t0=DWORD(glfwGetTime()*1000.);dt=fcnt=0;fps=.0; + updateFPSDelay=.0; + return true; +} + +void SMELT_IMPL::smFinale() +{ + smLog("%s:" SLINE ": Cleaning up...\n",SYS_GLFW_SRCFN); + clearQueue();finiOAL();finiOGL(); + glfwDestroyWindow((GLFWwindow*)hwnd);glfwTerminate();hwnd=0; +} + +void SMELT_IMPL::smMainLoop() +{ + if(!hwnd)return smLog("%s:" SLINE ": Error: SMELT is not initialized.\n",SYS_GLFW_SRCFN); + if(!pUpdateFunc&&!updateHandler) return smLog("%s:" SLINE ": UpdateFunc is not defined.\n",SYS_GLFW_SRCFN); + Active=true; + for(;;) + { + glfwPollEvents(); + bool loopcont=true; + loopcont=procGLFWEvent(); + if(!loopcont)break; + if(Active||noSuspend) + { + DWORD ticks; + do{ticks=DWORD(glfwGetTime()*1000.);dt=ticks-t0;}while(dt<1); + if(dt>=fixDelta) + { + timeDelta=dt/1000.; + if(timeDelta>0.2)timeDelta=fixDelta?fixDelta/1000.:.01; + ++fcnt;updateFPSDelay+=timeDelta;t0=ticks;timeS+=timeDelta; + if(updateFPSDelay>1){fps=fcnt/updateFPSDelay;updateFPSDelay=.0;fcnt=0;} + if(pUpdateFunc){if(pUpdateFunc())break;} + if(updateHandler){if(updateHandler->handlerFunc())break;} + for(int i=1;i<=255;++i)keylst[i]=((keyz[i]&4)!=0); + clearQueue(); + } + else + if(fixDelta&&dt+3<fixDelta)std::this_thread::sleep_for(std::chrono::milliseconds(1)); + }else std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + clearQueue();Active=false; +} +void SMELT_IMPL::smUpdateFunc(smHook func){pUpdateFunc=func;} +void SMELT_IMPL::smUpdateFunc(smHandler* h){updateHandler=h;} +void SMELT_IMPL::smUnFocFunc(smHook func){pUnFocFunc=func;} +void SMELT_IMPL::smUnFocFunc(smHandler* h){unFocHandler=h;} +void SMELT_IMPL::smFocFunc(smHook func){pFocFunc=func;} +void SMELT_IMPL::smFocFunc(smHandler* h){focHandler=h;} +void SMELT_IMPL::smQuitFunc(smHook func){pQuitFunc=func;} +void SMELT_IMPL::smQuitFunc(smHandler* h){quitHandler=h;} +void SMELT_IMPL::smWinTitle(const char *title){strcpy(winTitle,title);} +bool SMELT_IMPL::smIsActive(){return Active;} +void SMELT_IMPL::smNoSuspend(bool para){noSuspend=para;} +void SMELT_IMPL::smVidMode(int resX,int resY,bool _windowed) +{ + if(vertexArray)return; + if(!pOpenGLDevice)scrw=resX,scrh=resY,windowed=_windowed; + else if(windowed!=_windowed) + { + windowed=_windowed; + glfwSetWindowSize((GLFWwindow*)hwnd,windowed?scrw:dispw,windowed?scrh:disph); + restOGL(); + if(!windowed){mouseOver=true;if(!pSM->Active)pSM->focusChange(true);} + } +} +void SMELT_IMPL::smLogFile(const char* path) +{ + strcpy(logFile,path); + FILE *tf=fopen(logFile,"w"); + if(!tf)*logFile=0;else fclose(tf); +} +void SMELT_IMPL::smLog(const char* format,...) +{ + va_list ap; + va_start(ap,format);vfprintf(stderr,format,ap);va_end(ap); + FILE *logf=fopen(logFile,"a");if(!logf)return; + va_start(ap,format);vfprintf(logf,format,ap);va_end(ap); + fclose(logf); +} +void SMELT_IMPL::smScreenShot(const char* path) +{ + if(pOpenGLDevice) + { + //glFinish(); + //glReadPixels(0,0,screen->w,screen->h,GL_RGB,GL_UNSIGNED_BYTE,surface->pixels); + } +} +void SMELT_IMPL::smSetFPS(int fps) +{ + vsync=(fps==FPS_VSYNC); + if(pOpenGLDevice)glfwSwapInterval(vsync?1:0); + if(fps>0)fixDelta=1000./fps;else fixDelta=0; +} +float SMELT_IMPL::smGetFPS(){return fps;} +float SMELT_IMPL::smGetDelta(){return timeDelta;} +float SMELT_IMPL::smGetTime(){return timeS;} + +SMELT_IMPL::SMELT_IMPL() +{ + hwnd=NULL;Active=false;memset(curError,0,sizeof(curError)); + pUpdateFunc=pUnFocFunc=pFocFunc=pQuitFunc=NULL; + updateHandler=unFocHandler=focHandler=quitHandler=NULL; + Icon=NULL;strcpy(winTitle,"untitled");scrw=dispw=800;scrh=disph=600; + windowed=vsync=false;memset(logFile,0,sizeof(logFile)); + limfps=0;hideMouse=true;noSuspend=false; + pOpenGLDevice=NULL;targets=NULL;curTarget=NULL; + textures=NULL;vertexArray=NULL;vertexBuf=NULL;indexBuf=NULL;primTex=0; + pOpenALDevice=NULL;mute=false;inpQueue=NULL;posz=0;posx=posy=.0; + mouseOver=true;captured=false;keymods=0;zbufenabled=false; + timeDelta=updateFPSDelay=fps=.0;fcnt=dt=fixDelta=0; +} +void SMELT_IMPL::focusChange(bool actif) +{ + Active=actif; + if(actif){pFocFunc?pFocFunc():0;focHandler?focHandler->handlerFunc():0;} + else {pUnFocFunc?pUnFocFunc():0;unFocHandler?unFocHandler->handlerFunc():0;}; +} +bool SMELT_IMPL::procGLFWEvent() +{ + if(glfwWindowShouldClose((GLFWwindow*)hwnd)) + { + bool accepted=true; + if(pSM->pQuitFunc&&pSM->pQuitFunc())accepted=false; + if(pSM->quitHandler&&quitHandler->handlerFunc())accepted=false; + if(accepted)return false; + } + return true; +} +void glfwErrorHandler(int err,const char* desc) +{ + strcpy(lasterr,desc); +} +void glfwFocChangeHandler(GLFWwindow*,int foc) +{ + pSM->focusChange(foc); +} +void glfwCursorEnterHandler(GLFWwindow*,int ent) +{ + pSM->mouseOver=ent; +} +void glfwKBEventHandler(GLFWwindow* window,int key,int scancode,int action,int mods) +{ + if(action==GLFW_RELEASE) + { + pSM->keymods=mods; + pSM->buildEvent(INPUT_KEYUP,key,0,0,-1,-1); + } + else + { + pSM->keymods=mods; + if((pSM->keymods&GLFW_MOD_ALT)&&((key==GLFW_KEY_ENTER)||(key==GLFW_KEY_KP_ENTER))) + pSM->smVidMode(pSM->scrw,pSM->scrh,!pSM->windowed); + pSM->buildEvent(INPUT_KEYDOWN,key,0,0,-1,-1); + } +} +void glfwMouseButtonHandler(GLFWwindow* w,int btn,int action,int mods) +{ + double x,y;glfwGetCursorPos(w,&x,&y); + if(action==GLFW_PRESS) + { + if(btn==GLFW_MOUSE_BUTTON_LEFT) + pSM->buildEvent(INPUT_MBUTTONDOWN,SMK_LBUTTON,0,0,x,y); + if(btn==GLFW_MOUSE_BUTTON_RIGHT) + pSM->buildEvent(INPUT_MBUTTONDOWN,SMK_RBUTTON,0,0,x,y); + if(btn==GLFW_MOUSE_BUTTON_MIDDLE) + pSM->buildEvent(INPUT_MBUTTONDOWN,SMK_MBUTTON,0,0,x,y); + } + else + { + if(btn==GLFW_MOUSE_BUTTON_LEFT) + pSM->buildEvent(INPUT_MBUTTONUP,SMK_LBUTTON,0,0,x,y); + if(btn==GLFW_MOUSE_BUTTON_RIGHT) + pSM->buildEvent(INPUT_MBUTTONUP,SMK_RBUTTON,0,0,x,y); + if(btn==GLFW_MOUSE_BUTTON_MIDDLE) + pSM->buildEvent(INPUT_MBUTTONUP,SMK_MBUTTON,0,0,x,y); + } +} +void glfwMouseMotionHandler(GLFWwindow*,double x,double y) +{ + pSM->buildEvent(INPUT_MOUSEMOVE,0,0,0,x,y); +} +void glfwMouseWheelHandler(GLFWwindow* w,double x,double y) +{ + double cx,cy;glfwGetCursorPos(w,&cx,&cy); + if(y>0)pSM->buildEvent(INPUT_MOUSEWHEEL,1,0,0,cx,cy); + if(y<0)pSM->buildEvent(INPUT_MOUSEWHEEL,-1,0,0,cx,cy); +} diff --git a/smelt/sdl/.directory b/smelt/sdl/.directory deleted file mode 100644 index f403253..0000000 --- a/smelt/sdl/.directory +++ /dev/null @@ -1,6 +0,0 @@ -[Dolphin] -GroupedSorting=true -PreviewsShown=true -SortRole=type -Timestamp=2016,1,25,22,42,36 -Version=3 diff --git a/smelt/sdl/CxImage b/smelt/sdl/CxImage new file mode 120000 index 0000000..07300ae --- /dev/null +++ b/smelt/sdl/CxImage @@ -0,0 +1 @@ +../glfw/CxImage
\ No newline at end of file diff --git a/smelt/sdl/CxImage/.directory b/smelt/sdl/CxImage/.directory deleted file mode 100644 index 8add095..0000000 --- a/smelt/sdl/CxImage/.directory +++ /dev/null @@ -1,6 +0,0 @@ -[Dolphin] -GroupedSorting=true -PreviewsShown=true -SortRole=type -Timestamp=2015,7,23,0,2,39 -Version=3 diff --git a/smelt/sdl/CxImage/license.txt b/smelt/sdl/CxImage/license.txt deleted file mode 100644 index 1ea1f04..0000000 --- a/smelt/sdl/CxImage/license.txt +++ /dev/null @@ -1,48 +0,0 @@ -This copy of the CxImage notices is provided for your convenience. In case of
-any discrepancy between this copy and the notices in the file ximage.h that is
-included in the CxImage distribution, the latter shall prevail.
-
-If you modify CxImage you may insert additional notices immediately following
-this sentence.
-
---------------------------------------------------------------------------------
-
-COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
-
-CxImage version 7.0.0 31/Dec/2010
-
-CxImage : Copyright (C) 2001 - 2010, Davide Pizzolato
-
-Original CImage and CImageIterator implementation are:
-Copyright (C) 1995, Alejandro Aguilar Sierra (asierra(at)servidor(dot)unam(dot)mx)
-
-Covered code is provided under this license on an "as is" basis, without warranty
-of any kind, either expressed or implied, including, without limitation, warranties
-that the covered code is free of defects, merchantable, fit for a particular purpose
-or non-infringing. The entire risk as to the quality and performance of the covered
-code is with you. Should any covered code prove defective in any respect, you (not
-the initial developer or any other contributor) assume the cost of any necessary
-servicing, repair or correction. This disclaimer of warranty constitutes an essential
-part of this license. No use of any covered code is authorized hereunder except under
-this disclaimer.
-
-Permission is hereby granted to use, copy, modify, and distribute this
-source code, or portions hereof, for any purpose, including commercial applications,
-freely and without fee, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not
-claim that you wrote the original software. If you use this software
-in a product, an acknowledgment in the product documentation would be
-appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must not be
-misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source distribution.
-
---------------------------------------------------------------------------------
-
-Other information: about CxImage, and the latest version, can be found at the
-CxImage home page: http://www.xdp.it
-
---------------------------------------------------------------------------------
diff --git a/smelt/sdl/CxImage/makefile b/smelt/sdl/CxImage/makefile deleted file mode 100644 index 725a62a..0000000 --- a/smelt/sdl/CxImage/makefile +++ /dev/null @@ -1,12 +0,0 @@ -CC= g++ -CXXFLAGS= -c -Os -D_LINUX -Wall -fPIC -AR= ar - -all: objects archive clean - -objects: - $(CC) *.cpp $(CXXFLAGS) -archive: - $(AR) rcs libCxImage.a *.o -clean: - rm *.o && mv libCxImage.a ../ diff --git a/smelt/sdl/CxImage/tif_xfile.cpp b/smelt/sdl/CxImage/tif_xfile.cpp deleted file mode 100644 index 4d1d79a..0000000 --- a/smelt/sdl/CxImage/tif_xfile.cpp +++ /dev/null @@ -1,221 +0,0 @@ -/*
- * TIFF file IO, using CxFile.
- */
-
-#ifdef WIN32
- #include <windows.h>
-#endif
-#include <stdio.h>
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_TIF
-
-#include "../tiff/tiffiop.h"
-#include "../tiff/tiffvers.h"
-
-#include "xfile.h"
-
-static tsize_t
-_tiffReadProcEx(thandle_t fd, tdata_t buf, tsize_t size)
-{
- return (tsize_t)((CxFile*)fd)->Read(buf, 1, size);
-}
-
-static tsize_t
-_tiffWriteProcEx(thandle_t fd, tdata_t buf, tsize_t size)
-{
- return (tsize_t)((CxFile*)fd)->Write(buf, 1, size);
-}
-
-static toff_t
-_tiffSeekProcEx(thandle_t fd, toff_t off, int whence)
-{
- if ( off == 0xFFFFFFFF )
- return 0xFFFFFFFF;
- if (!((CxFile*)fd)->Seek(off, whence))
- return 0xFFFFFFFF;
- if (whence == SEEK_SET)
- return off;
-
- return (toff_t)((CxFile*)fd)->Tell();
-}
-
-// Return nonzero if error
-static int
-_tiffCloseProcEx(thandle_t /*fd*/)
-{
-// return !((CxFile*)fd)->Close(); // "//" needed for memory files <DP>
- return 0;
-}
-
-#include <sys/stat.h>
-
-static toff_t
-_tiffSizeProcEx(thandle_t fd)
-{
- return ((CxFile*)fd)->Size();
-}
-
-static int
-_tiffMapProcEx(thandle_t /*fd*/, tdata_t* /*pbase*/, toff_t* /*psize*/)
-{
- return (0);
-}
-
-static void
-_tiffUnmapProcEx(thandle_t /*fd*/, tdata_t /*base*/, toff_t /*size*/)
-{
-}
-
-// Open a TIFF file descriptor for read/writing.
-/*
-TIFF*
-TIFFOpen(const char* name, const char* mode)
-{
- static const char module[] = "TIFFOpen";
- FILE* stream = fopen(name, mode);
- if (stream == NULL)
- {
- TIFFError(module, "%s: Cannot open", name);
- return NULL;
- }
- return (TIFFFdOpen((int)stream, name, mode));
-}
-*/
-
-TIFF*
-_TIFFFdOpen(void* fd, const char* name, const char* mode)
-{
- TIFF* tif;
-
- tif = TIFFClientOpen(name, mode,
- (thandle_t) fd,
- _tiffReadProcEx, _tiffWriteProcEx, _tiffSeekProcEx, _tiffCloseProcEx,
- _tiffSizeProcEx, _tiffMapProcEx, _tiffUnmapProcEx);
- if (tif)
- {
- tif->tif_fd = (int)fd;
- }
- return (tif);
-}
-
-extern "C" TIFF* _TIFFOpenEx(CxFile* stream, const char* mode)
-{
- return (_TIFFFdOpen(stream, "TIFF IMAGE", mode));
-}
-
-#ifdef __GNUC__
-extern char* malloc();
-extern char* realloc();
-#else
-#include <malloc.h>
-#endif
-
-tdata_t
-_TIFFmalloc(tsize_t s)
-{
- return (malloc((size_t) s));
-}
-
-void
-_TIFFfree(tdata_t p)
-{
- free(p);
-}
-
-tdata_t
-_TIFFrealloc(tdata_t p, tsize_t s)
-{
- return (realloc(p, (size_t) s));
-}
-
-void
-_TIFFmemset(tdata_t p, int v, tsize_t c)
-{
- memset(p, v, (size_t) c);
-}
-
-void
-_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
-{
- memcpy(d, s, (size_t) c);
-}
-
-int
-_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
-{
- return (memcmp(p1, p2, (size_t) c));
-}
-
-#ifndef UNICODE
-#define DbgPrint wvsprintf
-#define DbgPrint2 wsprintf
-#define DbgMsgBox MessageBox
-#else
-#define DbgPrint wvsprintfA
-#define DbgPrint2 wsprintfA
-#define DbgMsgBox MessageBoxA
-#endif
-
-static void
-Win32WarningHandler(const char* module, const char* fmt, va_list ap)
-{
-#ifdef _DEBUG
-#if (!defined(_CONSOLE) && !defined(_WIN32_WCE) && defined(WIN32))
- LPSTR szTitle;
- LPSTR szTmp;
- LPCSTR szTitleText = "%s Warning";
- LPCSTR szDefaultModule = "TIFFLIB";
- szTmp = (module == NULL) ? (LPSTR)szDefaultModule : (LPSTR)module;
- if ((szTitle = (LPSTR)LocalAlloc(LMEM_FIXED, (strlen(szTmp) +
- strlen(szTitleText) + strlen(fmt) + 128))) == NULL)
- return;
- DbgPrint2(szTitle, szTitleText, szTmp);
- szTmp = szTitle + (strlen(szTitle)+2);
- DbgPrint(szTmp, fmt, ap);
- DbgMsgBox(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONINFORMATION);
- LocalFree(szTitle);
- return;
-#else
- if (module != NULL)
- fprintf(stderr, "%s: ", module);
- fprintf(stderr, "Warning, ");
- vfprintf(stderr, fmt, ap);
- fprintf(stderr, ".\n");
-#endif
-#endif
-}
-TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler;
-
-static void
-Win32ErrorHandler(const char* module, const char* fmt, va_list ap)
-{
-#ifdef _DEBUG
-#if (!defined(_CONSOLE) && !defined(_WIN32_WCE) && defined(WIN32))
- LPSTR szTitle;
- LPSTR szTmp;
- LPCSTR szTitleText = "%s Error";
- LPCSTR szDefaultModule = "TIFFLIB";
- szTmp = (module == NULL) ? (LPSTR)szDefaultModule : (LPSTR)module;
- if ((szTitle = (LPSTR)LocalAlloc(LMEM_FIXED, (strlen(szTmp) +
- strlen(szTitleText) + strlen(fmt) + 128))) == NULL)
- return;
- DbgPrint2(szTitle, szTitleText, szTmp);
- szTmp = szTitle + (strlen(szTitle)+2);
- DbgPrint(szTmp, fmt, ap);
- DbgMsgBox(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONEXCLAMATION);
- LocalFree(szTitle);
- return;
-#else
- if (module != NULL)
- fprintf(stderr, "%s: ", module);
- vfprintf(stderr, fmt, ap);
- fprintf(stderr, ".\n");
-#endif
-#endif
-}
-TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler;
-
-#endif
-
diff --git a/smelt/sdl/CxImage/xfile.h b/smelt/sdl/CxImage/xfile.h deleted file mode 100644 index 6de281c..0000000 --- a/smelt/sdl/CxImage/xfile.h +++ /dev/null @@ -1,79 +0,0 @@ -/*
- * File: xfile.h
- * Purpose: General Purpose File Class
- */
-/*
- --------------------------------------------------------------------------------
-
- COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
-
- CxFile (c) 11/May/2002 Davide Pizzolato - www.xdp.it
- CxFile version 2.00 23/Aug/2002
- CxFile version 2.10 16/Dec/2007
-
- Special thanks to Chris Shearer Cooper for new features, enhancements and bugfixes
-
- Covered code is provided under this license on an "as is" basis, without warranty
- of any kind, either expressed or implied, including, without limitation, warranties
- that the covered code is free of defects, merchantable, fit for a particular purpose
- or non-infringing. The entire risk as to the quality and performance of the covered
- code is with you. Should any covered code prove defective in any respect, you (not
- the initial developer or any other contributor) assume the cost of any necessary
- servicing, repair or correction. This disclaimer of warranty constitutes an essential
- part of this license. No use of any covered code is authorized hereunder except under
- this disclaimer.
-
- Permission is hereby granted to use, copy, modify, and distribute this
- source code, or portions hereof, for any purpose, including commercial applications,
- freely and without fee, subject to the following restrictions:
-
- 1. The origin of this software must not be misrepresented; you must not
- claim that you wrote the original software. If you use this software
- in a product, an acknowledgment in the product documentation would be
- appreciated but is not required.
-
- 2. Altered source versions must be plainly marked as such, and must not be
- misrepresented as being the original software.
-
- 3. This notice may not be removed or altered from any source distribution.
- --------------------------------------------------------------------------------
- */
-#if !defined(__xfile_h)
-#define __xfile_h
-
-#if defined (WIN32) || defined (_WIN32_WCE)
- #include <windows.h>
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "ximadef.h"
-
-class DLL_EXP CxFile
-{
-public:
- CxFile(void) { };
- virtual ~CxFile() { };
-
- virtual bool Close() = 0;
- virtual size_t Read(void *buffer, size_t size, size_t count) = 0;
- virtual size_t Write(const void *buffer, size_t size, size_t count) = 0;
- virtual bool Seek(int32_t offset, int32_t origin) = 0;
- virtual int32_t Tell() = 0;
- virtual int32_t Size() = 0;
- virtual bool Flush() = 0;
- virtual bool Eof() = 0;
- virtual int32_t Error() = 0;
- virtual bool PutC(uint8_t c)
- {
- // Default implementation
- size_t nWrote = Write(&c, 1, 1);
- return (bool)(nWrote == 1);
- }
- virtual int32_t GetC() = 0;
- virtual char * GetS(char *string, int32_t n) = 0;
- virtual int32_t Scanf(const char *format, void* output) = 0;
-};
-
-#endif //__xfile_h
diff --git a/smelt/sdl/CxImage/ximabmp.cpp b/smelt/sdl/CxImage/ximabmp.cpp deleted file mode 100644 index c173c7d..0000000 --- a/smelt/sdl/CxImage/ximabmp.cpp +++ /dev/null @@ -1,448 +0,0 @@ -/*
- * File: ximabmp.cpp
- * Purpose: Platform Independent BMP Image Class Loader and Writer
- * 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximabmp.h"
-
-#if CXIMAGE_SUPPORT_BMP
-
-#include "ximaiter.h"
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageBMP::Encode(CxFile * hFile)
-{
-
- if (EncodeSafeCheck(hFile)) return false;
-
- BITMAPFILEHEADER hdr;
-
- hdr.bfType = 0x4d42; // 'BM' WINDOWS_BITMAP_SIGNATURE
- hdr.bfSize = GetSize() + 14 /*sizeof(BITMAPFILEHEADER)*/;
- hdr.bfReserved1 = hdr.bfReserved2 = 0;
- hdr.bfOffBits = 14 /*sizeof(BITMAPFILEHEADER)*/ + head.biSize + GetPaletteSize();
-
- hdr.bfType = m_ntohs(hdr.bfType);
- hdr.bfSize = m_ntohl(hdr.bfSize);
- hdr.bfOffBits = m_ntohl(hdr.bfOffBits);
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (GetNumColors()==0 && AlphaIsValid()){
-
- BITMAPINFOHEADER infohdr;
- memcpy(&infohdr,&head,sizeof(BITMAPINFOHEADER));
- infohdr.biCompression = BI_RGB;
- infohdr.biBitCount = 32;
- uint32_t dwEffWidth = ((((infohdr.biBitCount * infohdr.biWidth) + 31) / 32) * 4);
- infohdr.biSizeImage = dwEffWidth * infohdr.biHeight;
-
- hdr.bfSize = infohdr.biSize + infohdr.biSizeImage + 14 /*sizeof(BITMAPFILEHEADER)*/;
-
- hdr.bfSize = m_ntohl(hdr.bfSize);
- bihtoh(&infohdr);
-
- // Write the file header
- hFile->Write(&hdr,min(14,sizeof(BITMAPFILEHEADER)),1);
- hFile->Write(&infohdr,sizeof(BITMAPINFOHEADER),1);
- //and DIB+ALPHA interlaced
- uint8_t *srcalpha = AlphaGetPointer();
- for(int32_t y = 0; y < infohdr.biHeight; ++y){
- uint8_t *srcdib = GetBits(y);
- for(int32_t x = 0; x < infohdr.biWidth; ++x){
- hFile->Write(srcdib,3,1);
- hFile->Write(srcalpha,1,1);
- srcdib += 3;
- ++srcalpha;
- }
- }
-
- } else
-#endif //CXIMAGE_SUPPORT_ALPHA
- {
- // Write the file header
- hFile->Write(&hdr,min(14,sizeof(BITMAPFILEHEADER)),1);
- //copy attributes
- memcpy(pDib,&head,sizeof(BITMAPINFOHEADER));
- bihtoh((BITMAPINFOHEADER*)pDib);
- // Write the DIB header and the pixels
- hFile->Write(pDib,GetSize(),1);
- bihtoh((BITMAPINFOHEADER*)pDib);
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageBMP::Decode(CxFile * hFile)
-{
- if (hFile == NULL) return false;
-
- BITMAPFILEHEADER bf;
- uint32_t off = hFile->Tell(); //<CSC>
- cx_try {
- if (hFile->Read(&bf,min(14,sizeof(bf)),1)==0) cx_throw("Not a BMP");
-
- bf.bfSize = m_ntohl(bf.bfSize);
- bf.bfOffBits = m_ntohl(bf.bfOffBits);
-
- if (m_ntohs(bf.bfType) != BFT_BITMAP) { //do we have a RC HEADER?
- bf.bfOffBits = 0L;
- hFile->Seek(off,SEEK_SET);
- }
-
- BITMAPINFOHEADER bmpHeader;
- if (!DibReadBitmapInfo(hFile,&bmpHeader)); cx_throw("Error reading BMP info");
- uint32_t dwCompression=bmpHeader.biCompression;
- uint32_t dwBitCount=bmpHeader.biBitCount; //preserve for BI_BITFIELDS compression <Thomas Ernst>
- bool bIsOldBmp = bmpHeader.biSize == sizeof(BITMAPCOREHEADER);
-
- bool bTopDownDib = bmpHeader.biHeight<0; //<Flanders> check if it's a top-down bitmap
- if (bTopDownDib) bmpHeader.biHeight=-bmpHeader.biHeight;
-
- if (info.nEscape == -1) {
- // Return output dimensions only
- head.biWidth = bmpHeader.biWidth;
- head.biHeight = bmpHeader.biHeight;
- info.dwType = CXIMAGE_FORMAT_BMP;
- cx_throw("output dimensions returned");
- }
-
- if (!Create(bmpHeader.biWidth,bmpHeader.biHeight,bmpHeader.biBitCount,CXIMAGE_FORMAT_BMP))
- cx_throw("");
-
- SetXDPI((int32_t) floor(bmpHeader.biXPelsPerMeter * 254.0 / 10000.0 + 0.5));
- SetYDPI((int32_t) floor(bmpHeader.biYPelsPerMeter * 254.0 / 10000.0 + 0.5));
-
- if (info.nEscape) cx_throw("Cancelled"); // <vho> - cancel decoding
-
- RGBQUAD *pRgb = GetPalette();
- if (pRgb){
- if (bIsOldBmp){
- // convert a old color table (3 byte entries) to a new
- // color table (4 byte entries)
- hFile->Read((void*)pRgb,DibNumColors(&bmpHeader) * sizeof(RGBTRIPLE),1);
- for (int32_t i=DibNumColors(&head)-1; i>=0; i--){
- pRgb[i].rgbRed = ((RGBTRIPLE *)pRgb)[i].rgbtRed;
- pRgb[i].rgbBlue = ((RGBTRIPLE *)pRgb)[i].rgbtBlue;
- pRgb[i].rgbGreen = ((RGBTRIPLE *)pRgb)[i].rgbtGreen;
- pRgb[i].rgbReserved = (uint8_t)0;
- }
- } else {
- hFile->Read((void*)pRgb,DibNumColors(&bmpHeader) * sizeof(RGBQUAD),1);
- //force rgbReserved=0, to avoid problems with some WinXp bitmaps
- for (uint32_t i=0; i<head.biClrUsed; i++) pRgb[i].rgbReserved=0;
- }
- }
-
- if (info.nEscape) cx_throw("Cancelled"); // <vho> - cancel decoding
-
- switch (dwBitCount) {
- case 32 :
- uint32_t bfmask[3];
- if (dwCompression == BI_BITFIELDS)
- {
- hFile->Read(bfmask, 12, 1);
- } else {
- bfmask[0]=0x00FF0000;
- bfmask[1]=0x0000FF00;
- bfmask[2]=0x000000FF;
- }
- if (bf.bfOffBits != 0L) hFile->Seek(off + bf.bfOffBits,SEEK_SET);
- if (dwCompression == BI_BITFIELDS || dwCompression == BI_RGB){
- int32_t imagesize=4*head.biHeight*head.biWidth;
- uint8_t* buff32=(uint8_t*)malloc(imagesize);
- if (buff32){
- hFile->Read(buff32, imagesize,1); // read in the pixels
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (dwCompression == BI_RGB){
- AlphaCreate();
- if (AlphaIsValid()){
- bool bAlphaOk = false;
- uint8_t* p;
- for (int32_t y=0; y<head.biHeight; y++){
- p = buff32 + 3 + head.biWidth * 4 * y;
- for (int32_t x=0; x<head.biWidth; x++){
- if (*p) bAlphaOk = true;
- AlphaSet(x,y,*p);
- p+=4;
- }
- }
- // fix if alpha pixels are all zero
- if (!bAlphaOk) AlphaInvert();
- }
- }
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- Bitfield2RGB(buff32,bfmask[0],bfmask[1],bfmask[2],32);
- free(buff32);
- } else cx_throw("can't allocate memory");
- } else cx_throw("unknown compression");
- break;
- case 24 :
- if (bf.bfOffBits != 0L) hFile->Seek(off + bf.bfOffBits,SEEK_SET);
- if (dwCompression == BI_RGB){
- hFile->Read(info.pImage, head.biSizeImage,1); // read in the pixels
- } else cx_throw("unknown compression");
- break;
- case 16 :
- {
- uint32_t bfmask[3];
- if (dwCompression == BI_BITFIELDS)
- {
- hFile->Read(bfmask, 12, 1);
- } else {
- bfmask[0]=0x7C00; bfmask[1]=0x3E0; bfmask[2]=0x1F; //RGB555
- }
- // bf.bfOffBits required after the bitfield mask <Cui Ying Jie>
- if (bf.bfOffBits != 0L) hFile->Seek(off + bf.bfOffBits,SEEK_SET);
- // read in the pixels
- hFile->Read(info.pImage, head.biHeight*((head.biWidth+1)/2)*4,1);
- // transform into RGB
- Bitfield2RGB(info.pImage,bfmask[0],bfmask[1],bfmask[2],16);
- break;
- }
- case 8 :
- case 4 :
- case 1 :
- if (bf.bfOffBits != 0L) hFile->Seek(off + bf.bfOffBits,SEEK_SET);
- switch (dwCompression) {
- case BI_RGB :
- hFile->Read(info.pImage, head.biSizeImage,1); // read in the pixels
- break;
- case BI_RLE4 :
- {
- uint8_t status_byte = 0;
- uint8_t second_byte = 0;
- int32_t scanline = 0;
- int32_t bits = 0;
- BOOL low_nibble = FALSE;
- CImageIterator iter(this);
-
- for (BOOL bContinue = TRUE; bContinue && hFile->Read(&status_byte, sizeof(uint8_t), 1);) {
-
- switch (status_byte) {
- case RLE_COMMAND :
- hFile->Read(&status_byte, sizeof(uint8_t), 1);
- switch (status_byte) {
- case RLE_ENDOFLINE :
- bits = 0;
- scanline++;
- low_nibble = FALSE;
- break;
- case RLE_ENDOFBITMAP :
- bContinue=FALSE;
- break;
- case RLE_DELTA :
- {
- // read the delta values
- uint8_t delta_x;
- uint8_t delta_y;
- hFile->Read(&delta_x, sizeof(uint8_t), 1);
- hFile->Read(&delta_y, sizeof(uint8_t), 1);
- // apply them
- bits += delta_x / 2;
- scanline += delta_y;
- break;
- }
- default :
- hFile->Read(&second_byte, sizeof(uint8_t), 1);
- uint8_t *sline = iter.GetRow(scanline);
- for (int32_t i = 0; i < status_byte; i++) {
- if ((uint8_t*)(sline+bits) < (uint8_t*)(info.pImage+head.biSizeImage)){
- if (low_nibble) {
- if (i&1)
- *(sline + bits) |= (second_byte & 0x0f);
- else
- *(sline + bits) |= (second_byte & 0xf0)>>4;
- bits++;
- } else {
- if (i&1)
- *(sline + bits) = (uint8_t)(second_byte & 0x0f)<<4;
- else
- *(sline + bits) = (uint8_t)(second_byte & 0xf0);
- }
- }
-
- if ((i & 1) && (i != (status_byte - 1)))
- hFile->Read(&second_byte, sizeof(uint8_t), 1);
-
- low_nibble = !low_nibble;
- }
- if ((((status_byte+1) >> 1) & 1 ) == 1)
- hFile->Read(&second_byte, sizeof(uint8_t), 1);
- break;
- };
- break;
- default :
- {
- uint8_t *sline = iter.GetRow(scanline);
- hFile->Read(&second_byte, sizeof(uint8_t), 1);
- for (unsigned i = 0; i < status_byte; i++) {
- if ((uint8_t*)(sline+bits) < (uint8_t*)(info.pImage+head.biSizeImage)){
- if (low_nibble) {
- if (i&1)
- *(sline + bits) |= (second_byte & 0x0f);
- else
- *(sline + bits) |= (second_byte & 0xf0)>>4;
- bits++;
- } else {
- if (i&1)
- *(sline + bits) = (uint8_t)(second_byte & 0x0f)<<4;
- else
- *(sline + bits) = (uint8_t)(second_byte & 0xf0);
- }
- }
- low_nibble = !low_nibble;
- }
- }
- break;
- };
- }
- break;
- }
- case BI_RLE8 :
- {
- uint8_t status_byte = 0;
- uint8_t second_byte = 0;
- int32_t scanline = 0;
- int32_t bits = 0;
- CImageIterator iter(this);
-
- for (BOOL bContinue = TRUE; bContinue && hFile->Read(&status_byte, sizeof(uint8_t), 1);) {
- switch (status_byte) {
- case RLE_COMMAND :
- hFile->Read(&status_byte, sizeof(uint8_t), 1);
- switch (status_byte) {
- case RLE_ENDOFLINE :
- bits = 0;
- scanline++;
- break;
- case RLE_ENDOFBITMAP :
- bContinue=FALSE;
- break;
- case RLE_DELTA :
- {
- // read the delta values
- uint8_t delta_x;
- uint8_t delta_y;
- hFile->Read(&delta_x, sizeof(uint8_t), 1);
- hFile->Read(&delta_y, sizeof(uint8_t), 1);
- // apply them
- bits += delta_x;
- scanline += delta_y;
- break;
- }
- default :
- hFile->Read((void *)(iter.GetRow(scanline) + bits), sizeof(uint8_t) * status_byte, 1);
- // align run length to even number of bytes
- if ((status_byte & 1) == 1)
- hFile->Read(&second_byte, sizeof(uint8_t), 1);
- bits += status_byte;
- break;
- };
- break;
- default :
- uint8_t *sline = iter.GetRow(scanline);
- hFile->Read(&second_byte, sizeof(uint8_t), 1);
- for (unsigned i = 0; i < status_byte; i++) {
- if ((uint8_t*)(sline+bits) < (uint8_t*)(info.pImage+head.biSizeImage)){
- *(sline + bits) = second_byte;
- bits++;
- } else {
- break;
- }
- }
- break;
- };
- }
- break;
- }
- default :
- cx_throw("compression type not supported");
- }
- }
-
- if (bTopDownDib) Flip(); //<Flanders>
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- if (info.nEscape == -1 && info.dwType == CXIMAGE_FORMAT_BMP) return true;
- return false;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/* ReadDibBitmapInfo()
- *
- * Will read a file in DIB format and return a global HANDLE to its
- * BITMAPINFO. This function will work with both "old" and "new"
- * bitmap formats, but will always return a "new" BITMAPINFO.
- */
-bool CxImageBMP::DibReadBitmapInfo(CxFile* fh, BITMAPINFOHEADER *pdib)
-{
- if ((fh==NULL)||(pdib==NULL)) return false;
-
- if (fh->Read(pdib,sizeof(BITMAPINFOHEADER),1)==0) return false;
-
- bihtoh(pdib);
-
- switch (pdib->biSize) // what type of bitmap info is this?
- {
- case sizeof(BITMAPINFOHEADER):
- break;
-
- case 64: //sizeof(OS2_BMP_HEADER):
- fh->Seek((int32_t)(64 - sizeof(BITMAPINFOHEADER)),SEEK_CUR);
- break;
-
- case 124: //sizeof(BITMAPV5HEADER):
- fh->Seek((long)(124-sizeof(BITMAPINFOHEADER)), SEEK_CUR);
- break;
-
- case sizeof(BITMAPCOREHEADER):
- {
- BITMAPCOREHEADER bc = *(BITMAPCOREHEADER*)pdib;
- pdib->biSize = bc.bcSize;
- pdib->biWidth = (uint32_t)bc.bcWidth;
- pdib->biHeight = (uint32_t)bc.bcHeight;
- pdib->biPlanes = bc.bcPlanes;
- pdib->biBitCount = bc.bcBitCount;
- pdib->biCompression = BI_RGB;
- pdib->biSizeImage = 0;
- pdib->biXPelsPerMeter = 0;
- pdib->biYPelsPerMeter = 0;
- pdib->biClrUsed = 0;
- pdib->biClrImportant = 0;
-
- fh->Seek((int32_t)(sizeof(BITMAPCOREHEADER)-sizeof(BITMAPINFOHEADER)), SEEK_CUR);
- }
- break;
- default:
- //give a last chance
- if (pdib->biSize>(sizeof(BITMAPINFOHEADER))&&
- (pdib->biSizeImage>=(uint32_t)(pdib->biHeight*((((pdib->biBitCount*pdib->biWidth)+31)/32)*4)))&&
- (pdib->biPlanes==1)&&(pdib->biClrUsed==0))
- {
- if (pdib->biCompression==BI_RGB)
- fh->Seek((int32_t)(pdib->biSize - sizeof(BITMAPINFOHEADER)),SEEK_CUR);
- break;
- }
- return false;
- }
-
- FixBitmapInfo(pdib);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_BMP
-////////////////////////////////////////////////////////////////////////////////
diff --git a/smelt/sdl/CxImage/ximabmp.h b/smelt/sdl/CxImage/ximabmp.h deleted file mode 100644 index c828de5..0000000 --- a/smelt/sdl/CxImage/ximabmp.h +++ /dev/null @@ -1,79 +0,0 @@ -/*
- * File: ximabmp.h
- * Purpose: BMP Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImageBMP (c) 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- *
- * Special thanks to Troels Knakkergaard for new features, enhancements and bugfixes
- *
- * original CImageBMP and CImageIterator implementation are:
- * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra(at)servidor(dot)unam(dot)mx>
- *
- * ==========================================================
- */
-
-#if !defined(__ximaBMP_h)
-#define __ximaBMP_h
-
-#include "ximage.h"
-
-const int32_t RLE_COMMAND = 0;
-const int32_t RLE_ENDOFLINE = 0;
-const int32_t RLE_ENDOFBITMAP = 1;
-const int32_t RLE_DELTA = 2;
-
-#if !defined(BI_RLE8)
- #define BI_RLE8 1L
-#endif
-#if !defined(BI_RLE4)
- #define BI_RLE4 2L
-#endif
-
-#if CXIMAGE_SUPPORT_BMP
-
-class CxImageBMP: public CxImage
-{
-public:
- CxImageBMP(): CxImage(CXIMAGE_FORMAT_BMP) {};
-
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-
-protected:
- bool DibReadBitmapInfo(CxFile* fh, BITMAPINFOHEADER *pdib);
-};
-
-#define BFT_ICON 0x4349 /* 'IC' */
-#define BFT_BITMAP 0x4d42 /* 'BM' */
-#define BFT_CURSOR 0x5450 /* 'PT' */
-
-#ifndef WIDTHBYTES
-#define WIDTHBYTES(i) ((unsigned)((i+31)&(~31))/8) /* ULONG aligned ! */
-#endif
-
-#endif
-
-#define DibWidthBytesN(lpbi, n) (uint32_t)WIDTHBYTES((uint32_t)(lpbi)->biWidth * (uint32_t)(n))
-#define DibWidthBytes(lpbi) DibWidthBytesN(lpbi, (lpbi)->biBitCount)
-
-#define DibSizeImage(lpbi) ((lpbi)->biSizeImage == 0 \
- ? ((uint32_t)(uint32_t)DibWidthBytes(lpbi) * (uint32_t)(uint32_t)(lpbi)->biHeight) \
- : (lpbi)->biSizeImage)
-
-#define DibNumColors(lpbi) ((lpbi)->biClrUsed == 0 && (lpbi)->biBitCount <= 8 \
- ? (int32_t)(1 << (int32_t)(lpbi)->biBitCount) \
- : (int32_t)(lpbi)->biClrUsed)
-
-#define FixBitmapInfo(lpbi) if ((lpbi)->biSizeImage == 0) \
- (lpbi)->biSizeImage = DibSizeImage(lpbi); \
- if ((lpbi)->biClrUsed == 0) \
- (lpbi)->biClrUsed = DibNumColors(lpbi); \
-
-#endif
diff --git a/smelt/sdl/CxImage/ximacfg.h b/smelt/sdl/CxImage/ximacfg.h deleted file mode 100644 index 875f517..0000000 --- a/smelt/sdl/CxImage/ximacfg.h +++ /dev/null @@ -1,59 +0,0 @@ -#if !defined(__ximaCFG_h)
-#define __ximaCFG_h
-
-/////////////////////////////////////////////////////////////////////////////
-// CxImage supported features
-#define CXIMAGE_SUPPORT_ALPHA 1
-#define CXIMAGE_SUPPORT_SELECTION 0
-#define CXIMAGE_SUPPORT_TRANSFORMATION 1
-#define CXIMAGE_SUPPORT_DSP 0
-#define CXIMAGE_SUPPORT_LAYERS 0
-#define CXIMAGE_SUPPORT_INTERPOLATION 1
-
-#define CXIMAGE_SUPPORT_DECODE 1
-#define CXIMAGE_SUPPORT_ENCODE 0 //<vho><T.Peck>
-#define CXIMAGE_SUPPORT_WINDOWS 0
-#define CXIMAGE_SUPPORT_EXIF 0
-
-/////////////////////////////////////////////////////////////////////////////
-// CxImage supported formats
-#define CXIMAGE_SUPPORT_BMP 1
-#define CXIMAGE_SUPPORT_GIF 1
-#define CXIMAGE_SUPPORT_JPG 1
-#define CXIMAGE_SUPPORT_PNG 1
-#define CXIMAGE_SUPPORT_ICO 0
-#define CXIMAGE_SUPPORT_TIF 0
-#define CXIMAGE_SUPPORT_TGA 0
-#define CXIMAGE_SUPPORT_PCX 1
-#define CXIMAGE_SUPPORT_WBMP 0
-#define CXIMAGE_SUPPORT_WMF 0
-
-#define CXIMAGE_SUPPORT_JP2 0
-#define CXIMAGE_SUPPORT_JPC 0
-#define CXIMAGE_SUPPORT_PGX 0
-#define CXIMAGE_SUPPORT_PNM 0
-#define CXIMAGE_SUPPORT_RAS 0
-
-#define CXIMAGE_SUPPORT_JBG 0 // GPL'd see ../jbig/copying.txt & ../jbig/patents.htm
-
-#define CXIMAGE_SUPPORT_MNG 0
-#define CXIMAGE_SUPPORT_SKA 0
-#define CXIMAGE_SUPPORT_RAW 0
-#define CXIMAGE_SUPPORT_PSD 0
-
-/////////////////////////////////////////////////////////////////////////////
-#define CXIMAGE_MAX_MEMORY 268435456
-
-#define CXIMAGE_DEFAULT_DPI 96
-
-#define CXIMAGE_ERR_NOFILE "null file handler"
-#define CXIMAGE_ERR_NOIMAGE "null image!!!"
-
-//#define CXIMAGE_SUPPORT_EXCEPTION_HANDLING 1
-//!!Uncomment the last line when releasing
-/////////////////////////////////////////////////////////////////////////////
-//color to grey mapping <H. Muelner> <jurgene>
-//#define RGB2GRAY(r,g,b) (((b)*114 + (g)*587 + (r)*299)/1000)
-#define RGB2GRAY(r,g,b) (((b)*117 + (g)*601 + (r)*306) >> 10)
-
-#endif
diff --git a/smelt/sdl/CxImage/ximadef.h b/smelt/sdl/CxImage/ximadef.h deleted file mode 100644 index 372ec13..0000000 --- a/smelt/sdl/CxImage/ximadef.h +++ /dev/null @@ -1,205 +0,0 @@ -#if !defined(__ximadefs_h)
-#define __ximadefs_h
-
-#include "ximacfg.h"
-
-#if /*defined(_AFXDLL)||*/defined(_USRDLL)
- #define DLL_EXP __declspec(dllexport)
-#elif defined(_MSC_VER)&&(_MSC_VER<1200)
- #define DLL_EXP __declspec(dllimport)
-#else
- #define DLL_EXP
-#endif
-
-
-#if CXIMAGE_SUPPORT_EXCEPTION_HANDLING
- #define cx_try try
- #define cx_throw(message) throw(message)
- #define cx_catch catch (const char *message)
-#else
- #define cx_try bool cx_error=false;
- #define cx_throw(message) {cx_error=true; if(strcmp(message,"")) strncpy(info.szLastError,message,255); goto cx_error_catch;}
- #define cx_catch cx_error_catch: char message[]=""; if(cx_error)
-#endif
-
-
-#if CXIMAGE_SUPPORT_JP2 || CXIMAGE_SUPPORT_JPC || CXIMAGE_SUPPORT_PGX || CXIMAGE_SUPPORT_PNM || CXIMAGE_SUPPORT_RAS
- #define CXIMAGE_SUPPORT_JASPER 1
-#else
- #define CXIMAGE_SUPPORT_JASPER 0
-#endif
-
-#if CXIMAGE_SUPPORT_DSP
-#undef CXIMAGE_SUPPORT_TRANSFORMATION
- #define CXIMAGE_SUPPORT_TRANSFORMATION 1
-#endif
-
-#if CXIMAGE_SUPPORT_TRANSFORMATION || CXIMAGE_SUPPORT_TIF || CXIMAGE_SUPPORT_TGA || CXIMAGE_SUPPORT_BMP || CXIMAGE_SUPPORT_WINDOWS
- #define CXIMAGE_SUPPORT_BASICTRANSFORMATIONS 1
-#endif
-
-#if CXIMAGE_SUPPORT_DSP || CXIMAGE_SUPPORT_TRANSFORMATION
-#undef CXIMAGE_SUPPORT_INTERPOLATION
- #define CXIMAGE_SUPPORT_INTERPOLATION 1
-#endif
-
-#if defined (_WIN32_WCE)
- #undef CXIMAGE_SUPPORT_WMF
- #define CXIMAGE_SUPPORT_WMF 0
-#endif
-
-#if !defined(WIN32) && !defined(_WIN32_WCE)
- #undef CXIMAGE_SUPPORT_WINDOWS
- #define CXIMAGE_SUPPORT_WINDOWS 0
-#endif
-
-#ifndef min
-#define min(a,b) (((a)<(b))?(a):(b))
-#endif
-#ifndef max
-#define max(a,b) (((a)>(b))?(a):(b))
-#endif
-
-#ifndef PI
- #define PI 3.141592653589793f
-#endif
-
-
-#if defined(WIN32) || defined(_WIN32_WCE)
-#include <windows.h>
-#include <tchar.h>
-#endif
-
-#include <stdio.h>
-#include <math.h>
-
-#ifdef __BORLANDC__
-
-#ifndef _COMPLEX_DEFINED
-
-typedef struct tagcomplex {
- double x,y;
-} _complex;
-
-#endif
-
-#define _cabs(c) sqrt(c.x*c.x+c.y*c.y)
-
-#endif
-
-#if defined(WIN32) || defined(_WIN32_WCE)
- #include "stdint.h"
-#endif
-
-#if !defined(WIN32) && !defined(_WIN32_WCE)
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-
-typedef uint32_t COLORREF;
-typedef void* HANDLE;
-typedef void* HRGN;
-
-#ifndef BOOL
-#define BOOL bool
-#endif
-
-#ifndef TRUE
-#define TRUE true
-#endif
-
-#ifndef FALSE
-#define FALSE false
-#endif
-
-#ifndef TCHAR
-#define TCHAR char
-#define _T
-#endif
-
-typedef struct tagRECT
-{
- int32_t left;
- int32_t top;
- int32_t right;
- int32_t bottom;
-} RECT;
-
-typedef struct tagPOINT
-{
- int32_t x;
- int32_t y;
-} POINT;
-
-typedef struct tagRGBQUAD {
- uint8_t rgbBlue;
- uint8_t rgbGreen;
- uint8_t rgbRed;
- uint8_t rgbReserved;
-} RGBQUAD;
-
-#pragma pack(1)
-
-typedef struct tagBITMAPINFOHEADER{
- uint32_t biSize;
- int32_t biWidth;
- int32_t biHeight;
- uint16_t biPlanes;
- uint16_t biBitCount;
- uint32_t biCompression;
- uint32_t biSizeImage;
- int32_t biXPelsPerMeter;
- int32_t biYPelsPerMeter;
- uint32_t biClrUsed;
- uint32_t biClrImportant;
-} BITMAPINFOHEADER;
-
-typedef struct tagBITMAPFILEHEADER {
- uint16_t bfType;
- uint32_t bfSize;
- uint16_t bfReserved1;
- uint16_t bfReserved2;
- uint32_t bfOffBits;
-} BITMAPFILEHEADER;
-
-typedef struct tagBITMAPCOREHEADER {
- uint32_t bcSize;
- uint16_t bcWidth;
- uint16_t bcHeight;
- uint16_t bcPlanes;
- uint16_t bcBitCount;
-} BITMAPCOREHEADER;
-
-typedef struct tagRGBTRIPLE {
- uint8_t rgbtBlue;
- uint8_t rgbtGreen;
- uint8_t rgbtRed;
-} RGBTRIPLE;
-
-#pragma pack()
-
-#define BI_RGB 0L
-#define BI_RLE8 1L
-#define BI_RLE4 2L
-#define BI_BITFIELDS 3L
-
-#define GetRValue(rgb) ((uint8_t)(rgb))
-#define GetGValue(rgb) ((uint8_t)(((uint16_t)(rgb)) >> 8))
-#define GetBValue(rgb) ((uint8_t)((rgb)>>16))
-#define RGB(r,g,b) ((COLORREF)(((uint8_t)(r)|((uint16_t)((uint8_t)(g))<<8))|(((uint32_t)(uint8_t)(b))<<16)))
-
-#ifndef _COMPLEX_DEFINED
-
-typedef struct tagcomplex {
- double x,y;
-} _complex;
-
-#endif
-
-#define _cabs(c) sqrt(c.x*c.x+c.y*c.y)
-
-#endif
-
-#endif //__ximadefs
diff --git a/smelt/sdl/CxImage/ximadsp.cpp b/smelt/sdl/CxImage/ximadsp.cpp deleted file mode 100644 index df73136..0000000 --- a/smelt/sdl/CxImage/ximadsp.cpp +++ /dev/null @@ -1,3771 +0,0 @@ -// xImaDsp.cpp : DSP functions
-/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximage.h"
-
-#include "ximaiter.h"
-
-#if CXIMAGE_SUPPORT_DSP
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Converts the image to B&W.
- * The OptimalThreshold() function can be used for calculating the optimal threshold.
- * \param level: the lightness threshold.
- * \return true if everything is ok
- */
-bool CxImage::Threshold(uint8_t level)
-{
- if (!pDib) return false;
- if (head.biBitCount == 1) return true;
-
- GrayScale();
-
- CxImage tmp(head.biWidth,head.biHeight,1);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- for (int32_t y=0;y<head.biHeight;y++){
- info.nProgress = (int32_t)(100*y/head.biHeight);
- if (info.nEscape) break;
- for (int32_t x=0;x<head.biWidth;x++){
- if (BlindGetPixelIndex(x,y)>level)
- tmp.BlindSetPixelIndex(x,y,1);
- else
- tmp.BlindSetPixelIndex(x,y,0);
- }
- }
- tmp.SetPaletteColor(0,0,0,0);
- tmp.SetPaletteColor(1,255,255,255);
- Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Converts the image to B&W, using a threshold mask
- * \param pThresholdMask: the lightness threshold mask.
- * the pThresholdMask image must be grayscale with same with and height of the current image
- * \return true if everything is ok
- */
-bool CxImage::Threshold(CxImage* pThresholdMask)
-{
- if (!pDib) return false;
- if (head.biBitCount == 1) return true;
-
- if (!pThresholdMask) return false;
-
- if (!pThresholdMask->IsValid() ||
- !pThresholdMask->IsGrayScale() ||
- pThresholdMask->GetWidth() != GetWidth() ||
- pThresholdMask->GetHeight() != GetHeight()){
- strcpy(info.szLastError,"invalid ThresholdMask");
- return false;
- }
-
- GrayScale();
-
- CxImage tmp(head.biWidth,head.biHeight,1);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- for (int32_t y=0;y<head.biHeight;y++){
- info.nProgress = (int32_t)(100*y/head.biHeight);
- if (info.nEscape) break;
- for (int32_t x=0;x<head.biWidth;x++){
- if (BlindGetPixelIndex(x,y)>pThresholdMask->BlindGetPixelIndex(x,y))
- tmp.BlindSetPixelIndex(x,y,1);
- else
- tmp.BlindSetPixelIndex(x,y,0);
- }
- }
- tmp.SetPaletteColor(0,0,0,0);
- tmp.SetPaletteColor(1,255,255,255);
- Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Filters only the pixels with a lightness less (or more) than the threshold level,
- * and preserves the colors for the unfiltered pixels.
- * \param level = the lightness threshold.
- * \param bDirection = false: filter dark pixels, true: filter light pixels
- * \param nBkgndColor = filtered pixels are set to nBkgndColor color
- * \param bSetAlpha = if true, sets also the alpha component for the filtered pixels, with nBkgndColor.rgbReserved
- * \return true if everything is ok
- * \author [DP], [wangsongtao]
- */
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::Threshold2(uint8_t level, bool bDirection, RGBQUAD nBkgndColor, bool bSetAlpha)
-{
- if (!pDib) return false;
- if (head.biBitCount == 1) return true;
-
- CxImage tmp(*this, true, false, false);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- tmp.GrayScale();
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*y/head.biHeight);
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- uint8_t i = tmp.BlindGetPixelIndex(x,y);
- if (!bDirection && i<level) BlindSetPixelColor(x,y,nBkgndColor,bSetAlpha);
- if (bDirection && i>=level) BlindSetPixelColor(x,y,nBkgndColor,bSetAlpha);
- }
- }
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Extract RGB channels from the image. Each channel is an 8 bit grayscale image.
- * \param r,g,b: pointers to CxImage objects, to store the splited channels
- * \return true if everything is ok
- */
-bool CxImage::SplitRGB(CxImage* r,CxImage* g,CxImage* b)
-{
- if (!pDib) return false;
- if (r==NULL && g==NULL && b==NULL) return false;
-
- CxImage tmpr(head.biWidth,head.biHeight,8);
- CxImage tmpg(head.biWidth,head.biHeight,8);
- CxImage tmpb(head.biWidth,head.biHeight,8);
-
- RGBQUAD color;
- for(int32_t y=0; y<head.biHeight; y++){
- for(int32_t x=0; x<head.biWidth; x++){
- color = BlindGetPixelColor(x,y);
- if (r) tmpr.BlindSetPixelIndex(x,y,color.rgbRed);
- if (g) tmpg.BlindSetPixelIndex(x,y,color.rgbGreen);
- if (b) tmpb.BlindSetPixelIndex(x,y,color.rgbBlue);
- }
- }
-
- if (r) tmpr.SetGrayPalette();
- if (g) tmpg.SetGrayPalette();
- if (b) tmpb.SetGrayPalette();
-
- /*for(int32_t j=0; j<256; j++){
- uint8_t i=(uint8_t)j;
- if (r) tmpr.SetPaletteColor(i,i,0,0);
- if (g) tmpg.SetPaletteColor(i,0,i,0);
- if (b) tmpb.SetPaletteColor(i,0,0,i);
- }*/
-
- if (r) r->Transfer(tmpr);
- if (g) g->Transfer(tmpg);
- if (b) b->Transfer(tmpb);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Extract CMYK channels from the image. Each channel is an 8 bit grayscale image.
- * \param c,m,y,k: pointers to CxImage objects, to store the splited channels
- * \return true if everything is ok
- */
-bool CxImage::SplitCMYK(CxImage* c,CxImage* m,CxImage* y,CxImage* k)
-{
- if (!pDib) return false;
- if (c==NULL && m==NULL && y==NULL && k==NULL) return false;
-
- CxImage tmpc(head.biWidth,head.biHeight,8);
- CxImage tmpm(head.biWidth,head.biHeight,8);
- CxImage tmpy(head.biWidth,head.biHeight,8);
- CxImage tmpk(head.biWidth,head.biHeight,8);
-
- RGBQUAD color;
- for(int32_t yy=0; yy<head.biHeight; yy++){
- for(int32_t xx=0; xx<head.biWidth; xx++){
- color = BlindGetPixelColor(xx,yy);
- if (c) tmpc.BlindSetPixelIndex(xx,yy,(uint8_t)(255-color.rgbRed));
- if (m) tmpm.BlindSetPixelIndex(xx,yy,(uint8_t)(255-color.rgbGreen));
- if (y) tmpy.BlindSetPixelIndex(xx,yy,(uint8_t)(255-color.rgbBlue));
- if (k) tmpk.BlindSetPixelIndex(xx,yy,(uint8_t)RGB2GRAY(color.rgbRed,color.rgbGreen,color.rgbBlue));
- }
- }
-
- if (c) tmpc.SetGrayPalette();
- if (m) tmpm.SetGrayPalette();
- if (y) tmpy.SetGrayPalette();
- if (k) tmpk.SetGrayPalette();
-
- if (c) c->Transfer(tmpc);
- if (m) m->Transfer(tmpm);
- if (y) y->Transfer(tmpy);
- if (k) k->Transfer(tmpk);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Extract YUV channels from the image. Each channel is an 8 bit grayscale image.
- * \param y,u,v: pointers to CxImage objects, to store the splited channels
- * \return true if everything is ok
- */
-bool CxImage::SplitYUV(CxImage* y,CxImage* u,CxImage* v)
-{
- if (!pDib) return false;
- if (y==NULL && u==NULL && v==NULL) return false;
-
- CxImage tmpy(head.biWidth,head.biHeight,8);
- CxImage tmpu(head.biWidth,head.biHeight,8);
- CxImage tmpv(head.biWidth,head.biHeight,8);
-
- RGBQUAD color;
- for(int32_t yy=0; yy<head.biHeight; yy++){
- for(int32_t x=0; x<head.biWidth; x++){
- color = RGBtoYUV(BlindGetPixelColor(x,yy));
- if (y) tmpy.BlindSetPixelIndex(x,yy,color.rgbRed);
- if (u) tmpu.BlindSetPixelIndex(x,yy,color.rgbGreen);
- if (v) tmpv.BlindSetPixelIndex(x,yy,color.rgbBlue);
- }
- }
-
- if (y) tmpy.SetGrayPalette();
- if (u) tmpu.SetGrayPalette();
- if (v) tmpv.SetGrayPalette();
-
- if (y) y->Transfer(tmpy);
- if (u) u->Transfer(tmpu);
- if (v) v->Transfer(tmpv);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Extract YIQ channels from the image. Each channel is an 8 bit grayscale image.
- * \param y,i,q: pointers to CxImage objects, to store the splited channels
- * \return true if everything is ok
- */
-bool CxImage::SplitYIQ(CxImage* y,CxImage* i,CxImage* q)
-{
- if (!pDib) return false;
- if (y==NULL && i==NULL && q==NULL) return false;
-
- CxImage tmpy(head.biWidth,head.biHeight,8);
- CxImage tmpi(head.biWidth,head.biHeight,8);
- CxImage tmpq(head.biWidth,head.biHeight,8);
-
- RGBQUAD color;
- for(int32_t yy=0; yy<head.biHeight; yy++){
- for(int32_t x=0; x<head.biWidth; x++){
- color = RGBtoYIQ(BlindGetPixelColor(x,yy));
- if (y) tmpy.BlindSetPixelIndex(x,yy,color.rgbRed);
- if (i) tmpi.BlindSetPixelIndex(x,yy,color.rgbGreen);
- if (q) tmpq.BlindSetPixelIndex(x,yy,color.rgbBlue);
- }
- }
-
- if (y) tmpy.SetGrayPalette();
- if (i) tmpi.SetGrayPalette();
- if (q) tmpq.SetGrayPalette();
-
- if (y) y->Transfer(tmpy);
- if (i) i->Transfer(tmpi);
- if (q) q->Transfer(tmpq);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Extract XYZ channels from the image. Each channel is an 8 bit grayscale image.
- * \param x,y,z: pointers to CxImage objects, to store the splited channels
- * \return true if everything is ok
- */
-bool CxImage::SplitXYZ(CxImage* x,CxImage* y,CxImage* z)
-{
- if (!pDib) return false;
- if (x==NULL && y==NULL && z==NULL) return false;
-
- CxImage tmpx(head.biWidth,head.biHeight,8);
- CxImage tmpy(head.biWidth,head.biHeight,8);
- CxImage tmpz(head.biWidth,head.biHeight,8);
-
- RGBQUAD color;
- for(int32_t yy=0; yy<head.biHeight; yy++){
- for(int32_t xx=0; xx<head.biWidth; xx++){
- color = RGBtoXYZ(BlindGetPixelColor(xx,yy));
- if (x) tmpx.BlindSetPixelIndex(xx,yy,color.rgbRed);
- if (y) tmpy.BlindSetPixelIndex(xx,yy,color.rgbGreen);
- if (z) tmpz.BlindSetPixelIndex(xx,yy,color.rgbBlue);
- }
- }
-
- if (x) tmpx.SetGrayPalette();
- if (y) tmpy.SetGrayPalette();
- if (z) tmpz.SetGrayPalette();
-
- if (x) x->Transfer(tmpx);
- if (y) y->Transfer(tmpy);
- if (z) z->Transfer(tmpz);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Extract HSL channels from the image. Each channel is an 8 bit grayscale image.
- * \param h,s,l: pointers to CxImage objects, to store the splited channels
- * \return true if everything is ok
- */
-bool CxImage::SplitHSL(CxImage* h,CxImage* s,CxImage* l)
-{
- if (!pDib) return false;
- if (h==NULL && s==NULL && l==NULL) return false;
-
- CxImage tmph(head.biWidth,head.biHeight,8);
- CxImage tmps(head.biWidth,head.biHeight,8);
- CxImage tmpl(head.biWidth,head.biHeight,8);
-
- RGBQUAD color;
- for(int32_t y=0; y<head.biHeight; y++){
- for(int32_t x=0; x<head.biWidth; x++){
- color = RGBtoHSL(BlindGetPixelColor(x,y));
- if (h) tmph.BlindSetPixelIndex(x,y,color.rgbRed);
- if (s) tmps.BlindSetPixelIndex(x,y,color.rgbGreen);
- if (l) tmpl.BlindSetPixelIndex(x,y,color.rgbBlue);
- }
- }
-
- if (h) tmph.SetGrayPalette();
- if (s) tmps.SetGrayPalette();
- if (l) tmpl.SetGrayPalette();
-
- /* pseudo-color generator for hue channel (visual debug)
- if (h) for(int32_t j=0; j<256; j++){
- uint8_t i=(uint8_t)j;
- RGBQUAD hsl={120,240,i,0};
- tmph.SetPaletteColor(i,HSLtoRGB(hsl));
- }*/
-
- if (h) h->Transfer(tmph);
- if (s) s->Transfer(tmps);
- if (l) l->Transfer(tmpl);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#define HSLMAX 255 /* H,L, and S vary over 0-HSLMAX */
-#define RGBMAX 255 /* R,G, and B vary over 0-RGBMAX */
- /* HSLMAX BEST IF DIVISIBLE BY 6 */
- /* RGBMAX, HSLMAX must each fit in a uint8_t. */
-/* Hue is undefined if Saturation is 0 (grey-scale) */
-/* This value determines where the Hue scrollbar is */
-/* initially set for achromatic colors */
-#define HSLUNDEFINED (HSLMAX*2/3)
-////////////////////////////////////////////////////////////////////////////////
-RGBQUAD CxImage::RGBtoHSL(RGBQUAD lRGBColor)
-{
- uint8_t R,G,B; /* input RGB values */
- uint8_t H,L,S; /* output HSL values */
- uint8_t cMax,cMin; /* max and min RGB values */
- uint16_t Rdelta,Gdelta,Bdelta; /* intermediate value: % of spread from max*/
-
- R = lRGBColor.rgbRed; /* get R, G, and B out of uint32_t */
- G = lRGBColor.rgbGreen;
- B = lRGBColor.rgbBlue;
-
- cMax = max( max(R,G), B); /* calculate lightness */
- cMin = min( min(R,G), B);
- L = (uint8_t)((((cMax+cMin)*HSLMAX)+RGBMAX)/(2*RGBMAX));
-
- if (cMax==cMin){ /* r=g=b --> achromatic case */
- S = 0; /* saturation */
- H = HSLUNDEFINED; /* hue */
- } else { /* chromatic case */
- if (L <= (HSLMAX/2)) /* saturation */
- S = (uint8_t)((((cMax-cMin)*HSLMAX)+((cMax+cMin)/2))/(cMax+cMin));
- else
- S = (uint8_t)((((cMax-cMin)*HSLMAX)+((2*RGBMAX-cMax-cMin)/2))/(2*RGBMAX-cMax-cMin));
- /* hue */
- Rdelta = (uint16_t)((((cMax-R)*(HSLMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin));
- Gdelta = (uint16_t)((((cMax-G)*(HSLMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin));
- Bdelta = (uint16_t)((((cMax-B)*(HSLMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin));
-
- if (R == cMax)
- H = (uint8_t)(Bdelta - Gdelta);
- else if (G == cMax)
- H = (uint8_t)((HSLMAX/3) + Rdelta - Bdelta);
- else /* B == cMax */
- H = (uint8_t)(((2*HSLMAX)/3) + Gdelta - Rdelta);
-
-// if (H < 0) H += HSLMAX; //always false
- if (H > HSLMAX) H -= HSLMAX;
- }
- RGBQUAD hsl={L,S,H,0};
- return hsl;
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::HueToRGB(float n1,float n2, float hue)
-{
- //<F. Livraghi> fixed implementation for HSL2RGB routine
- float rValue;
-
- if (hue > 360)
- hue = hue - 360;
- else if (hue < 0)
- hue = hue + 360;
-
- if (hue < 60)
- rValue = n1 + (n2-n1)*hue/60.0f;
- else if (hue < 180)
- rValue = n2;
- else if (hue < 240)
- rValue = n1+(n2-n1)*(240-hue)/60;
- else
- rValue = n1;
-
- return rValue;
-}
-////////////////////////////////////////////////////////////////////////////////
-RGBQUAD CxImage::HSLtoRGB(COLORREF cHSLColor)
-{
- return HSLtoRGB(RGBtoRGBQUAD(cHSLColor));
-}
-////////////////////////////////////////////////////////////////////////////////
-RGBQUAD CxImage::HSLtoRGB(RGBQUAD lHSLColor)
-{
- //<F. Livraghi> fixed implementation for HSL2RGB routine
- float h,s,l;
- float m1,m2;
- uint8_t r,g,b;
-
- h = (float)lHSLColor.rgbRed * 360.0f/255.0f;
- s = (float)lHSLColor.rgbGreen/255.0f;
- l = (float)lHSLColor.rgbBlue/255.0f;
-
- if (l <= 0.5) m2 = l * (1+s);
- else m2 = l + s - l*s;
-
- m1 = 2 * l - m2;
-
- if (s == 0) {
- r=g=b=(uint8_t)(l*255.0f);
- } else {
- r = (uint8_t)(HueToRGB(m1,m2,h+120) * 255.0f);
- g = (uint8_t)(HueToRGB(m1,m2,h) * 255.0f);
- b = (uint8_t)(HueToRGB(m1,m2,h-120) * 255.0f);
- }
-
- RGBQUAD rgb = {b,g,r,0};
- return rgb;
-}
-////////////////////////////////////////////////////////////////////////////////
-RGBQUAD CxImage::YUVtoRGB(RGBQUAD lYUVColor)
-{
- int32_t U,V,R,G,B;
- float Y = lYUVColor.rgbRed;
- U = lYUVColor.rgbGreen - 128;
- V = lYUVColor.rgbBlue - 128;
-
-// R = (int32_t)(1.164 * Y + 2.018 * U);
-// G = (int32_t)(1.164 * Y - 0.813 * V - 0.391 * U);
-// B = (int32_t)(1.164 * Y + 1.596 * V);
- R = (int32_t)( Y + 1.403f * V);
- G = (int32_t)( Y - 0.344f * U - 0.714f * V);
- B = (int32_t)( Y + 1.770f * U);
-
- R= min(255,max(0,R));
- G= min(255,max(0,G));
- B= min(255,max(0,B));
- RGBQUAD rgb={(uint8_t)B,(uint8_t)G,(uint8_t)R,0};
- return rgb;
-}
-////////////////////////////////////////////////////////////////////////////////
-RGBQUAD CxImage::RGBtoYUV(RGBQUAD lRGBColor)
-{
- int32_t Y,U,V,R,G,B;
- R = lRGBColor.rgbRed;
- G = lRGBColor.rgbGreen;
- B = lRGBColor.rgbBlue;
-
-// Y = (int32_t)( 0.257 * R + 0.504 * G + 0.098 * B);
-// U = (int32_t)( 0.439 * R - 0.368 * G - 0.071 * B + 128);
-// V = (int32_t)(-0.148 * R - 0.291 * G + 0.439 * B + 128);
- Y = (int32_t)(0.299f * R + 0.587f * G + 0.114f * B);
- U = (int32_t)((B-Y) * 0.565f + 128);
- V = (int32_t)((R-Y) * 0.713f + 128);
-
- Y= min(255,max(0,Y));
- U= min(255,max(0,U));
- V= min(255,max(0,V));
- RGBQUAD yuv={(uint8_t)V,(uint8_t)U,(uint8_t)Y,0};
- return yuv;
-}
-////////////////////////////////////////////////////////////////////////////////
-RGBQUAD CxImage::YIQtoRGB(RGBQUAD lYIQColor)
-{
- int32_t I,Q,R,G,B;
- float Y = lYIQColor.rgbRed;
- I = lYIQColor.rgbGreen - 128;
- Q = lYIQColor.rgbBlue - 128;
-
- R = (int32_t)( Y + 0.956f * I + 0.621f * Q);
- G = (int32_t)( Y - 0.273f * I - 0.647f * Q);
- B = (int32_t)( Y - 1.104f * I + 1.701f * Q);
-
- R= min(255,max(0,R));
- G= min(255,max(0,G));
- B= min(255,max(0,B));
- RGBQUAD rgb={(uint8_t)B,(uint8_t)G,(uint8_t)R,0};
- return rgb;
-}
-////////////////////////////////////////////////////////////////////////////////
-RGBQUAD CxImage::RGBtoYIQ(RGBQUAD lRGBColor)
-{
- int32_t Y,I,Q,R,G,B;
- R = lRGBColor.rgbRed;
- G = lRGBColor.rgbGreen;
- B = lRGBColor.rgbBlue;
-
- Y = (int32_t)( 0.2992f * R + 0.5868f * G + 0.1140f * B);
- I = (int32_t)( 0.5960f * R - 0.2742f * G - 0.3219f * B + 128);
- Q = (int32_t)( 0.2109f * R - 0.5229f * G + 0.3120f * B + 128);
-
- Y= min(255,max(0,Y));
- I= min(255,max(0,I));
- Q= min(255,max(0,Q));
- RGBQUAD yiq={(uint8_t)Q,(uint8_t)I,(uint8_t)Y,0};
- return yiq;
-}
-////////////////////////////////////////////////////////////////////////////////
-RGBQUAD CxImage::XYZtoRGB(RGBQUAD lXYZColor)
-{
- int32_t X,Y,Z,R,G,B;
- X = lXYZColor.rgbRed;
- Y = lXYZColor.rgbGreen;
- Z = lXYZColor.rgbBlue;
- double k=1.088751;
-
- R = (int32_t)( 3.240479f * X - 1.537150f * Y - 0.498535f * Z * k);
- G = (int32_t)( -0.969256f * X + 1.875992f * Y + 0.041556f * Z * k);
- B = (int32_t)( 0.055648f * X - 0.204043f * Y + 1.057311f * Z * k);
-
- R= min(255,max(0,R));
- G= min(255,max(0,G));
- B= min(255,max(0,B));
- RGBQUAD rgb={(uint8_t)B,(uint8_t)G,(uint8_t)R,0};
- return rgb;
-}
-////////////////////////////////////////////////////////////////////////////////
-RGBQUAD CxImage::RGBtoXYZ(RGBQUAD lRGBColor)
-{
- int32_t X,Y,Z,R,G,B;
- R = lRGBColor.rgbRed;
- G = lRGBColor.rgbGreen;
- B = lRGBColor.rgbBlue;
-
- X = (int32_t)( 0.412453f * R + 0.357580f * G + 0.180423f * B);
- Y = (int32_t)( 0.212671f * R + 0.715160f * G + 0.072169f * B);
- Z = (int32_t)((0.019334f * R + 0.119193f * G + 0.950227f * B)*0.918483657f);
-
- //X= min(255,max(0,X));
- //Y= min(255,max(0,Y));
- //Z= min(255,max(0,Z));
- RGBQUAD xyz={(uint8_t)Z,(uint8_t)Y,(uint8_t)X,0};
- return xyz;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Generates a "rainbow" palette with saturated colors
- * \param correction: 1 generates a single hue spectrum. 0.75 is nice for scientific applications.
- */
-void CxImage::HuePalette(float correction)
-{
- if (head.biClrUsed==0) return;
-
- for(uint32_t j=0; j<head.biClrUsed; j++){
- uint8_t i=(uint8_t)(j*correction*(255/(head.biClrUsed-1)));
- RGBQUAD hsl={120,240,i,0};
- SetPaletteColor((uint8_t)j,HSLtoRGB(hsl));
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Replaces the original hue and saturation values.
- * \param hue: hue
- * \param sat: saturation
- * \param blend: can be from 0 (no effect) to 1 (full effect)
- * \return true if everything is ok
- */
-bool CxImage::Colorize(uint8_t hue, uint8_t sat, float blend)
-{
- if (!pDib) return false;
-
- if (blend < 0.0f) blend = 0.0f;
- if (blend > 1.0f) blend = 1.0f;
- int32_t a0 = (int32_t)(256*blend);
- int32_t a1 = 256 - a0;
-
- bool bFullBlend = false;
- if (blend > 0.999f) bFullBlend = true;
-
- RGBQUAD color,hsl;
- if (head.biClrUsed==0){
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- if (bFullBlend){
- color = RGBtoHSL(BlindGetPixelColor(x,y));
- color.rgbRed=hue;
- color.rgbGreen=sat;
- BlindSetPixelColor(x,y,HSLtoRGB(color));
- } else {
- color = BlindGetPixelColor(x,y);
- hsl.rgbRed=hue;
- hsl.rgbGreen=sat;
- hsl.rgbBlue = (uint8_t)RGB2GRAY(color.rgbRed,color.rgbGreen,color.rgbBlue);
- hsl = HSLtoRGB(hsl);
- //BlendPixelColor(x,y,hsl,blend);
- //color.rgbRed = (uint8_t)(hsl.rgbRed * blend + color.rgbRed * (1.0f - blend));
- //color.rgbBlue = (uint8_t)(hsl.rgbBlue * blend + color.rgbBlue * (1.0f - blend));
- //color.rgbGreen = (uint8_t)(hsl.rgbGreen * blend + color.rgbGreen * (1.0f - blend));
- color.rgbRed = (uint8_t)((hsl.rgbRed * a0 + color.rgbRed * a1)>>8);
- color.rgbBlue = (uint8_t)((hsl.rgbBlue * a0 + color.rgbBlue * a1)>>8);
- color.rgbGreen = (uint8_t)((hsl.rgbGreen * a0 + color.rgbGreen * a1)>>8);
- BlindSetPixelColor(x,y,color);
- }
- }
- }
- }
- } else {
- for(uint32_t j=0; j<head.biClrUsed; j++){
- if (bFullBlend){
- color = RGBtoHSL(GetPaletteColor((uint8_t)j));
- color.rgbRed=hue;
- color.rgbGreen=sat;
- SetPaletteColor((uint8_t)j,HSLtoRGB(color));
- } else {
- color = GetPaletteColor((uint8_t)j);
- hsl.rgbRed=hue;
- hsl.rgbGreen=sat;
- hsl.rgbBlue = (uint8_t)RGB2GRAY(color.rgbRed,color.rgbGreen,color.rgbBlue);
- hsl = HSLtoRGB(hsl);
- color.rgbRed = (uint8_t)(hsl.rgbRed * blend + color.rgbRed * (1.0f - blend));
- color.rgbBlue = (uint8_t)(hsl.rgbBlue * blend + color.rgbBlue * (1.0f - blend));
- color.rgbGreen = (uint8_t)(hsl.rgbGreen * blend + color.rgbGreen * (1.0f - blend));
- SetPaletteColor((uint8_t)j,color);
- }
- }
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Changes the brightness and the contrast of the image.
- * \param brightness: can be from -255 to 255, if brightness is negative, the image becomes dark.
- * \param contrast: can be from -100 to 100, the neutral value is 0.
- * \return true if everything is ok
- */
-bool CxImage::Light(int32_t brightness, int32_t contrast)
-{
- if (!pDib) return false;
- float c=(100 + contrast)/100.0f;
- brightness+=128;
-
- uint8_t cTable[256]; //<nipper>
- for (int32_t i=0;i<256;i++) {
- cTable[i] = (uint8_t)max(0,min(255,(int32_t)((i-128)*c + brightness + 0.5f)));
- }
-
- return Lut(cTable);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return mean lightness of the image. Useful with Threshold() and Light()
- */
-float CxImage::Mean()
-{
- if (!pDib) return 0;
-
- CxImage tmp(*this,true);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- tmp.GrayScale();
- float sum=0;
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
- if (xmin==xmax || ymin==ymax) return (float)0.0;
-
- uint8_t *iSrc=tmp.info.pImage;
- iSrc += tmp.info.dwEffWidth*ymin; // necessary for selections <Admir Hodzic>
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin)); //<zhanghk><Anatoly Ivasyuk>
- for(int32_t x=xmin; x<xmax; x++){
- sum+=iSrc[x];
- }
- iSrc+=tmp.info.dwEffWidth;
- }
- return sum/(xmax-xmin)/(ymax-ymin);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * 2D linear filter
- * \param kernel: convolving matrix, in row format.
- * \param Ksize: size of the kernel.
- * \param Kfactor: normalization constant.
- * \param Koffset: bias.
- * \verbatim Example: the "soften" filter uses this kernel:
- 1 1 1
- 1 8 1
- 1 1 1
- the function needs: kernel={1,1,1,1,8,1,1,1,1}; Ksize=3; Kfactor=16; Koffset=0; \endverbatim
- * \return true if everything is ok
- */
-bool CxImage::Filter(int32_t* kernel, int32_t Ksize, int32_t Kfactor, int32_t Koffset)
-{
- if (!pDib) return false;
-
- int32_t k2 = Ksize/2;
- int32_t kmax= Ksize-k2;
- int32_t r,g,b,i;
- int32_t ksumcur,ksumtot;
- RGBQUAD c;
-
- CxImage tmp(*this);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- ksumtot = 0;
- for(int32_t j=-k2;j<kmax;j++){
- for(int32_t k=-k2;k<kmax;k++){
- ksumtot += kernel[(j+k2)+Ksize*(k+k2)];
- }
- }
-
- if ((head.biBitCount==8) && IsGrayScale())
- {
- uint8_t* cPtr;
- uint8_t* cPtr2;
- int32_t iCount;
- int32_t iY, iY2, iY1;
- cPtr = info.pImage;
- cPtr2 = (uint8_t *)tmp.info.pImage;
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- iY1 = y*info.dwEffWidth+xmin;
- for(int32_t x=xmin; x<xmax; x++, iY1++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- b=ksumcur=0;
- iCount = 0;
- iY2 = ((y-k2)*info.dwEffWidth);
- for(int32_t j=-k2;j<kmax;j++, iY2+=info.dwEffWidth)
- {
- if (0>(y+j) || (y+j)>=head.biHeight) continue;
- iY = iY2+x;
- for(int32_t k=-k2;k<kmax;k++, iCount++)
- {
- if (0>(x+k) || (x+k)>=head.biWidth) continue;
- i=kernel[iCount];
- b += cPtr[iY+k] * i;
- ksumcur += i;
- }
- }
- if (Kfactor==0 || ksumcur==0){
- cPtr2[iY1] = (uint8_t)min(255, max(0,(int32_t)(b + Koffset)));
- } else if (ksumtot == ksumcur) {
- cPtr2[iY1] = (uint8_t)min(255, max(0,(int32_t)(b/Kfactor + Koffset)));
- } else {
- cPtr2[iY1] = (uint8_t)min(255, max(0,(int32_t)((b*ksumtot)/(ksumcur*Kfactor) + Koffset)));
- }
- }
- }
- }
- }
- else
- {
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
- #if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
- #endif //CXIMAGE_SUPPORT_SELECTION
- {
- r=b=g=ksumcur=0;
- for(int32_t j=-k2;j<kmax;j++){
- for(int32_t k=-k2;k<kmax;k++){
- if (!IsInside(x+j,y+k)) continue;
- c = BlindGetPixelColor(x+j,y+k);
- i = kernel[(j+k2)+Ksize*(k+k2)];
- r += c.rgbRed * i;
- g += c.rgbGreen * i;
- b += c.rgbBlue * i;
- ksumcur += i;
- }
- }
- if (Kfactor==0 || ksumcur==0){
- c.rgbRed = (uint8_t)min(255, max(0,(int32_t)(r + Koffset)));
- c.rgbGreen = (uint8_t)min(255, max(0,(int32_t)(g + Koffset)));
- c.rgbBlue = (uint8_t)min(255, max(0,(int32_t)(b + Koffset)));
- } else if (ksumtot == ksumcur) {
- c.rgbRed = (uint8_t)min(255, max(0,(int32_t)(r/Kfactor + Koffset)));
- c.rgbGreen = (uint8_t)min(255, max(0,(int32_t)(g/Kfactor + Koffset)));
- c.rgbBlue = (uint8_t)min(255, max(0,(int32_t)(b/Kfactor + Koffset)));
- } else {
- c.rgbRed = (uint8_t)min(255, max(0,(int32_t)((r*ksumtot)/(ksumcur*Kfactor) + Koffset)));
- c.rgbGreen = (uint8_t)min(255, max(0,(int32_t)((g*ksumtot)/(ksumcur*Kfactor) + Koffset)));
- c.rgbBlue = (uint8_t)min(255, max(0,(int32_t)((b*ksumtot)/(ksumcur*Kfactor) + Koffset)));
- }
- tmp.BlindSetPixelColor(x,y,c);
- }
- }
- }
- }
- Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Enhance the dark areas of the image
- * \param Ksize: size of the kernel.
- * \return true if everything is ok
- */
-bool CxImage::Erode(int32_t Ksize)
-{
- if (!pDib) return false;
-
- int32_t k2 = Ksize/2;
- int32_t kmax= Ksize-k2;
- uint8_t r,g,b;
- RGBQUAD c;
-
- CxImage tmp(*this);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- r=b=g=255;
- for(int32_t j=-k2;j<kmax;j++){
- for(int32_t k=-k2;k<kmax;k++){
- if (!IsInside(x+j,y+k)) continue;
- c = BlindGetPixelColor(x+j,y+k);
- if (c.rgbRed < r) r=c.rgbRed;
- if (c.rgbGreen < g) g=c.rgbGreen;
- if (c.rgbBlue < b) b=c.rgbBlue;
- }
- }
- c.rgbRed = r;
- c.rgbGreen = g;
- c.rgbBlue = b;
- tmp.BlindSetPixelColor(x,y,c);
- }
- }
- }
- Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Enhance the light areas of the image
- * \param Ksize: size of the kernel.
- * \return true if everything is ok
- */
-bool CxImage::Dilate(int32_t Ksize)
-{
- if (!pDib) return false;
-
- int32_t k2 = Ksize/2;
- int32_t kmax= Ksize-k2;
- uint8_t r,g,b;
- RGBQUAD c;
-
- CxImage tmp(*this);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- r=b=g=0;
- for(int32_t j=-k2;j<kmax;j++){
- for(int32_t k=-k2;k<kmax;k++){
- if (!IsInside(x+j,y+k)) continue;
- c = BlindGetPixelColor(x+j,y+k);
- if (c.rgbRed > r) r=c.rgbRed;
- if (c.rgbGreen > g) g=c.rgbGreen;
- if (c.rgbBlue > b) b=c.rgbBlue;
- }
- }
- c.rgbRed = r;
- c.rgbGreen = g;
- c.rgbBlue = b;
- tmp.BlindSetPixelColor(x,y,c);
- }
- }
- }
- Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Enhance the variations between adjacent pixels.
- * Similar results can be achieved using Filter(),
- * but the algorithms are different both in Edge() and in Contour().
- * \param Ksize: size of the kernel.
- * \return true if everything is ok
- */
-bool CxImage::Edge(int32_t Ksize)
-{
- if (!pDib) return false;
-
- int32_t k2 = Ksize/2;
- int32_t kmax= Ksize-k2;
- uint8_t r,g,b,rr,gg,bb;
- RGBQUAD c;
-
- CxImage tmp(*this);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- r=b=g=0;
- rr=bb=gg=255;
- for(int32_t j=-k2;j<kmax;j++){
- for(int32_t k=-k2;k<kmax;k++){
- if (!IsInside(x+j,y+k)) continue;
- c = BlindGetPixelColor(x+j,y+k);
- if (c.rgbRed > r) r=c.rgbRed;
- if (c.rgbGreen > g) g=c.rgbGreen;
- if (c.rgbBlue > b) b=c.rgbBlue;
-
- if (c.rgbRed < rr) rr=c.rgbRed;
- if (c.rgbGreen < gg) gg=c.rgbGreen;
- if (c.rgbBlue < bb) bb=c.rgbBlue;
- }
- }
- c.rgbRed = (uint8_t)(255-abs(r-rr));
- c.rgbGreen = (uint8_t)(255-abs(g-gg));
- c.rgbBlue = (uint8_t)(255-abs(b-bb));
- tmp.BlindSetPixelColor(x,y,c);
- }
- }
- }
- Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Blends two images
- * \param imgsrc2: image to be mixed with this
- * \param op: blending method; see ImageOpType
- * \param lXOffset, lYOffset: image displacement
- * \param bMixAlpha: if true and imgsrc2 has a valid alpha layer, it will be mixed in the destination image.
- * \return true if everything is ok
- * \author [Mwolski],[brunom]
- */
-void CxImage::Mix(CxImage & imgsrc2, ImageOpType op, int32_t lXOffset, int32_t lYOffset, bool bMixAlpha)
-{
- int32_t lWide = min(GetWidth(),imgsrc2.GetWidth()-lXOffset);
- int32_t lHeight = min(GetHeight(),imgsrc2.GetHeight()-lYOffset);
-
- bool bEditAlpha = false;
-
-#if CXIMAGE_SUPPORT_ALPHA
- bEditAlpha = imgsrc2.AlphaIsValid() & bMixAlpha;
- if (bEditAlpha && AlphaIsValid()==false){
- AlphaCreate();
- }
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- RGBQUAD rgbBackgrnd1 = GetTransColor();
- RGBQUAD rgb1, rgb2, rgbDest;
-
- for(int32_t lY=0;lY<lHeight;lY++)
- {
- info.nProgress = (int32_t)(100*lY/head.biHeight);
- if (info.nEscape) break;
-
- for(int32_t lX=0;lX<lWide;lX++)
- {
-#if CXIMAGE_SUPPORT_SELECTION
- if (SelectionIsInside(lX,lY) && imgsrc2.SelectionIsInside(lX+lXOffset,lY+lYOffset))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- rgb1 = GetPixelColor(lX,lY);
- rgb2 = imgsrc2.GetPixelColor(lX+lXOffset,lY+lYOffset);
- switch(op)
- {
- case OpAvg:
- rgbDest.rgbBlue = (uint8_t)((rgb1.rgbBlue+rgb2.rgbBlue)/2);
- rgbDest.rgbGreen = (uint8_t)((rgb1.rgbGreen+rgb2.rgbGreen)/2);
- rgbDest.rgbRed = (uint8_t)((rgb1.rgbRed+rgb2.rgbRed)/2);
- if (bEditAlpha) rgbDest.rgbReserved = (uint8_t)((rgb1.rgbReserved+rgb2.rgbReserved)/2);
- break;
- case OpAdd:
- rgbDest.rgbBlue = (uint8_t)max(0,min(255,rgb1.rgbBlue+rgb2.rgbBlue));
- rgbDest.rgbGreen = (uint8_t)max(0,min(255,rgb1.rgbGreen+rgb2.rgbGreen));
- rgbDest.rgbRed = (uint8_t)max(0,min(255,rgb1.rgbRed+rgb2.rgbRed));
- if (bEditAlpha) rgbDest.rgbReserved = (uint8_t)max(0,min(255,rgb1.rgbReserved+rgb2.rgbReserved));
- break;
- case OpSub:
- rgbDest.rgbBlue = (uint8_t)max(0,min(255,rgb1.rgbBlue-rgb2.rgbBlue));
- rgbDest.rgbGreen = (uint8_t)max(0,min(255,rgb1.rgbGreen-rgb2.rgbGreen));
- rgbDest.rgbRed = (uint8_t)max(0,min(255,rgb1.rgbRed-rgb2.rgbRed));
- if (bEditAlpha) rgbDest.rgbReserved = (uint8_t)max(0,min(255,rgb1.rgbReserved-rgb2.rgbReserved));
- break;
- case OpAnd:
- rgbDest.rgbBlue = (uint8_t)(rgb1.rgbBlue&rgb2.rgbBlue);
- rgbDest.rgbGreen = (uint8_t)(rgb1.rgbGreen&rgb2.rgbGreen);
- rgbDest.rgbRed = (uint8_t)(rgb1.rgbRed&rgb2.rgbRed);
- if (bEditAlpha) rgbDest.rgbReserved = (uint8_t)(rgb1.rgbReserved&rgb2.rgbReserved);
- break;
- case OpXor:
- rgbDest.rgbBlue = (uint8_t)(rgb1.rgbBlue^rgb2.rgbBlue);
- rgbDest.rgbGreen = (uint8_t)(rgb1.rgbGreen^rgb2.rgbGreen);
- rgbDest.rgbRed = (uint8_t)(rgb1.rgbRed^rgb2.rgbRed);
- if (bEditAlpha) rgbDest.rgbReserved = (uint8_t)(rgb1.rgbReserved^rgb2.rgbReserved);
- break;
- case OpOr:
- rgbDest.rgbBlue = (uint8_t)(rgb1.rgbBlue|rgb2.rgbBlue);
- rgbDest.rgbGreen = (uint8_t)(rgb1.rgbGreen|rgb2.rgbGreen);
- rgbDest.rgbRed = (uint8_t)(rgb1.rgbRed|rgb2.rgbRed);
- if (bEditAlpha) rgbDest.rgbReserved = (uint8_t)(rgb1.rgbReserved|rgb2.rgbReserved);
- break;
- case OpMask:
- if(rgb2.rgbBlue==0 && rgb2.rgbGreen==0 && rgb2.rgbRed==0)
- rgbDest = rgbBackgrnd1;
- else
- rgbDest = rgb1;
- break;
- case OpSrcCopy:
- if(IsTransparent(lX,lY))
- rgbDest = rgb2;
- else // copy straight over
- rgbDest = rgb1;
- break;
- case OpDstCopy:
- if(imgsrc2.IsTransparent(lX+lXOffset,lY+lYOffset))
- rgbDest = rgb1;
- else // copy straight over
- rgbDest = rgb2;
- break;
- case OpScreen:
- {
- uint8_t a,a1;
-
- if (imgsrc2.IsTransparent(lX+lXOffset,lY+lYOffset)){
- a=0;
-#if CXIMAGE_SUPPORT_ALPHA
- } else if (imgsrc2.AlphaIsValid()){
- a=imgsrc2.AlphaGet(lX+lXOffset,lY+lYOffset);
- a =(uint8_t)((a*imgsrc2.info.nAlphaMax)/255);
-#endif //CXIMAGE_SUPPORT_ALPHA
- } else {
- a=255;
- }
-
- if (a==0){ //transparent
- rgbDest = rgb1;
- } else if (a==255){ //opaque
- rgbDest = rgb2;
- } else { //blend
- a1 = (uint8_t)~a;
- rgbDest.rgbBlue = (uint8_t)((rgb1.rgbBlue*a1+rgb2.rgbBlue*a)/255);
- rgbDest.rgbGreen = (uint8_t)((rgb1.rgbGreen*a1+rgb2.rgbGreen*a)/255);
- rgbDest.rgbRed = (uint8_t)((rgb1.rgbRed*a1+rgb2.rgbRed*a)/255);
- }
-
- if (bEditAlpha) rgbDest.rgbReserved = (uint8_t)((rgb1.rgbReserved*a)/255);
- }
- break;
- case OpSrcBlend:
- if(IsTransparent(lX,lY))
- rgbDest = rgb2;
- else
- {
- int32_t lBDiff = abs(rgb1.rgbBlue - rgbBackgrnd1.rgbBlue);
- int32_t lGDiff = abs(rgb1.rgbGreen - rgbBackgrnd1.rgbGreen);
- int32_t lRDiff = abs(rgb1.rgbRed - rgbBackgrnd1.rgbRed);
-
- double lAverage = (lBDiff+lGDiff+lRDiff)/3;
- double lThresh = 16;
- double dLarge = lAverage/lThresh;
- double dSmall = (lThresh-lAverage)/lThresh;
- double dSmallAmt = dSmall*((double)rgb2.rgbBlue);
-
- if( lAverage < lThresh+1){
- rgbDest.rgbBlue = (uint8_t)max(0,min(255,(int32_t)(dLarge*((double)rgb1.rgbBlue) +
- dSmallAmt)));
- rgbDest.rgbGreen = (uint8_t)max(0,min(255,(int32_t)(dLarge*((double)rgb1.rgbGreen) +
- dSmallAmt)));
- rgbDest.rgbRed = (uint8_t)max(0,min(255,(int32_t)(dLarge*((double)rgb1.rgbRed) +
- dSmallAmt)));
- }
- else
- rgbDest = rgb1;
- }
- break;
- case OpBlendAlpha: //[brunom]
- if(rgb2.rgbReserved != 0)
- {
- // The lower value is almost transparent, or the overlying
- // almost transparent can not directly overlying the value taken
- if( (rgb1.rgbReserved < 5) || (rgb2.rgbReserved > 250) ){
- rgbDest = rgb2;
- } else {
- // Alpha Blending with associative calculation merge
- // (http://en.wikipedia.org/wiki/Alpha_compositing)
- int32_t a0,a1,a2;
- // Transparency of the superimposed image
- a2 = rgb2.rgbReserved;
- // Calculation transparency of the underlying image
- a1 = (rgb1.rgbReserved * (255 - a2)) >> 8;
- // total transparency of the new pixel
- a0 = a2 + a1;
- // New transparency assume (a0 == 0 is the restriction s.o. (range 5-250) intercepted)
- if (bEditAlpha) rgbDest.rgbReserved = a0;
- // each color channel to calculate
- rgbDest.rgbBlue = (BYTE)((rgb2.rgbBlue * a2 + a1 * rgb1.rgbBlue )/a0);
- rgbDest.rgbGreen = (BYTE)((rgb2.rgbGreen * a2 + a1 * rgb1.rgbGreen)/a0);
- rgbDest.rgbRed = (BYTE)((rgb2.rgbRed * a2 + a1 * rgb1.rgbRed )/a0);
- }
- } else {
- rgbDest = rgb1;
- rgbDest.rgbReserved = 0;
- }
- break;
- default:
- return;
- }
- SetPixelColor(lX,lY,rgbDest,bEditAlpha);
- }
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-// thanks to Kenneth Ballard
-void CxImage::MixFrom(CxImage & imagesrc2, int32_t lXOffset, int32_t lYOffset)
-{
- int32_t width = imagesrc2.GetWidth();
- int32_t height = imagesrc2.GetHeight();
-
- int32_t x, y;
-
- if (imagesrc2.IsTransparent()) {
- for(x = 0; x < width; x++) {
- for(y = 0; y < height; y++) {
- if(!imagesrc2.IsTransparent(x,y)){
- SetPixelColor(x + lXOffset, y + lYOffset, imagesrc2.BlindGetPixelColor(x, y));
- }
- }
- }
- } else { //no transparency so just set it <Matt>
- for(x = 0; x < width; x++) {
- for(y = 0; y < height; y++) {
- SetPixelColor(x + lXOffset, y + lYOffset, imagesrc2.BlindGetPixelColor(x, y));
- }
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Adjusts separately the red, green, and blue values in the image.
- * \param r, g, b: can be from -255 to +255.
- * \return true if everything is ok
- */
-bool CxImage::ShiftRGB(int32_t r, int32_t g, int32_t b)
-{
- if (!pDib) return false;
- RGBQUAD color;
- if (head.biClrUsed==0){
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- for(int32_t y=ymin; y<ymax; y++){
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- color = BlindGetPixelColor(x,y);
- color.rgbRed = (uint8_t)max(0,min(255,(int32_t)(color.rgbRed + r)));
- color.rgbGreen = (uint8_t)max(0,min(255,(int32_t)(color.rgbGreen + g)));
- color.rgbBlue = (uint8_t)max(0,min(255,(int32_t)(color.rgbBlue + b)));
- BlindSetPixelColor(x,y,color);
- }
- }
- }
- } else {
- for(uint32_t j=0; j<head.biClrUsed; j++){
- color = GetPaletteColor((uint8_t)j);
- color.rgbRed = (uint8_t)max(0,min(255,(int32_t)(color.rgbRed + r)));
- color.rgbGreen = (uint8_t)max(0,min(255,(int32_t)(color.rgbGreen + g)));
- color.rgbBlue = (uint8_t)max(0,min(255,(int32_t)(color.rgbBlue + b)));
- SetPaletteColor((uint8_t)j,color);
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Adjusts the color balance of the image
- * \param gamma can be from 0.1 to 5.
- * \return true if everything is ok
- * \sa GammaRGB
- */
-bool CxImage::Gamma(float gamma)
-{
- if (!pDib) return false;
-
- if (gamma <= 0.0f) return false;
-
- double dinvgamma = 1/gamma;
- double dMax = pow(255.0, dinvgamma) / 255.0;
-
- uint8_t cTable[256]; //<nipper>
- for (int32_t i=0;i<256;i++) {
- cTable[i] = (uint8_t)max(0,min(255,(int32_t)( pow((double)i, dinvgamma) / dMax)));
- }
-
- return Lut(cTable);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Adjusts the color balance indipendent for each color channel
- * \param gammaR, gammaG, gammaB can be from 0.1 to 5.
- * \return true if everything is ok
- * \sa Gamma
- */
-bool CxImage::GammaRGB(float gammaR, float gammaG, float gammaB)
-{
- if (!pDib) return false;
-
- if (gammaR <= 0.0f) return false;
- if (gammaG <= 0.0f) return false;
- if (gammaB <= 0.0f) return false;
-
- double dinvgamma, dMax;
- int32_t i;
-
- dinvgamma = 1/gammaR;
- dMax = pow(255.0, dinvgamma) / 255.0;
- uint8_t cTableR[256];
- for (i=0;i<256;i++) {
- cTableR[i] = (uint8_t)max(0,min(255,(int32_t)( pow((double)i, dinvgamma) / dMax)));
- }
-
- dinvgamma = 1/gammaG;
- dMax = pow(255.0, dinvgamma) / 255.0;
- uint8_t cTableG[256];
- for (i=0;i<256;i++) {
- cTableG[i] = (uint8_t)max(0,min(255,(int32_t)( pow((double)i, dinvgamma) / dMax)));
- }
-
- dinvgamma = 1/gammaB;
- dMax = pow(255.0, dinvgamma) / 255.0;
- uint8_t cTableB[256];
- for (i=0;i<256;i++) {
- cTableB[i] = (uint8_t)max(0,min(255,(int32_t)( pow((double)i, dinvgamma) / dMax)));
- }
-
- return Lut(cTableR, cTableG, cTableB);
-}
-////////////////////////////////////////////////////////////////////////////////
-
-//#if !defined (_WIN32_WCE)
-/**
- * Adjusts the intensity of each pixel to the median intensity of its surrounding pixels.
- * \param Ksize: size of the kernel.
- * \return true if everything is ok
- */
-bool CxImage::Median(int32_t Ksize)
-{
- if (!pDib) return false;
-
- int32_t k2 = Ksize/2;
- int32_t kmax= Ksize-k2;
- int32_t i,j,k;
-
- RGBQUAD* kernel = (RGBQUAD*)malloc(Ksize*Ksize*sizeof(RGBQUAD));
-
- CxImage tmp(*this);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- for(j=-k2, i=0;j<kmax;j++)
- for(k=-k2;k<kmax;k++)
- if (IsInside(x+j,y+k))
- kernel[i++]=BlindGetPixelColor(x+j,y+k);
-
- qsort(kernel, i, sizeof(RGBQUAD), CompareColors);
- tmp.SetPixelColor(x,y,kernel[i/2]);
- }
- }
- }
- free(kernel);
- Transfer(tmp);
- return true;
-}
-//#endif //_WIN32_WCE
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Adds an uniform noise to the image
- * \param level: can be from 0 (no noise) to 255 (lot of noise).
- * \return true if everything is ok
- */
-bool CxImage::Noise(int32_t level)
-{
- if (!pDib) return false;
- RGBQUAD color;
-
- int32_t xmin,xmax,ymin,ymax,n;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin)); //<zhanghk><Anatoly Ivasyuk>
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- color = BlindGetPixelColor(x,y);
- n=(int32_t)((rand()/(float)RAND_MAX - 0.5)*level);
- color.rgbRed = (uint8_t)max(0,min(255,(int32_t)(color.rgbRed + n)));
- n=(int32_t)((rand()/(float)RAND_MAX - 0.5)*level);
- color.rgbGreen = (uint8_t)max(0,min(255,(int32_t)(color.rgbGreen + n)));
- n=(int32_t)((rand()/(float)RAND_MAX - 0.5)*level);
- color.rgbBlue = (uint8_t)max(0,min(255,(int32_t)(color.rgbBlue + n)));
- BlindSetPixelColor(x,y,color);
- }
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the bidimensional FFT or DFT of the image.
- * - The images are processed as grayscale
- * - If the dimensions of the image are a power of, 2 the FFT is performed automatically.
- * - If dstReal and/or dstImag are NULL, the resulting images replaces the original(s).
- * - Note: with 8 bits there is a HUGE loss in the dynamics. The function tries
- * to keep an acceptable SNR, but 8bit = 48dB...
- *
- * \param srcReal, srcImag: source images: One can be NULL, but not both
- * \param dstReal, dstImag: destination images. Can be NULL.
- * \param direction: 1 = forward, -1 = inverse.
- * \param bForceFFT: if true, the images are resampled to make the dimensions a power of 2.
- * \param bMagnitude: if true, the real part returns the magnitude, the imaginary part returns the phase
- * \return true if everything is ok
- */
-bool CxImage::FFT2(CxImage* srcReal, CxImage* srcImag, CxImage* dstReal, CxImage* dstImag,
- int32_t direction, bool bForceFFT, bool bMagnitude)
-{
- //check if there is something to convert
- if (srcReal==NULL && srcImag==NULL) return false;
-
- int32_t w,h;
- //get width and height
- if (srcReal) {
- w=srcReal->GetWidth();
- h=srcReal->GetHeight();
- } else {
- w=srcImag->GetWidth();
- h=srcImag->GetHeight();
- }
-
- bool bXpow2 = IsPowerof2(w);
- bool bYpow2 = IsPowerof2(h);
- //if bForceFFT, width AND height must be powers of 2
- if (bForceFFT && !(bXpow2 && bYpow2)) {
- int32_t i;
-
- i=0;
- while((1<<i)<w) i++;
- w=1<<i;
- bXpow2=true;
-
- i=0;
- while((1<<i)<h) i++;
- h=1<<i;
- bYpow2=true;
- }
-
- // I/O images for FFT
- CxImage *tmpReal,*tmpImag;
-
- // select output
- tmpReal = (dstReal) ? dstReal : srcReal;
- tmpImag = (dstImag) ? dstImag : srcImag;
-
- // src!=dst -> copy the image
- if (srcReal && dstReal) tmpReal->Copy(*srcReal,true,false,false);
- if (srcImag && dstImag) tmpImag->Copy(*srcImag,true,false,false);
-
- // dst&&src are empty -> create new one, else turn to GrayScale
- if (srcReal==0 && dstReal==0){
- tmpReal = new CxImage(w,h,8);
- tmpReal->Clear(0);
- tmpReal->SetGrayPalette();
- } else {
- if (!tmpReal->IsGrayScale()) tmpReal->GrayScale();
- }
- if (srcImag==0 && dstImag==0){
- tmpImag = new CxImage(w,h,8);
- tmpImag->Clear(0);
- tmpImag->SetGrayPalette();
- } else {
- if (!tmpImag->IsGrayScale()) tmpImag->GrayScale();
- }
-
- if (!(tmpReal->IsValid() && tmpImag->IsValid())){
- if (srcReal==0 && dstReal==0) delete tmpReal;
- if (srcImag==0 && dstImag==0) delete tmpImag;
- return false;
- }
-
- //resample for FFT, if necessary
- tmpReal->Resample(w,h,0);
- tmpImag->Resample(w,h,0);
-
- //ok, here we have 2 (w x h), grayscale images ready for a FFT
-
- double* real;
- double* imag;
- int32_t j,k,m;
-
- _complex **grid;
- //double mean = tmpReal->Mean();
- /* Allocate memory for the grid */
- grid = (_complex **)malloc(w * sizeof(_complex));
- for (k=0;k<w;k++) {
- grid[k] = (_complex *)malloc(h * sizeof(_complex));
- }
- for (j=0;j<h;j++) {
- for (k=0;k<w;k++) {
- grid[k][j].x = tmpReal->GetPixelIndex(k,j)-128;
- grid[k][j].y = tmpImag->GetPixelIndex(k,j)-128;
- }
- }
-
- //DFT buffers
- double *real2,*imag2;
- real2 = (double*)malloc(max(w,h) * sizeof(double));
- imag2 = (double*)malloc(max(w,h) * sizeof(double));
-
- /* Transform the rows */
- real = (double *)malloc(w * sizeof(double));
- imag = (double *)malloc(w * sizeof(double));
-
- m=0;
- while((1<<m)<w) m++;
-
- for (j=0;j<h;j++) {
- for (k=0;k<w;k++) {
- real[k] = grid[k][j].x;
- imag[k] = grid[k][j].y;
- }
-
- if (bXpow2) FFT(direction,m,real,imag);
- else DFT(direction,w,real,imag,real2,imag2);
-
- for (k=0;k<w;k++) {
- grid[k][j].x = real[k];
- grid[k][j].y = imag[k];
- }
- }
- free(real);
- free(imag);
-
- /* Transform the columns */
- real = (double *)malloc(h * sizeof(double));
- imag = (double *)malloc(h * sizeof(double));
-
- m=0;
- while((1<<m)<h) m++;
-
- for (k=0;k<w;k++) {
- for (j=0;j<h;j++) {
- real[j] = grid[k][j].x;
- imag[j] = grid[k][j].y;
- }
-
- if (bYpow2) FFT(direction,m,real,imag);
- else DFT(direction,h,real,imag,real2,imag2);
-
- for (j=0;j<h;j++) {
- grid[k][j].x = real[j];
- grid[k][j].y = imag[j];
- }
- }
- free(real);
- free(imag);
-
- free(real2);
- free(imag2);
-
- /* converting from double to byte, there is a HUGE loss in the dynamics
- "nn" tries to keep an acceptable SNR, but 8bit=48dB: don't ask more */
- double nn=pow((double)2,(double)log((double)max(w,h))/(double)log((double)2)-4);
- //reversed gain for reversed transform
- if (direction==-1) nn=1/nn;
- //bMagnitude : just to see it on the screen
- if (bMagnitude) nn*=4;
-
- for (j=0;j<h;j++) {
- for (k=0;k<w;k++) {
- if (bMagnitude){
- tmpReal->SetPixelIndex(k,j,(uint8_t)max(0,min(255,(nn*(3+log(_cabs(grid[k][j])))))));
- if (grid[k][j].x==0){
- tmpImag->SetPixelIndex(k,j,(uint8_t)max(0,min(255,(128+(atan(grid[k][j].y/0.0000000001)*nn)))));
- } else {
- tmpImag->SetPixelIndex(k,j,(uint8_t)max(0,min(255,(128+(atan(grid[k][j].y/grid[k][j].x)*nn)))));
- }
- } else {
- tmpReal->SetPixelIndex(k,j,(uint8_t)max(0,min(255,(128 + grid[k][j].x*nn))));
- tmpImag->SetPixelIndex(k,j,(uint8_t)max(0,min(255,(128 + grid[k][j].y*nn))));
- }
- }
- }
-
- for (k=0;k<w;k++) free (grid[k]);
- free (grid);
-
- if (srcReal==0 && dstReal==0) delete tmpReal;
- if (srcImag==0 && dstImag==0) delete tmpImag;
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::IsPowerof2(int32_t x)
-{
- int32_t i=0;
- while ((1<<i)<x) i++;
- if (x==(1<<i)) return true;
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- This computes an in-place complex-to-complex FFT
- x and y are the real and imaginary arrays of n=2^m points.
- o(n)=n*log2(n)
- dir = 1 gives forward transform
- dir = -1 gives reverse transform
- Written by Paul Bourke, July 1998
- FFT algorithm by Cooley and Tukey, 1965
-*/
-bool CxImage::FFT(int32_t dir,int32_t m,double *x,double *y)
-{
- int32_t nn,i,i1,j,k,i2,l,l1,l2;
- double c1,c2,tx,ty,t1,t2,u1,u2,z;
-
- /* Calculate the number of points */
- nn = 1<<m;
-
- /* Do the bit reversal */
- i2 = nn >> 1;
- j = 0;
- for (i=0;i<nn-1;i++) {
- if (i < j) {
- tx = x[i];
- ty = y[i];
- x[i] = x[j];
- y[i] = y[j];
- x[j] = tx;
- y[j] = ty;
- }
- k = i2;
- while (k <= j) {
- j -= k;
- k >>= 1;
- }
- j += k;
- }
-
- /* Compute the FFT */
- c1 = -1.0;
- c2 = 0.0;
- l2 = 1;
- for (l=0;l<m;l++) {
- l1 = l2;
- l2 <<= 1;
- u1 = 1.0;
- u2 = 0.0;
- for (j=0;j<l1;j++) {
- for (i=j;i<nn;i+=l2) {
- i1 = i + l1;
- t1 = u1 * x[i1] - u2 * y[i1];
- t2 = u1 * y[i1] + u2 * x[i1];
- x[i1] = x[i] - t1;
- y[i1] = y[i] - t2;
- x[i] += t1;
- y[i] += t2;
- }
- z = u1 * c1 - u2 * c2;
- u2 = u1 * c2 + u2 * c1;
- u1 = z;
- }
- c2 = sqrt((1.0 - c1) / 2.0);
- if (dir == 1)
- c2 = -c2;
- c1 = sqrt((1.0 + c1) / 2.0);
- }
-
- /* Scaling for forward transform */
- if (dir == 1) {
- for (i=0;i<nn;i++) {
- x[i] /= (double)nn;
- y[i] /= (double)nn;
- }
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- Direct fourier transform o(n)=n^2
- Written by Paul Bourke, July 1998
-*/
-bool CxImage::DFT(int32_t dir,int32_t m,double *x1,double *y1,double *x2,double *y2)
-{
- int32_t i,k;
- double arg;
- double cosarg,sinarg;
-
- for (i=0;i<m;i++) {
- x2[i] = 0;
- y2[i] = 0;
- arg = - dir * 2.0 * PI * i / (double)m;
- for (k=0;k<m;k++) {
- cosarg = cos(k * arg);
- sinarg = sin(k * arg);
- x2[i] += (x1[k] * cosarg - y1[k] * sinarg);
- y2[i] += (x1[k] * sinarg + y1[k] * cosarg);
- }
- }
-
- /* Copy the data back */
- if (dir == 1) {
- for (i=0;i<m;i++) {
- x1[i] = x2[i] / m;
- y1[i] = y2[i] / m;
- }
- } else {
- for (i=0;i<m;i++) {
- x1[i] = x2[i];
- y1[i] = y2[i];
- }
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Combines different color components into a single image
- * \param r,g,b: color channels
- * \param a: alpha layer, can be NULL
- * \param colorspace: 0 = RGB, 1 = HSL, 2 = YUV, 3 = YIQ, 4 = XYZ
- * \return true if everything is ok
- */
-bool CxImage::Combine(CxImage* r,CxImage* g,CxImage* b,CxImage* a, int32_t colorspace)
-{
- if (r==0 || g==0 || b==0) return false;
-
- int32_t w = r->GetWidth();
- int32_t h = r->GetHeight();
-
- Create(w,h,24);
-
- g->Resample(w,h);
- b->Resample(w,h);
-
- if (a) {
- a->Resample(w,h);
-#if CXIMAGE_SUPPORT_ALPHA
- AlphaCreate();
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
-
- RGBQUAD c;
- for (int32_t y=0;y<h;y++){
- info.nProgress = (int32_t)(100*y/h); //<Anatoly Ivasyuk>
- for (int32_t x=0;x<w;x++){
- c.rgbRed=r->GetPixelIndex(x,y);
- c.rgbGreen=g->GetPixelIndex(x,y);
- c.rgbBlue=b->GetPixelIndex(x,y);
- switch (colorspace){
- case 1:
- BlindSetPixelColor(x,y,HSLtoRGB(c));
- break;
- case 2:
- BlindSetPixelColor(x,y,YUVtoRGB(c));
- break;
- case 3:
- BlindSetPixelColor(x,y,YIQtoRGB(c));
- break;
- case 4:
- BlindSetPixelColor(x,y,XYZtoRGB(c));
- break;
- default:
- BlindSetPixelColor(x,y,c);
- }
-#if CXIMAGE_SUPPORT_ALPHA
- if (a) AlphaSet(x,y,a->GetPixelIndex(x,y));
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Smart blurring to remove small defects, dithering or artifacts.
- * \param radius: normally between 0.01 and 0.5
- * \param niterations: should be trimmed with radius, to avoid blurring should be (radius*niterations)<1
- * \param colorspace: 0 = RGB, 1 = HSL, 2 = YUV, 3 = YIQ, 4 = XYZ
- * \return true if everything is ok
- */
-bool CxImage::Repair(float radius, int32_t niterations, int32_t colorspace)
-{
- if (!IsValid()) return false;
-
- int32_t w = GetWidth();
- int32_t h = GetHeight();
-
- CxImage r,g,b;
-
- r.Create(w,h,8);
- g.Create(w,h,8);
- b.Create(w,h,8);
-
- switch (colorspace){
- case 1:
- SplitHSL(&r,&g,&b);
- break;
- case 2:
- SplitYUV(&r,&g,&b);
- break;
- case 3:
- SplitYIQ(&r,&g,&b);
- break;
- case 4:
- SplitXYZ(&r,&g,&b);
- break;
- default:
- SplitRGB(&r,&g,&b);
- }
-
- for (int32_t i=0; i<niterations; i++){
- RepairChannel(&r,radius);
- RepairChannel(&g,radius);
- RepairChannel(&b,radius);
- }
-
- CxImage* a=NULL;
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()){
- a = new CxImage();
- AlphaSplit(a);
- }
-#endif
-
- Combine(&r,&g,&b,a,colorspace);
-
- delete a;
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::RepairChannel(CxImage *ch, float radius)
-{
- if (ch==NULL) return false;
-
- CxImage tmp(*ch);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- int32_t w = ch->GetWidth()-1;
- int32_t h = ch->GetHeight()-1;
-
- double correction,ix,iy,ixx,ixy,iyy;
- int32_t x,y,xy0,xp1,xm1,yp1,ym1;
-
- for(x=1; x<w; x++){
- for(y=1; y<h; y++){
-
- xy0 = ch->BlindGetPixelIndex(x,y);
- xm1 = ch->BlindGetPixelIndex(x-1,y);
- xp1 = ch->BlindGetPixelIndex(x+1,y);
- ym1 = ch->BlindGetPixelIndex(x,y-1);
- yp1 = ch->BlindGetPixelIndex(x,y+1);
-
- ix= (xp1-xm1)/2.0;
- iy= (yp1-ym1)/2.0;
- ixx= xp1 - 2.0 * xy0 + xm1;
- iyy= yp1 - 2.0 * xy0 + ym1;
- ixy=(ch->BlindGetPixelIndex(x+1,y+1) + ch->BlindGetPixelIndex(x-1,y-1) -
- ch->BlindGetPixelIndex(x-1,y+1) - ch->BlindGetPixelIndex(x+1,y-1))/4.0;
-
- correction = ((1.0+iy*iy)*ixx - ix*iy*ixy + (1.0+ix*ix)*iyy)/(1.0+ix*ix+iy*iy);
-
- tmp.BlindSetPixelIndex(x,y,(uint8_t)min(255,max(0,(xy0 + radius * correction + 0.5))));
- }
- }
-
- for (x=0;x<=w;x++){
- for(y=0; y<=h; y+=h){
- xy0 = ch->BlindGetPixelIndex(x,y);
- xm1 = ch->GetPixelIndex(x-1,y);
- xp1 = ch->GetPixelIndex(x+1,y);
- ym1 = ch->GetPixelIndex(x,y-1);
- yp1 = ch->GetPixelIndex(x,y+1);
-
- ix= (xp1-xm1)/2.0;
- iy= (yp1-ym1)/2.0;
- ixx= xp1 - 2.0 * xy0 + xm1;
- iyy= yp1 - 2.0 * xy0 + ym1;
- ixy=(ch->GetPixelIndex(x+1,y+1) + ch->GetPixelIndex(x-1,y-1) -
- ch->GetPixelIndex(x-1,y+1) - ch->GetPixelIndex(x+1,y-1))/4.0;
-
- correction = ((1.0+iy*iy)*ixx - ix*iy*ixy + (1.0+ix*ix)*iyy)/(1.0+ix*ix+iy*iy);
-
- tmp.BlindSetPixelIndex(x,y,(uint8_t)min(255,max(0,(xy0 + radius * correction + 0.5))));
- }
- }
- for (x=0;x<=w;x+=w){
- for (y=0;y<=h;y++){
- xy0 = ch->BlindGetPixelIndex(x,y);
- xm1 = ch->GetPixelIndex(x-1,y);
- xp1 = ch->GetPixelIndex(x+1,y);
- ym1 = ch->GetPixelIndex(x,y-1);
- yp1 = ch->GetPixelIndex(x,y+1);
-
- ix= (xp1-xm1)/2.0;
- iy= (yp1-ym1)/2.0;
- ixx= xp1 - 2.0 * xy0 + xm1;
- iyy= yp1 - 2.0 * xy0 + ym1;
- ixy=(ch->GetPixelIndex(x+1,y+1) + ch->GetPixelIndex(x-1,y-1) -
- ch->GetPixelIndex(x-1,y+1) - ch->GetPixelIndex(x+1,y-1))/4.0;
-
- correction = ((1.0+iy*iy)*ixx - ix*iy*ixy + (1.0+ix*ix)*iyy)/(1.0+ix*ix+iy*iy);
-
- tmp.BlindSetPixelIndex(x,y,(uint8_t)min(255,max(0,(xy0 + radius * correction + 0.5))));
- }
- }
-
- ch->Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Enhance the variations between adjacent pixels.
- * Similar results can be achieved using Filter(),
- * but the algorithms are different both in Edge() and in Contour().
- * \return true if everything is ok
- */
-bool CxImage::Contour()
-{
- if (!pDib) return false;
-
- int32_t Ksize = 3;
- int32_t k2 = Ksize/2;
- int32_t kmax= Ksize-k2;
- int32_t i,j,k;
- uint8_t maxr,maxg,maxb;
- RGBQUAD pix1,pix2;
-
- CxImage tmp(*this);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- pix1 = BlindGetPixelColor(x,y);
- maxr=maxg=maxb=0;
- for(j=-k2, i=0;j<kmax;j++){
- for(k=-k2;k<kmax;k++, i++){
- if (!IsInside(x+j,y+k)) continue;
- pix2 = BlindGetPixelColor(x+j,y+k);
- if ((pix2.rgbBlue-pix1.rgbBlue)>maxb) maxb = pix2.rgbBlue;
- if ((pix2.rgbGreen-pix1.rgbGreen)>maxg) maxg = pix2.rgbGreen;
- if ((pix2.rgbRed-pix1.rgbRed)>maxr) maxr = pix2.rgbRed;
- }
- }
- pix1.rgbBlue=(uint8_t)(255-maxb);
- pix1.rgbGreen=(uint8_t)(255-maxg);
- pix1.rgbRed=(uint8_t)(255-maxr);
- tmp.BlindSetPixelColor(x,y,pix1);
- }
- }
- }
- Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Adds a random offset to each pixel in the image
- * \param radius: maximum pixel displacement
- * \return true if everything is ok
- */
-bool CxImage::Jitter(int32_t radius)
-{
- if (!pDib) return false;
-
- int32_t nx,ny;
-
- CxImage tmp(*this);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- nx=x+(int32_t)((rand()/(float)RAND_MAX - 0.5)*(radius*2));
- ny=y+(int32_t)((rand()/(float)RAND_MAX - 0.5)*(radius*2));
- if (!IsInside(nx,ny)) {
- nx=x;
- ny=y;
- }
- if (head.biClrUsed==0){
- tmp.BlindSetPixelColor(x,y,BlindGetPixelColor(nx,ny));
- } else {
- tmp.BlindSetPixelIndex(x,y,BlindGetPixelIndex(nx,ny));
- }
-#if CXIMAGE_SUPPORT_ALPHA
- tmp.AlphaSet(x,y,AlphaGet(nx,ny));
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- }
- }
- Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * generates a 1-D convolution matrix to be used for each pass of
- * a two-pass gaussian blur. Returns the length of the matrix.
- * \author [nipper]
- */
-int32_t CxImage::gen_convolve_matrix (float radius, float **cmatrix_p)
-{
- int32_t matrix_length;
- int32_t matrix_midpoint;
- float* cmatrix;
- int32_t i,j;
- float std_dev;
- float sum;
-
- /* we want to generate a matrix that goes out a certain radius
- * from the center, so we have to go out ceil(rad-0.5) pixels,
- * inlcuding the center pixel. Of course, that's only in one direction,
- * so we have to go the same amount in the other direction, but not count
- * the center pixel again. So we double the previous result and subtract
- * one.
- * The radius parameter that is passed to this function is used as
- * the standard deviation, and the radius of effect is the
- * standard deviation * 2. It's a little confusing.
- * <DP> modified scaling, so that matrix_lenght = 1+2*radius parameter
- */
- radius = (float)fabs(0.5*radius) + 0.25f;
-
- std_dev = radius;
- radius = std_dev * 2;
-
- /* go out 'radius' in each direction */
- matrix_length = int32_t (2 * ceil(radius-0.5) + 1);
- if (matrix_length <= 0) matrix_length = 1;
- matrix_midpoint = matrix_length/2 + 1;
- *cmatrix_p = new float[matrix_length];
- cmatrix = *cmatrix_p;
-
- /* Now we fill the matrix by doing a numeric integration approximation
- * from -2*std_dev to 2*std_dev, sampling 50 points per pixel.
- * We do the bottom half, mirror it to the top half, then compute the
- * center point. Otherwise asymmetric quantization errors will occur.
- * The formula to integrate is e^-(x^2/2s^2).
- */
-
- /* first we do the top (right) half of matrix */
- for (i = matrix_length/2 + 1; i < matrix_length; i++)
- {
- float base_x = i - (float)floor((float)(matrix_length/2)) - 0.5f;
- sum = 0;
- for (j = 1; j <= 50; j++)
- {
- if ( base_x+0.02*j <= radius )
- sum += (float)exp (-(base_x+0.02*j)*(base_x+0.02*j) /
- (2*std_dev*std_dev));
- }
- cmatrix[i] = sum/50;
- }
-
- /* mirror the thing to the bottom half */
- for (i=0; i<=matrix_length/2; i++) {
- cmatrix[i] = cmatrix[matrix_length-1-i];
- }
-
- /* find center val -- calculate an odd number of quanta to make it symmetric,
- * even if the center point is weighted slightly higher than others. */
- sum = 0;
- for (j=0; j<=50; j++)
- {
- sum += (float)exp (-(0.5+0.02*j)*(0.5+0.02*j) /
- (2*std_dev*std_dev));
- }
- cmatrix[matrix_length/2] = sum/51;
-
- /* normalize the distribution by scaling the total sum to one */
- sum=0;
- for (i=0; i<matrix_length; i++) sum += cmatrix[i];
- for (i=0; i<matrix_length; i++) cmatrix[i] = cmatrix[i] / sum;
-
- return matrix_length;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * generates a lookup table for every possible product of 0-255 and
- * each value in the convolution matrix. The returned array is
- * indexed first by matrix position, then by input multiplicand (?)
- * value.
- * \author [nipper]
- */
-float* CxImage::gen_lookup_table (float *cmatrix, int32_t cmatrix_length)
-{
- float* lookup_table = new float[cmatrix_length * 256];
- float* lookup_table_p = lookup_table;
- float* cmatrix_p = cmatrix;
-
- for (int32_t i=0; i<cmatrix_length; i++)
- {
- for (int32_t j=0; j<256; j++)
- {
- *(lookup_table_p++) = *cmatrix_p * (float)j;
- }
- cmatrix_p++;
- }
-
- return lookup_table;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * this function is written as if it is blurring a column at a time,
- * even though it can operate on rows, too. There is no difference
- * in the processing of the lines, at least to the blur_line function.
- * \author [nipper]
- */
-void CxImage::blur_line (float *ctable, float *cmatrix, int32_t cmatrix_length, uint8_t* cur_col, uint8_t* dest_col, int32_t y, int32_t bytes)
-{
- float scale;
- float sum;
- int32_t i=0, j=0;
- int32_t row;
- int32_t cmatrix_middle = cmatrix_length/2;
-
- float *cmatrix_p;
- uint8_t *cur_col_p;
- uint8_t *cur_col_p1;
- uint8_t *dest_col_p;
- float *ctable_p;
-
- /* this first block is the same as the non-optimized version --
- * it is only used for very small pictures, so speed isn't a
- * big concern.
- */
- if (cmatrix_length > y)
- {
- for (row = 0; row < y ; row++)
- {
- scale=0;
- /* find the scale factor */
- for (j = 0; j < y ; j++)
- {
- /* if the index is in bounds, add it to the scale counter */
- if ((j + cmatrix_middle - row >= 0) &&
- (j + cmatrix_middle - row < cmatrix_length))
- scale += cmatrix[j + cmatrix_middle - row];
- }
- for (i = 0; i<bytes; i++)
- {
- sum = 0;
- for (j = 0; j < y; j++)
- {
- if ((j >= row - cmatrix_middle) &&
- (j <= row + cmatrix_middle))
- sum += cur_col[j*bytes + i] * cmatrix[j];
- }
- dest_col[row*bytes + i] = (uint8_t)(0.5f + sum / scale);
- }
- }
- }
- else
- {
- /* for the edge condition, we only use available info and scale to one */
- for (row = 0; row < cmatrix_middle; row++)
- {
- /* find scale factor */
- scale=0;
- for (j = cmatrix_middle - row; j<cmatrix_length; j++)
- scale += cmatrix[j];
- for (i = 0; i<bytes; i++)
- {
- sum = 0;
- for (j = cmatrix_middle - row; j<cmatrix_length; j++)
- {
- sum += cur_col[(row + j-cmatrix_middle)*bytes + i] * cmatrix[j];
- }
- dest_col[row*bytes + i] = (uint8_t)(0.5f + sum / scale);
- }
- }
- /* go through each pixel in each col */
- dest_col_p = dest_col + row*bytes;
- for (; row < y-cmatrix_middle; row++)
- {
- cur_col_p = (row - cmatrix_middle) * bytes + cur_col;
- for (i = 0; i<bytes; i++)
- {
- sum = 0;
- cmatrix_p = cmatrix;
- cur_col_p1 = cur_col_p;
- ctable_p = ctable;
- for (j = cmatrix_length; j>0; j--)
- {
- sum += *(ctable_p + *cur_col_p1);
- cur_col_p1 += bytes;
- ctable_p += 256;
- }
- cur_col_p++;
- *(dest_col_p++) = (uint8_t)(0.5f + sum);
- }
- }
-
- /* for the edge condition , we only use available info, and scale to one */
- for (; row < y; row++)
- {
- /* find scale factor */
- scale=0;
- for (j = 0; j< y-row + cmatrix_middle; j++)
- scale += cmatrix[j];
- for (i = 0; i<bytes; i++)
- {
- sum = 0;
- for (j = 0; j<y-row + cmatrix_middle; j++)
- {
- sum += cur_col[(row + j-cmatrix_middle)*bytes + i] * cmatrix[j];
- }
- dest_col[row*bytes + i] = (uint8_t) (0.5f + sum / scale);
- }
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \author [DP]
- */
-void CxImage::blur_text (uint8_t threshold, uint8_t decay, uint8_t max_depth, CxImage* iSrc, CxImage* iDst, uint8_t bytes)
-{
- int32_t x,y,z,m;
- uint8_t *pSrc, *pSrc2, *pSrc3, *pDst;
- uint8_t step,n;
- int32_t pivot;
-
- if (max_depth<1) max_depth = 1;
-
- int32_t nmin,nmax,xmin,xmax,ymin,ymax;
- xmin = ymin = 0;
- xmax = iSrc->head.biWidth;
- ymax = iSrc->head.biHeight;
-
- if (xmin==xmax || ymin==ymax) return;
-
- nmin = xmin * bytes;
- nmax = xmax * bytes;
-
- CImageIterator itSrc(iSrc);
- CImageIterator itTmp(iDst);
-
- double dbScaler = 100.0f/(ymax-ymin)/bytes;
-
- for (n=0; n<bytes; n++){
- for (y=ymin+1;y<(ymax-1);y++)
- {
- if (info.nEscape) break;
- info.nProgress = (int32_t)((y-ymin)*dbScaler*(1+n));
-
- pSrc = itSrc.GetRow(y);
- pSrc2 = itSrc.GetRow(y+1);
- pSrc3 = itSrc.GetRow(y-1);
- pDst = itTmp.GetRow(y);
-
- //scan left to right
- for (x=n+nmin /*,i=xmin*/; x<(nmax-1); x+=bytes /*,i++*/)
- {
- z=x+bytes;
- pivot = pSrc[z]-threshold;
- //find upper corner
- if (pSrc[x]<pivot && pSrc2[z]<pivot && pSrc3[x]>=pivot){
- while (z<nmax && pSrc2[z]<pSrc[x+bytes] && pSrc[x+bytes]<=pSrc[z]){
- z+=bytes;
- }
- m = z-x;
- m = (decay>1) ? ((m/bytes)/decay+1) : m/bytes;
- if (m>max_depth) m = max_depth;
- step = (uint8_t)((pSrc[x+bytes]-pSrc[x])/(m+1));
- while (m-->1){
- pDst[x+m*bytes] = (uint8_t)(pDst[x]+(step*(m+1)));
- }
- }
- //find lower corner
- z=x+bytes;
- if (pSrc[x]<pivot && pSrc3[z]<pivot && pSrc2[x]>=pivot){
- while (z<nmax && pSrc3[z]<pSrc[x+bytes] && pSrc[x+bytes]<=pSrc[z]){
- z+=bytes;
- }
- m = z-x;
- m = (decay>1) ? ((m/bytes)/decay+1) : m/bytes;
- if (m>max_depth) m = max_depth;
- step = (uint8_t)((pSrc[x+bytes]-pSrc[x])/(m+1));
- while (m-->1){
- pDst[x+m*bytes] = (uint8_t)(pDst[x]+(step*(m+1)));
- }
- }
- }
- //scan right to left
- for (x=nmax-1-n /*,i=(xmax-1)*/; x>0; x-=bytes /*,i--*/)
- {
- z=x-bytes;
- pivot = pSrc[z]-threshold;
- //find upper corner
- if (pSrc[x]<pivot && pSrc2[z]<pivot && pSrc3[x]>=pivot){
- while (z>n && pSrc2[z]<pSrc[x-bytes] && pSrc[x-bytes]<=pSrc[z]){
- z-=bytes;
- }
- m = x-z;
- m = (decay>1) ? ((m/bytes)/decay+1) : m/bytes;
- if (m>max_depth) m = max_depth;
- step = (uint8_t)((pSrc[x-bytes]-pSrc[x])/(m+1));
- while (m-->1){
- pDst[x-m*bytes] = (uint8_t)(pDst[x]+(step*(m+1)));
- }
- }
- //find lower corner
- z=x-bytes;
- if (pSrc[x]<pivot && pSrc3[z]<pivot && pSrc2[x]>=pivot){
- while (z>n && pSrc3[z]<pSrc[x-bytes] && pSrc[x-bytes]<=pSrc[z]){
- z-=bytes;
- }
- m = x-z;
- m = (decay>1) ? ((m/bytes)/decay+1) : m/bytes;
- if (m>max_depth) m = max_depth;
- step = (uint8_t)((pSrc[x-bytes]-pSrc[x])/(m+1));
- while (m-->1){
- pDst[x-m*bytes] = (uint8_t)(pDst[x]+(step*(m+1)));
- }
- }
- }
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \author [DP]
- */
-bool CxImage::TextBlur(uint8_t threshold, uint8_t decay, uint8_t max_depth, bool bBlurHorizontal, bool bBlurVertical, CxImage* iDst)
-{
- if (!pDib) return false;
-
- RGBQUAD* pPalette=NULL;
- uint16_t bpp = GetBpp();
-
- //the routine is optimized for RGB or GrayScale images
- if (!(head.biBitCount == 24 || IsGrayScale())){
- pPalette = new RGBQUAD[head.biClrUsed];
- memcpy(pPalette, GetPalette(),GetPaletteSize());
- if (!IncreaseBpp(24))
- return false;
- }
-
- CxImage tmp(*this);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- if (bBlurHorizontal)
- blur_text(threshold, decay, max_depth, this, &tmp, head.biBitCount>>3);
-
- if (bBlurVertical){
- CxImage src2(*this);
- src2.RotateLeft();
- tmp.RotateLeft();
- blur_text(threshold, decay, max_depth, &src2, &tmp, head.biBitCount>>3);
- tmp.RotateRight();
- }
-
-#if CXIMAGE_SUPPORT_SELECTION
- //restore the non selected region
- if (pSelection){
- for(int32_t y=0; y<head.biHeight; y++){
- for(int32_t x=0; x<head.biWidth; x++){
- if (!BlindSelectionIsInside(x,y)){
- tmp.BlindSetPixelColor(x,y,BlindGetPixelColor(x,y));
- }
- }
- }
- }
-#endif //CXIMAGE_SUPPORT_SELECTION
-
- //if necessary, restore the original BPP and palette
- if (pPalette){
- tmp.DecreaseBpp(bpp, true, pPalette);
- delete [] pPalette;
- }
-
- if (iDst) iDst->Transfer(tmp);
- else Transfer(tmp);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \author [nipper]; changes [DP]
- */
-bool CxImage::GaussianBlur(float radius /*= 1.0f*/, CxImage* iDst /*= 0*/)
-{
- if (!pDib) return false;
-
- RGBQUAD* pPalette=NULL;
- uint16_t bpp = GetBpp();
-
- //the routine is optimized for RGB or GrayScale images
- if (!(head.biBitCount == 24 || IsGrayScale())){
- pPalette = new RGBQUAD[head.biClrUsed];
- memcpy(pPalette, GetPalette(),GetPaletteSize());
- if (!IncreaseBpp(24))
- return false;
- }
-
- CxImage tmp_x(*this, false, true, true);
- if (!tmp_x.IsValid()){
- strcpy(info.szLastError,tmp_x.GetLastError());
- return false;
- }
-
- // generate convolution matrix and make sure it's smaller than each dimension
- float *cmatrix = NULL;
- int32_t cmatrix_length = gen_convolve_matrix(radius, &cmatrix);
- // generate lookup table
- float *ctable = gen_lookup_table(cmatrix, cmatrix_length);
-
- int32_t x,y;
- int32_t bypp = head.biBitCount>>3;
-
- CImageIterator itSrc(this);
- CImageIterator itTmp(&tmp_x);
-
- double dbScaler = 50.0f/head.biHeight;
-
- // blur the rows
- for (y=0;y<head.biHeight;y++)
- {
- if (info.nEscape) break;
- info.nProgress = (int32_t)(y*dbScaler);
-
- blur_line(ctable, cmatrix, cmatrix_length, itSrc.GetRow(y), itTmp.GetRow(y), head.biWidth, bypp);
- }
-
- CxImage tmp_y(tmp_x, false, true, true);
- if (!tmp_y.IsValid()){
- strcpy(info.szLastError,tmp_y.GetLastError());
- return false;
- }
-
- CImageIterator itDst(&tmp_y);
-
- // blur the cols
- uint8_t* cur_col = (uint8_t*)malloc(bypp*head.biHeight);
- uint8_t* dest_col = (uint8_t*)malloc(bypp*head.biHeight);
-
- dbScaler = 50.0f/head.biWidth;
-
- for (x=0;x<head.biWidth;x++)
- {
- if (info.nEscape) break;
- info.nProgress = (int32_t)(50.0f+x*dbScaler);
-
- itTmp.GetCol(cur_col, x);
- itDst.GetCol(dest_col, x);
- blur_line(ctable, cmatrix, cmatrix_length, cur_col, dest_col, head.biHeight, bypp);
- itDst.SetCol(dest_col, x);
- }
-
- free(cur_col);
- free(dest_col);
-
- delete [] cmatrix;
- delete [] ctable;
-
-#if CXIMAGE_SUPPORT_SELECTION
- //restore the non selected region
- if (pSelection){
- for(y=0; y<head.biHeight; y++){
- for(x=0; x<head.biWidth; x++){
- if (!BlindSelectionIsInside(x,y)){
- tmp_y.BlindSetPixelColor(x,y,BlindGetPixelColor(x,y));
- }
- }
- }
- }
-#endif //CXIMAGE_SUPPORT_SELECTION
-
- //if necessary, restore the original BPP and palette
- if (pPalette){
- tmp_y.DecreaseBpp(bpp, false, pPalette);
- if (iDst) DecreaseBpp(bpp, false, pPalette);
- delete [] pPalette;
- }
-
- if (iDst) iDst->Transfer(tmp_y);
- else Transfer(tmp_y);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \author [DP],[nipper]
- */
-bool CxImage::SelectiveBlur(float radius, uint8_t threshold, CxImage* iDst)
-{
- if (!pDib) return false;
-
- RGBQUAD* pPalette=NULL;
- uint16_t bpp = GetBpp();
-
- CxImage Tmp(*this, true, true, true);
- if (!Tmp.IsValid()){
- strcpy(info.szLastError,Tmp.GetLastError());
- return false;
- }
-
- //the routine is optimized for RGB or GrayScale images
- if (!(head.biBitCount == 24 || IsGrayScale())){
- pPalette = new RGBQUAD[head.biClrUsed];
- memcpy(pPalette, GetPalette(),GetPaletteSize());
- if (!Tmp.IncreaseBpp(24)){
- delete [] pPalette;
- return false;
- }
- }
-
- CxImage Dst(Tmp, true, true, true);
- if (!Dst.IsValid()){
- strcpy(info.szLastError,Dst.GetLastError());
- delete [] pPalette;
- return false;
- }
-
- //build the difference mask
- uint8_t thresh_dw = (uint8_t)max( 0 ,(int32_t)(128 - threshold));
- uint8_t thresh_up = (uint8_t)min(255,(int32_t)(128 + threshold));
- int32_t kernel[]={-100,-100,-100,-100,801,-100,-100,-100,-100};
- if (!Tmp.Filter(kernel,3,800,128)){
- strcpy(info.szLastError,Tmp.GetLastError());
- delete [] pPalette;
- return false;
- }
-
- //if the image has no selection, build a selection for the whole image
-#if CXIMAGE_SUPPORT_SELECTION
- if (!Tmp.SelectionIsValid()){
- Tmp.SelectionCreate();
- Tmp.SelectionClear(255);
- }
-
- int32_t xmin,xmax,ymin,ymax;
- xmin = Tmp.info.rSelectionBox.left;
- xmax = Tmp.info.rSelectionBox.right;
- ymin = Tmp.info.rSelectionBox.bottom;
- ymax = Tmp.info.rSelectionBox.top;
-
- //modify the selection where the difference mask is over the threshold
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
- if(Tmp.BlindSelectionIsInside(x,y)){
- RGBQUAD c = Tmp.BlindGetPixelColor(x,y);
- if ((c.rgbRed < thresh_dw || c.rgbRed > thresh_up) ||
- (c.rgbGreen < thresh_dw || c.rgbGreen > thresh_up) ||
- (c.rgbBlue < thresh_dw || c.rgbBlue > thresh_up))
- {
- Tmp.SelectionSet(x,y,0);
- }
- }
- }
- }
-
- //blur the image (only in the selected pixels)
- Dst.SelectionCopy(Tmp);
- if (!Dst.GaussianBlur(radius)){
- strcpy(info.szLastError,Dst.GetLastError());
- delete [] pPalette;
- return false;
- }
-
- //restore the original selection
- Dst.SelectionCopy(*this);
-#endif //CXIMAGE_SUPPORT_SELECTION
-
- //if necessary, restore the original BPP and palette
- if (pPalette){
- Dst.DecreaseBpp(bpp, false, pPalette);
- delete [] pPalette;
- }
-
- if (iDst) iDst->Transfer(Dst);
- else Transfer(Dst);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * sharpen the image by subtracting a blurred copy from the original image.
- * \param radius: width in pixels of the blurring effect. Range: >0; default = 5.
- * \param amount: strength of the filter. Range: 0.0 (none) to 1.0 (max); default = 0.5
- * \param threshold: difference, between blurred and original pixel, to trigger the filter
- * Range: 0 (always triggered) to 255 (never triggered); default = 0.
- * \return true if everything is ok
- * \author [nipper]; changes [DP]
- */
-bool CxImage::UnsharpMask(float radius /*= 5.0*/, float amount /*= 0.5*/, int32_t threshold /*= 0*/)
-{
- if (!pDib) return false;
-
- RGBQUAD* pPalette=NULL;
- uint16_t bpp = GetBpp();
-
- //the routine is optimized for RGB or GrayScale images
- if (!(head.biBitCount == 24 || IsGrayScale())){
- pPalette = new RGBQUAD[head.biClrUsed];
- memcpy(pPalette, GetPalette(),GetPaletteSize());
- if (!IncreaseBpp(24))
- return false;
- }
-
- CxImage iDst;
- if (!GaussianBlur(radius,&iDst))
- return false;
-
- CImageIterator itSrc(this);
- CImageIterator itDst(&iDst);
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- if (xmin==xmax || ymin==ymax)
- return false;
-
- double dbScaler = 100.0/(ymax-ymin);
- int32_t bypp = head.biBitCount>>3;
-
- // merge the source and destination (which currently contains
- // the blurred version) images
- for (int32_t y=ymin; y<ymax; y++)
- {
- if (info.nEscape) break;
- info.nProgress = (int32_t)((y-ymin)*dbScaler);
-
- // get source row
- uint8_t* cur_row = itSrc.GetRow(y);
- // get dest row
- uint8_t* dest_row = itDst.GetRow(y);
- // combine the two
- for (int32_t x=xmin; x<xmax; x++) {
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- for (int32_t b=0, z=x*bypp; b<bypp; b++, z++){
- int32_t diff = cur_row[z] - dest_row[z];
-
- // do tresholding
- if (abs(diff) < threshold){
- dest_row[z] = cur_row[z];
- } else {
- dest_row[z] = (uint8_t)min(255, max(0,(int32_t)(cur_row[z] + amount * diff)));
- }
- }
- }
- }
- }
-
- //if necessary, restore the original BPP and palette
- if (pPalette){
- iDst.DecreaseBpp(bpp, false, pPalette);
- delete [] pPalette;
- }
-
- Transfer(iDst);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Apply a look up table to the image.
- * \param pLut: uint8_t[256] look up table
- * \return true if everything is ok
- */
-bool CxImage::Lut(uint8_t* pLut)
-{
- if (!pDib || !pLut) return false;
- RGBQUAD color;
-
- double dbScaler;
- if (head.biClrUsed==0){
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- // faster loop for full image
- uint8_t *iSrc=info.pImage;
- for(uint32_t i=0; i < head.biSizeImage ; i++){
- *iSrc++ = pLut[*iSrc];
- }
- return true;
- }
-
- if (xmin==xmax || ymin==ymax)
- return false;
-
- dbScaler = 100.0/(ymax-ymin);
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)((y-ymin)*dbScaler); //<Anatoly Ivasyuk>
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- color = BlindGetPixelColor(x,y);
- color.rgbRed = pLut[color.rgbRed];
- color.rgbGreen = pLut[color.rgbGreen];
- color.rgbBlue = pLut[color.rgbBlue];
- BlindSetPixelColor(x,y,color);
- }
- }
- }
-#if CXIMAGE_SUPPORT_SELECTION
- } else if (pSelection && (head.biBitCount==8) && IsGrayScale()){
- int32_t xmin,xmax,ymin,ymax;
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
-
- if (xmin==xmax || ymin==ymax)
- return false;
-
- dbScaler = 100.0/(ymax-ymin);
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)((y-ymin)*dbScaler);
- for(int32_t x=xmin; x<xmax; x++){
- if (BlindSelectionIsInside(x,y))
- {
- BlindSetPixelIndex(x,y,pLut[BlindGetPixelIndex(x,y)]);
- }
- }
- }
-#endif //CXIMAGE_SUPPORT_SELECTION
- } else {
- bool bIsGrayScale = IsGrayScale();
- for(uint32_t j=0; j<head.biClrUsed; j++){
- color = GetPaletteColor((uint8_t)j);
- color.rgbRed = pLut[color.rgbRed];
- color.rgbGreen = pLut[color.rgbGreen];
- color.rgbBlue = pLut[color.rgbBlue];
- SetPaletteColor((uint8_t)j,color);
- }
- if (bIsGrayScale) GrayScale();
- }
- return true;
-
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Apply an indipendent look up table for each channel
- * \param pLutR, pLutG, pLutB, pLutA: uint8_t[256] look up tables
- * \return true if everything is ok
- */
-bool CxImage::Lut(uint8_t* pLutR, uint8_t* pLutG, uint8_t* pLutB, uint8_t* pLutA)
-{
- if (!pDib || !pLutR || !pLutG || !pLutB) return false;
- RGBQUAD color;
-
- double dbScaler;
- if (head.biClrUsed==0){
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- if (xmin==xmax || ymin==ymax)
- return false;
-
- dbScaler = 100.0/(ymax-ymin);
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)((y-ymin)*dbScaler);
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- color = BlindGetPixelColor(x,y);
- color.rgbRed = pLutR[color.rgbRed];
- color.rgbGreen = pLutG[color.rgbGreen];
- color.rgbBlue = pLutB[color.rgbBlue];
- if (pLutA) color.rgbReserved=pLutA[color.rgbReserved];
- BlindSetPixelColor(x,y,color,true);
- }
- }
- }
- } else {
- bool bIsGrayScale = IsGrayScale();
- for(uint32_t j=0; j<head.biClrUsed; j++){
- color = GetPaletteColor((uint8_t)j);
- color.rgbRed = pLutR[color.rgbRed];
- color.rgbGreen = pLutG[color.rgbGreen];
- color.rgbBlue = pLutB[color.rgbBlue];
- SetPaletteColor((uint8_t)j,color);
- }
- if (bIsGrayScale) GrayScale();
- }
-
- return true;
-
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Use the RedEyeRemove function to remove the red-eye effect that frequently
- * occurs in photographs of humans and animals. You must select the region
- * where the function will filter the red channel.
- * \param strength: range from 0.0f (no effect) to 1.0f (full effect). Default = 0.8
- * \return true if everything is ok
- */
-bool CxImage::RedEyeRemove(float strength)
-{
- if (!pDib) return false;
- RGBQUAD color;
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- if (xmin==xmax || ymin==ymax)
- return false;
-
- if (strength<0.0f) strength = 0.0f;
- if (strength>1.0f) strength = 1.0f;
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- float a = 1.0f-5.0f*((float)((x-0.5f*(xmax+xmin))*(x-0.5f*(xmax+xmin))+(y-0.5f*(ymax+ymin))*(y-0.5f*(ymax+ymin))))/((float)((xmax-xmin)*(ymax-ymin)));
- if (a<0) a=0;
- color = BlindGetPixelColor(x,y);
- color.rgbRed = (uint8_t)(a*min(color.rgbGreen,color.rgbBlue)+(1.0f-a)*color.rgbRed);
- BlindSetPixelColor(x,y,color);
- }
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Changes the saturation of the image.
- * \param saturation: can be from -100 to 100, positive values increase the saturation.
- * \param colorspace: can be 1 (HSL) or 2 (YUV).
- * \return true if everything is ok
- */
-bool CxImage::Saturate(const int32_t saturation, const int32_t colorspace)
-{
- if (!pDib)
- return false;
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- if (xmin==xmax || ymin==ymax)
- return false;
-
- uint8_t cTable[256];
-
- switch(colorspace)
- {
- case 1:
- {
- for (int32_t i=0;i<256;i++) {
- cTable[i] = (uint8_t)max(0,min(255,(int32_t)(i + saturation)));
- }
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- RGBQUAD c = RGBtoHSL(BlindGetPixelColor(x,y));
- c.rgbGreen = cTable[c.rgbGreen];
- c = HSLtoRGB(c);
- BlindSetPixelColor(x,y,c);
- }
- }
- }
- }
- break;
- case 2:
- {
- for (int32_t i=0;i<256;i++) {
- cTable[i] = (uint8_t)max(0,min(255,(int32_t)((i-128)*(100 + saturation)/100.0f + 128.5f)));
- }
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- RGBQUAD c = RGBtoYUV(BlindGetPixelColor(x,y));
- c.rgbGreen = cTable[c.rgbGreen];
- c.rgbBlue = cTable[c.rgbBlue];
- c = YUVtoRGB(c);
- BlindSetPixelColor(x,y,c);
- }
- }
- }
- }
- break;
- default:
- strcpy(info.szLastError,"Saturate: wrong colorspace");
- return false;
- }
- return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Solarize: convert all colors above a given lightness level into their negative
- * \param level : lightness threshold. Range = 0 to 255; default = 128.
- * \param bLinkedChannels: true = compare with luminance, preserve colors (default)
- * false = compare with independent R,G,B levels
- * \return true if everything is ok
- * \author [Priyank Bolia] (priyank_bolia(at)yahoo(dot)com); changes [DP]
- */
-bool CxImage::Solarize(uint8_t level, bool bLinkedChannels)
-{
- if (!pDib) return false;
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- if (head.biBitCount<=8){
- if (IsGrayScale()){ //GRAYSCALE, selection
- for(int32_t y=ymin; y<ymax; y++){
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- uint8_t index = BlindGetPixelIndex(x,y);
- RGBQUAD color = GetPaletteColor(index);
- if ((uint8_t)RGB2GRAY(color.rgbRed,color.rgbGreen,color.rgbBlue)>level){
- BlindSetPixelIndex(x,y,255-index);
- }
- }
- }
- }
- } else { //PALETTE, full image
- RGBQUAD* ppal=GetPalette();
- for(uint32_t i=0;i<head.biClrUsed;i++){
- RGBQUAD color = GetPaletteColor((uint8_t)i);
- if (bLinkedChannels){
- if ((uint8_t)RGB2GRAY(color.rgbRed,color.rgbGreen,color.rgbBlue)>level){
- ppal[i].rgbBlue =(uint8_t)(255-ppal[i].rgbBlue);
- ppal[i].rgbGreen =(uint8_t)(255-ppal[i].rgbGreen);
- ppal[i].rgbRed =(uint8_t)(255-ppal[i].rgbRed);
- }
- } else {
- if (color.rgbBlue>level) ppal[i].rgbBlue =(uint8_t)(255-ppal[i].rgbBlue);
- if (color.rgbGreen>level) ppal[i].rgbGreen =(uint8_t)(255-ppal[i].rgbGreen);
- if (color.rgbRed>level) ppal[i].rgbRed =(uint8_t)(255-ppal[i].rgbRed);
- }
- }
- }
- } else { //RGB, selection
- for(int32_t y=ymin; y<ymax; y++){
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- RGBQUAD color = BlindGetPixelColor(x,y);
- if (bLinkedChannels){
- if ((uint8_t)RGB2GRAY(color.rgbRed,color.rgbGreen,color.rgbBlue)>level){
- color.rgbRed = (uint8_t)(255-color.rgbRed);
- color.rgbGreen = (uint8_t)(255-color.rgbGreen);
- color.rgbBlue = (uint8_t)(255-color.rgbBlue);
- }
- } else {
- if (color.rgbBlue>level) color.rgbBlue =(uint8_t)(255-color.rgbBlue);
- if (color.rgbGreen>level) color.rgbGreen =(uint8_t)(255-color.rgbGreen);
- if (color.rgbRed>level) color.rgbRed =(uint8_t)(255-color.rgbRed);
- }
- BlindSetPixelColor(x,y,color);
- }
- }
- }
- }
-
- //invert transparent color only in case of full image processing
- if (pSelection==0 || (!IsGrayScale() && IsIndexed())){
- if (bLinkedChannels){
- if ((uint8_t)RGB2GRAY(info.nBkgndColor.rgbRed,info.nBkgndColor.rgbGreen,info.nBkgndColor.rgbBlue)>level){
- info.nBkgndColor.rgbBlue = (uint8_t)(255-info.nBkgndColor.rgbBlue);
- info.nBkgndColor.rgbGreen = (uint8_t)(255-info.nBkgndColor.rgbGreen);
- info.nBkgndColor.rgbRed = (uint8_t)(255-info.nBkgndColor.rgbRed);
- }
- } else {
- if (info.nBkgndColor.rgbBlue>level) info.nBkgndColor.rgbBlue = (uint8_t)(255-info.nBkgndColor.rgbBlue);
- if (info.nBkgndColor.rgbGreen>level) info.nBkgndColor.rgbGreen = (uint8_t)(255-info.nBkgndColor.rgbGreen);
- if (info.nBkgndColor.rgbRed>level) info.nBkgndColor.rgbRed = (uint8_t)(255-info.nBkgndColor.rgbRed);
- }
- }
-
- return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Converts the RGB triplets to and from different colorspace
- * \param dstColorSpace: destination colorspace; 0 = RGB, 1 = HSL, 2 = YUV, 3 = YIQ, 4 = XYZ
- * \param srcColorSpace: source colorspace; 0 = RGB, 1 = HSL, 2 = YUV, 3 = YIQ, 4 = XYZ
- * \return true if everything is ok
- */
-bool CxImage::ConvertColorSpace(const int32_t dstColorSpace, const int32_t srcColorSpace)
-{
- if (!pDib)
- return false;
-
- if (dstColorSpace == srcColorSpace)
- return true;
-
- int32_t w = GetWidth();
- int32_t h = GetHeight();
-
- for (int32_t y=0;y<h;y++){
- info.nProgress = (int32_t)(100*y/h);
- if (info.nEscape) break;
- for (int32_t x=0;x<w;x++){
- RGBQUAD c = BlindGetPixelColor(x,y);
- switch (srcColorSpace){
- case 0:
- break;
- case 1:
- c = HSLtoRGB(c);
- break;
- case 2:
- c = YUVtoRGB(c);
- break;
- case 3:
- c = YIQtoRGB(c);
- break;
- case 4:
- c = XYZtoRGB(c);
- break;
- default:
- strcpy(info.szLastError,"ConvertColorSpace: unknown source colorspace");
- return false;
- }
- switch (dstColorSpace){
- case 0:
- break;
- case 1:
- c = RGBtoHSL(c);
- break;
- case 2:
- c = RGBtoYUV(c);
- break;
- case 3:
- c = RGBtoYIQ(c);
- break;
- case 4:
- c = RGBtoXYZ(c);
- break;
- default:
- strcpy(info.szLastError,"ConvertColorSpace: unknown destination colorspace");
- return false;
- }
- BlindSetPixelColor(x,y,c);
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Finds the optimal (global or local) treshold for image binarization
- * \param method: 0 = average all methods (default); 1 = Otsu; 2 = Kittler & Illingworth; 3 = max entropy; 4 = potential difference;
- * \param pBox: region from where the threshold is computed; 0 = full image (default).
- * \param pContrastMask: limit the computation only in regions with contrasted (!=0) pixels; default = 0.
- * the pContrastMask image must be grayscale with same with and height of the current image,
- * can be obtained from the current image with a filter:
- * CxImage iContrastMask(*image,true,false,false);
- * iContrastMask.GrayScale();
- * int32_t edge[]={-1,-1,-1,-1,8,-1,-1,-1,-1};
- * iContrastMask.Filter(edge,3,1,0);
- * int32_t blur[]={1,1,1,1,1,1,1,1,1};
- * iContrastMask.Filter(blur,3,9,0);
- * \return optimal threshold; -1 = error.
- * \sa AdaptiveThreshold
- */
-int32_t CxImage::OptimalThreshold(int32_t method, RECT * pBox, CxImage* pContrastMask)
-{
- if (!pDib)
- return false;
-
- if (head.biBitCount!=8){
- strcpy(info.szLastError,"OptimalThreshold works only on 8 bit images");
- return -1;
- }
-
- if (pContrastMask){
- if (!pContrastMask->IsValid() ||
- !pContrastMask->IsGrayScale() ||
- pContrastMask->GetWidth() != GetWidth() ||
- pContrastMask->GetHeight() != GetHeight()){
- strcpy(info.szLastError,"OptimalThreshold invalid ContrastMask");
- return -1;
- }
- }
-
- int32_t xmin,xmax,ymin,ymax;
- if (pBox){
- xmin = max(pBox->left,0);
- xmax = min(pBox->right,head.biWidth);
- ymin = max(pBox->bottom,0);
- ymax = min(pBox->top,head.biHeight);
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- if (xmin>=xmax || ymin>=ymax)
- return -1;
-
- double p[256];
- memset(p, 0, 256*sizeof(double));
- //build histogram
- for (int32_t y = ymin; y<ymax; y++){
- uint8_t* pGray = GetBits(y) + xmin;
- uint8_t* pContr = 0;
- if (pContrastMask) pContr = pContrastMask->GetBits(y) + xmin;
- for (int32_t x = xmin; x<xmax; x++){
- uint8_t n = *pGray++;
- if (pContr){
- if (*pContr) p[n]++;
- pContr++;
- } else {
- p[n]++;
- }
- }
- }
-
- //find histogram limits
- int32_t gray_min = 0;
- while (gray_min<255 && p[gray_min]==0) gray_min++;
- int32_t gray_max = 255;
- while (gray_max>0 && p[gray_max]==0) gray_max--;
- if (gray_min > gray_max)
- return -1;
- if (gray_min == gray_max){
- if (gray_min == 0)
- return 0;
- else
- return gray_max-1;
- }
-
- //compute total moments 0th,1st,2nd order
- int32_t i,k;
- double w_tot = 0;
- double m_tot = 0;
- double q_tot = 0;
- for (i = gray_min; i <= gray_max; i++){
- w_tot += p[i];
- m_tot += i*p[i];
- q_tot += i*i*p[i];
- }
-
- double L, L1max, L2max, L3max, L4max; //objective functions
- int32_t th1,th2,th3,th4; //optimal thresholds
- L1max = L2max = L3max = L4max = 0;
- th1 = th2 = th3 = th4 = -1;
-
- double w1, w2, m1, m2, q1, q2, s1, s2;
- w1 = m1 = q1 = 0;
- for (i = gray_min; i < gray_max; i++){
- w1 += p[i];
- w2 = w_tot - w1;
- m1 += i*p[i];
- m2 = m_tot - m1;
- q1 += i*i*p[i];
- q2 = q_tot - q1;
- s1 = q1/w1-m1*m1/w1/w1; //s1 = q1/w1-pow(m1/w1,2);
- s2 = q2/w2-m2*m2/w2/w2; //s2 = q2/w2-pow(m2/w2,2);
-
- //Otsu
- L = -(s1*w1 + s2*w2); //implemented as definition
- //L = w1 * w2 * (m2/w2 - m1/w1)*(m2/w2 - m1/w1); //implementation that doesn't need s1 & s2
- if (L1max < L || th1<0){
- L1max = L;
- th1 = i;
- }
-
- //Kittler and Illingworth
- if (s1>0 && s2>0){
- L = w1*log(w1/sqrt(s1))+w2*log(w2/sqrt(s2));
- //L = w1*log(w1*w1/s1)+w2*log(w2*w2/s2);
- if (L2max < L || th2<0){
- L2max = L;
- th2 = i;
- }
- }
-
- //max entropy
- L = 0;
- for (k=gray_min;k<=i;k++) if (p[k] > 0) L -= p[k]*log(p[k]/w1)/w1;
- for (k;k<=gray_max;k++) if (p[k] > 0) L -= p[k]*log(p[k]/w2)/w2;
- if (L3max < L || th3<0){
- L3max = L;
- th3 = i;
- }
-
- //potential difference (based on Electrostatic Binarization method by J. Acharya & G. Sreechakra)
- // L=-fabs(vdiff/vsum); è molto selettivo, sembra che L=-fabs(vdiff) o L=-(vsum)
- // abbiano lo stesso valore di soglia... il che semplificherebbe molto la routine
- double vdiff = 0;
- for (k=gray_min;k<=i;k++)
- vdiff += p[k]*(i-k)*(i-k);
- double vsum = vdiff;
- for (k;k<=gray_max;k++){
- double dv = p[k]*(k-i)*(k-i);
- vdiff -= dv;
- vsum += dv;
- }
- if (vsum>0) L = -fabs(vdiff/vsum); else L = 0;
- if (L4max < L || th4<0){
- L4max = L;
- th4 = i;
- }
- }
-
- int32_t threshold;
- switch (method){
- case 1: //Otsu
- threshold = th1;
- break;
- case 2: //Kittler and Illingworth
- threshold = th2;
- break;
- case 3: //max entropy
- threshold = th3;
- break;
- case 4: //potential difference
- threshold = th4;
- break;
- default: //auto
- {
- int32_t nt = 0;
- threshold = 0;
- if (th1>=0) { threshold += th1; nt++;}
- if (th2>=0) { threshold += th2; nt++;}
- if (th3>=0) { threshold += th3; nt++;}
- if (th4>=0) { threshold += th4; nt++;}
- if (nt)
- threshold /= nt;
- else
- threshold = (gray_min+gray_max)/2;
-
- /*better(?) but really expensive alternative:
- n = 0:255;
- pth1 = c1(th1)/sqrt(2*pi*s1(th1))*exp(-((n - m1(th1)).^2)/2/s1(th1)) + c2(th1)/sqrt(2*pi*s2(th1))*exp(-((n - m2(th1)).^2)/2/s2(th1));
- pth2 = c1(th2)/sqrt(2*pi*s1(th2))*exp(-((n - m1(th2)).^2)/2/s1(th2)) + c2(th2)/sqrt(2*pi*s2(th2))*exp(-((n - m2(th2)).^2)/2/s2(th2));
- ...
- mse_th1 = sum((p-pth1).^2);
- mse_th2 = sum((p-pth2).^2);
- ...
- select th# that gives minimum mse_th#
- */
-
- }
- }
-
- if (threshold <= gray_min || threshold >= gray_max)
- threshold = (gray_min+gray_max)/2;
-
- return threshold;
-}
-///////////////////////////////////////////////////////////////////////////////
-/**
- * Converts the image to B&W, using an optimal threshold mask
- * \param method: 0 = average all methods (default); 1 = Otsu; 2 = Kittler & Illingworth; 3 = max entropy; 4 = potential difference;
- * \param nBoxSize: the image is divided into "nBoxSize x nBoxSize" blocks, from where the threshold is computed; min = 8; default = 64.
- * \param pContrastMask: limit the computation only in regions with contrasted (!=0) pixels; default = 0.
- * \param nBias: global offset added to the threshold mask; default = 0.
- * \param fGlobalLocalBalance: balance between local and global threshold. default = 0.5
- * fGlobalLocalBalance can be from 0.0 (use only local threshold) to 1.0 (use only global threshold)
- * the pContrastMask image must be grayscale with same with and height of the current image,
- * \return true if everything is ok.
- * \sa OptimalThreshold
- */
-bool CxImage::AdaptiveThreshold(int32_t method, int32_t nBoxSize, CxImage* pContrastMask, int32_t nBias, float fGlobalLocalBalance)
-{
- if (!pDib)
- return false;
-
- if (pContrastMask){
- if (!pContrastMask->IsValid() ||
- !pContrastMask->IsGrayScale() ||
- pContrastMask->GetWidth() != GetWidth() ||
- pContrastMask->GetHeight() != GetHeight()){
- strcpy(info.szLastError,"AdaptiveThreshold invalid ContrastMask");
- return false;
- }
- }
-
- if (nBoxSize<8) nBoxSize = 8;
- if (fGlobalLocalBalance<0.0f) fGlobalLocalBalance = 0.0f;
- if (fGlobalLocalBalance>1.0f) fGlobalLocalBalance = 1.0f;
-
- int32_t mw = (head.biWidth + nBoxSize - 1)/nBoxSize;
- int32_t mh = (head.biHeight + nBoxSize - 1)/nBoxSize;
-
- CxImage mask(mw,mh,8);
- if(!mask.GrayScale())
- return false;
-
- if(!GrayScale())
- return false;
-
- int32_t globalthreshold = OptimalThreshold(method, 0, pContrastMask);
- if (globalthreshold <0)
- return false;
-
- for (int32_t y=0; y<mh; y++){
- for (int32_t x=0; x<mw; x++){
- info.nProgress = (int32_t)(100*(x+y*mw)/(mw*mh));
- if (info.nEscape) break;
- RECT r;
- r.left = x*nBoxSize;
- r.right = r.left + nBoxSize;
- r.bottom = y*nBoxSize;
- r.top = r.bottom + nBoxSize;
- int32_t threshold = OptimalThreshold(method, &r, pContrastMask);
- if (threshold <0) return false;
- mask.SetPixelIndex(x,y,(uint8_t)max(0,min(255,nBias+((1.0f-fGlobalLocalBalance)*threshold + fGlobalLocalBalance*globalthreshold))));
- }
- }
-
- mask.Resample(mw*nBoxSize,mh*nBoxSize,0);
- mask.Crop(0,head.biHeight,head.biWidth,0);
-
- if(!Threshold(&mask))
- return false;
-
- return true;
-}
-///////////////////////////////////////////////////////////////////////////////
-/**
- * Finds the contour of an object with a given color
- * \param color_target: object color
- * \param color_trace: contour color
- * \return true if everything is ok.
- * \sa Edge, Contour
- */
-bool CxImage::Trace(RGBQUAD color_target, RGBQUAD color_trace)
-{
- if (!pDib) return false;
-
- RGBQUAD color;
- bool bFindStartPoint;
- int32_t nFindPoint;
- POINT StartPoint,CurrentPoint;
- int32_t Direction[8][2]={{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}, {0,1},{1,1}};
- int32_t BeginDirect = 0;
- int32_t x,y;
-
- CxImage tmp;
- tmp.CopyInfo(*this);
- tmp.Create(head.biWidth,head.biHeight,24,info.dwType);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
- tmp.Clear(255);
-
- CurrentPoint.x = StartPoint.x = CurrentPoint.y = StartPoint.y = 0;
- bFindStartPoint = false;
- for (y=head.biHeight-1;y>=0 && !bFindStartPoint;y--){
- info.nProgress = (int32_t)(100*y/head.biHeight);
- if (info.nEscape) break;
- for (x=0;x<head.biWidth && !bFindStartPoint;x++){
- color = BlindGetPixelColor(x,y);
- if (color.rgbRed == color_target.rgbRed &&
- color.rgbGreen == color_target.rgbGreen &&
- color.rgbBlue == color_target.rgbBlue )
- {
- bFindStartPoint = true;
- CurrentPoint.x = StartPoint.x = x;
- CurrentPoint.y = StartPoint.y = y;
- }
- }
- }
-
- while(bFindStartPoint)
- {
- nFindPoint = 8;
- while(nFindPoint)
- {
- x = CurrentPoint.x + Direction[BeginDirect][0];
- y = CurrentPoint.y + Direction[BeginDirect][1];
- color = GetPixelColor(x,y);
-
- if (IsInside(x,y) &&
- color.rgbRed == color_target.rgbRed &&
- color.rgbGreen == color_target.rgbGreen &&
- color.rgbBlue == color_target.rgbBlue )
- {
- nFindPoint = 0;
- CurrentPoint.x = x;
- CurrentPoint.y = y;
-
- if(x == StartPoint.x && y == StartPoint.y)
- bFindStartPoint = false;
-
- tmp.BlindSetPixelColor(x,y,color_trace);
-
- BeginDirect--;
- if(BeginDirect == -1) BeginDirect = 7;
- }
- else
- {
- BeginDirect++;
- if(BeginDirect == 8) BeginDirect = 0;
- nFindPoint--;
- if(nFindPoint == 0) {
- bFindStartPoint = false;
- tmp.SetPixelColor(CurrentPoint.x,CurrentPoint.y,color_trace);
- }
- }
- }
- }
- Transfer(tmp);
- return true;
-}
-
-#ifndef __MINGW32__
-////////////////////////////////////////////////////////////////////////////////
-#include <queue>
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Flood Fill
- * \param xStart, yStart: starting point
- * \param cFillColor: filling color
- * \param nTolerance: deviation from the starting point color
- * \param nOpacity: can be from 0 (transparent) to 255 (opaque, default)
- * \param bSelectFilledArea: if true, the pixels in the region are also set in the selection layer; default = false
- * \param nSelectionLevel: if bSelectFilledArea is true, the selected pixels are set to nSelectionLevel; default = 255
- * Note: nOpacity=0 && bSelectFilledArea=true act as a "magic wand"
- * \return true if everything is ok
- */
-bool CxImage::FloodFill(const int32_t xStart, const int32_t yStart, const RGBQUAD cFillColor, const uint8_t nTolerance,
- uint8_t nOpacity, const bool bSelectFilledArea, const uint8_t nSelectionLevel)
-{
- if (!pDib)
- return false;
-
- if (!IsInside(xStart,yStart))
- return true;
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (!SelectionIsInside(xStart,yStart))
- return true;
-#endif //CXIMAGE_SUPPORT_SELECTION
-
- RGBQUAD* pPalette=NULL;
- uint16_t bpp = GetBpp();
- //nTolerance or nOpacity implemented only for grayscale or 24bpp images
- if ((nTolerance || nOpacity != 255) && !(head.biBitCount == 24 || IsGrayScale())){
- pPalette = new RGBQUAD[head.biClrUsed];
- memcpy(pPalette, GetPalette(),GetPaletteSize());
- if (!IncreaseBpp(24))
- return false;
- }
-
- uint8_t* pFillMask = (uint8_t*)calloc(head.biWidth * head.biHeight,1);
- if (!pFillMask)
- return false;
-
-//------------------------------------- Begin of Flood Fill
- POINT offset[4] = {{-1,0},{0,-1},{1,0},{0,1}};
- std::queue<POINT> q;
- POINT point = {xStart,yStart};
- q.push(point);
-
- if (IsIndexed()){ //--- Generic indexed image, no tolerance OR Grayscale image with tolerance
- uint8_t idxRef = GetPixelIndex(xStart,yStart);
- uint8_t idxFill = GetNearestIndex(cFillColor);
- uint8_t idxMin = (uint8_t)min(255, max(0,(int32_t)(idxRef - nTolerance)));
- uint8_t idxMax = (uint8_t)min(255, max(0,(int32_t)(idxRef + nTolerance)));
-
- while(!q.empty())
- {
- point = q.front();
- q.pop();
-
- for (int32_t z=0; z<4; z++){
- int32_t x = point.x + offset[z].x;
- int32_t y = point.y + offset[z].y;
- if(IsInside(x,y)){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- uint8_t idx = BlindGetPixelIndex(x, y);
- uint8_t* pFill = pFillMask + x + y * head.biWidth;
- if (*pFill==0 && idxMin <= idx && idx <= idxMax )
- {
- if (nOpacity>0){
- if (nOpacity == 255)
- BlindSetPixelIndex(x, y, idxFill);
- else
- BlindSetPixelIndex(x, y, (uint8_t)((idxFill * nOpacity + idx * (255-nOpacity))>>8));
- }
- POINT pt = {x,y};
- q.push(pt);
- *pFill = 1;
- }
- }
- }
- }
- }
- } else { //--- RGB image
- RGBQUAD cRef = GetPixelColor(xStart,yStart);
- RGBQUAD cRefMin, cRefMax;
- cRefMin.rgbRed = (uint8_t)min(255, max(0,(int32_t)(cRef.rgbRed - nTolerance)));
- cRefMin.rgbGreen = (uint8_t)min(255, max(0,(int32_t)(cRef.rgbGreen - nTolerance)));
- cRefMin.rgbBlue = (uint8_t)min(255, max(0,(int32_t)(cRef.rgbBlue - nTolerance)));
- cRefMax.rgbRed = (uint8_t)min(255, max(0,(int32_t)(cRef.rgbRed + nTolerance)));
- cRefMax.rgbGreen = (uint8_t)min(255, max(0,(int32_t)(cRef.rgbGreen + nTolerance)));
- cRefMax.rgbBlue = (uint8_t)min(255, max(0,(int32_t)(cRef.rgbBlue + nTolerance)));
-
- while(!q.empty())
- {
- point = q.front();
- q.pop();
-
- for (int32_t z=0; z<4; z++){
- int32_t x = point.x + offset[z].x;
- int32_t y = point.y + offset[z].y;
- if(IsInside(x,y)){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- RGBQUAD cc = BlindGetPixelColor(x, y);
- uint8_t* pFill = pFillMask + x + y * head.biWidth;
- if (*pFill==0 &&
- cRefMin.rgbRed <= cc.rgbRed && cc.rgbRed <= cRefMax.rgbRed &&
- cRefMin.rgbGreen <= cc.rgbGreen && cc.rgbGreen <= cRefMax.rgbGreen &&
- cRefMin.rgbBlue <= cc.rgbBlue && cc.rgbBlue <= cRefMax.rgbBlue )
- {
- if (nOpacity>0){
- if (nOpacity == 255)
- BlindSetPixelColor(x, y, cFillColor);
- else
- {
- cc.rgbRed = (uint8_t)((cFillColor.rgbRed * nOpacity + cc.rgbRed * (255-nOpacity))>>8);
- cc.rgbGreen = (uint8_t)((cFillColor.rgbGreen * nOpacity + cc.rgbGreen * (255-nOpacity))>>8);
- cc.rgbBlue = (uint8_t)((cFillColor.rgbBlue * nOpacity + cc.rgbBlue * (255-nOpacity))>>8);
- BlindSetPixelColor(x, y, cc);
- }
- }
- POINT pt = {x,y};
- q.push(pt);
- *pFill = 1;
- }
- }
- }
- }
- }
- }
- if (pFillMask[xStart+yStart*head.biWidth] == 0 && nOpacity>0){
- if (nOpacity == 255)
- BlindSetPixelColor(xStart, yStart, cFillColor);
- else
- {
- RGBQUAD cc = BlindGetPixelColor(xStart, yStart);
- cc.rgbRed = (uint8_t)((cFillColor.rgbRed * nOpacity + cc.rgbRed * (255-nOpacity))>>8);
- cc.rgbGreen = (uint8_t)((cFillColor.rgbGreen * nOpacity + cc.rgbGreen * (255-nOpacity))>>8);
- cc.rgbBlue = (uint8_t)((cFillColor.rgbBlue * nOpacity + cc.rgbBlue * (255-nOpacity))>>8);
- BlindSetPixelColor(xStart, yStart, cc);
- }
- }
- pFillMask[xStart+yStart*head.biWidth] = 1;
-//------------------------------------- End of Flood Fill
-
- //if necessary, restore the original BPP and palette
- if (pPalette){
- DecreaseBpp(bpp, false, pPalette);
- delete [] pPalette;
- }
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (bSelectFilledArea){
- if (!SelectionIsValid()){
- if (!SelectionCreate()){
- return false;
- }
- SelectionClear();
- info.rSelectionBox.right = head.biWidth;
- info.rSelectionBox.top = head.biHeight;
- info.rSelectionBox.left = info.rSelectionBox.bottom = 0;
- }
- RECT r;
- SelectionGetBox(r);
- for (int32_t y = r.bottom; y < r.top; y++){
- uint8_t* pFill = pFillMask + r.left + y * head.biWidth;
- for (int32_t x = r.left; x<r.right; x++){
- if (*pFill) SelectionSet(x,y,nSelectionLevel);
- pFill++;
- }
- }
- SelectionRebuildBox();
- }
-#endif //CXIMAGE_SUPPORT_SELECTION
-
- free(pFillMask);
-
- return true;
-}
-#endif //__MINGW32__
-
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DSP
diff --git a/smelt/sdl/CxImage/ximaenc.cpp b/smelt/sdl/CxImage/ximaenc.cpp deleted file mode 100644 index 6064e49..0000000 --- a/smelt/sdl/CxImage/ximaenc.cpp +++ /dev/null @@ -1,1159 +0,0 @@ -// xImaCodec.cpp : Encode Decode functions
-/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_JPG
-#include "ximajpg.h"
-#endif
-
-#if CXIMAGE_SUPPORT_GIF
-#include "ximagif.h"
-#endif
-
-#if CXIMAGE_SUPPORT_PNG
-#include "ximapng.h"
-#endif
-
-#if CXIMAGE_SUPPORT_MNG
-#include "ximamng.h"
-#endif
-
-#if CXIMAGE_SUPPORT_BMP
-#include "ximabmp.h"
-#endif
-
-#if CXIMAGE_SUPPORT_ICO
-#include "ximaico.h"
-#endif
-
-#if CXIMAGE_SUPPORT_TIF
-#include "ximatif.h"
-#endif
-
-#if CXIMAGE_SUPPORT_TGA
-#include "ximatga.h"
-#endif
-
-#if CXIMAGE_SUPPORT_PCX
-#include "ximapcx.h"
-#endif
-
-#if CXIMAGE_SUPPORT_WBMP
-#include "ximawbmp.h"
-#endif
-
-#if CXIMAGE_SUPPORT_WMF
-#include "ximawmf.h" // <vho> - WMF/EMF support
-#endif
-
-#if CXIMAGE_SUPPORT_JBG
-#include "ximajbg.h"
-#endif
-
-#if CXIMAGE_SUPPORT_JASPER
-#include "ximajas.h"
-#endif
-
-#if CXIMAGE_SUPPORT_SKA
-#include "ximaska.h"
-#endif
-
-#if CXIMAGE_SUPPORT_RAW
-#include "ximaraw.h"
-#endif
-
-#if CXIMAGE_SUPPORT_PSD
-#include "ximapsd.h"
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::EncodeSafeCheck(CxFile *hFile)
-{
- if (hFile==NULL) {
- strcpy(info.szLastError,CXIMAGE_ERR_NOFILE);
- return true;
- }
-
- if (pDib==NULL){
- strcpy(info.szLastError,CXIMAGE_ERR_NOIMAGE);
- return true;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-//#ifdef WIN32
-//bool CxImage::Save(LPCWSTR filename, uint32_t imagetype)
-//{
-// FILE* hFile; //file handle to write the image
-// if ((hFile=_wfopen(filename,L"wb"))==NULL) return false;
-// bool bOK = Encode(hFile,imagetype);
-// fclose(hFile);
-// return bOK;
-//}
-//#endif //WIN32
-////////////////////////////////////////////////////////////////////////////////
-// For UNICODE support: char -> TCHAR
-/**
- * Saves to disk the image in a specific format.
- * \param filename: file name
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- * \return true if everything is ok
- */
-bool CxImage::Save(const TCHAR * filename, uint32_t imagetype)
-{
- FILE* hFile; //file handle to write the image
-
-#ifdef WIN32
- if ((hFile=_tfopen(filename,_T("wb")))==NULL) return false; // For UNICODE support
-#else
- if ((hFile=fopen(filename,"wb"))==NULL) return false;
-#endif
-
- bool bOK = Encode(hFile,imagetype);
- fclose(hFile);
- return bOK;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Saves to disk the image in a specific format.
- * \param hFile: file handle, open and enabled for writing.
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- * \return true if everything is ok
- */
-bool CxImage::Encode(FILE *hFile, uint32_t imagetype)
-{
- CxIOFile file(hFile);
- return Encode(&file,imagetype);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Saves to memory buffer the image in a specific format.
- * \param buffer: output memory buffer pointer. Must be NULL,
- * the function allocates and fill the memory,
- * the application must free the buffer, see also FreeMemory().
- * \param size: output memory buffer size.
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- * \return true if everything is ok
- */
-bool CxImage::Encode(uint8_t * &buffer, int32_t &size, uint32_t imagetype)
-{
- if (buffer!=NULL){
- strcpy(info.szLastError,"the buffer must be empty");
- return false;
- }
- CxMemFile file;
- file.Open();
- if(Encode(&file,imagetype)){
- buffer=file.GetBuffer();
- size=file.Size();
- return true;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Saves to disk the image in a specific format.
- * \param hFile: file handle (CxMemFile or CxIOFile), with write access.
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- * \return true if everything is ok
- * \sa ENUM_CXIMAGE_FORMATS
- */
-bool CxImage::Encode(CxFile *hFile, uint32_t imagetype)
-{
-
-#if CXIMAGE_SUPPORT_BMP
- if (CXIMAGE_FORMAT_BMP==imagetype){
- CxImageBMP *newima = new CxImageBMP;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_ICO
- if (CXIMAGE_FORMAT_ICO==imagetype){
- CxImageICO *newima = new CxImageICO;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_TIF
- if (CXIMAGE_FORMAT_TIF==imagetype){
- CxImageTIF *newima = new CxImageTIF;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_JPG
- if (CXIMAGE_FORMAT_JPG==imagetype){
- CxImageJPG *newima = new CxImageJPG;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_GIF
- if (CXIMAGE_FORMAT_GIF==imagetype){
- CxImageGIF *newima = new CxImageGIF;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_PNG
- if (CXIMAGE_FORMAT_PNG==imagetype){
- CxImagePNG *newima = new CxImagePNG;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_MNG
- if (CXIMAGE_FORMAT_MNG==imagetype){
- CxImageMNG *newima = new CxImageMNG;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_TGA
- if (CXIMAGE_FORMAT_TGA==imagetype){
- CxImageTGA *newima = new CxImageTGA;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_PCX
- if (CXIMAGE_FORMAT_PCX==imagetype){
- CxImagePCX *newima = new CxImagePCX;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_WBMP
- if (CXIMAGE_FORMAT_WBMP==imagetype){
- CxImageWBMP *newima = new CxImageWBMP;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS // <vho> - WMF/EMF support
- if (CXIMAGE_FORMAT_WMF==imagetype){
- CxImageWMF *newima = new CxImageWMF;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_JBG
- if (CXIMAGE_FORMAT_JBG==imagetype){
- CxImageJBG *newima = new CxImageJBG;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_JASPER
- if (
- #if CXIMAGE_SUPPORT_JP2
- CXIMAGE_FORMAT_JP2==imagetype ||
- #endif
- #if CXIMAGE_SUPPORT_JPC
- CXIMAGE_FORMAT_JPC==imagetype ||
- #endif
- #if CXIMAGE_SUPPORT_PGX
- CXIMAGE_FORMAT_PGX==imagetype ||
- #endif
- #if CXIMAGE_SUPPORT_PNM
- CXIMAGE_FORMAT_PNM==imagetype ||
- #endif
- #if CXIMAGE_SUPPORT_RAS
- CXIMAGE_FORMAT_RAS==imagetype ||
- #endif
- false ){
- CxImageJAS *newima = new CxImageJAS;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile,imagetype)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-
-#if CXIMAGE_SUPPORT_SKA
- if (CXIMAGE_FORMAT_SKA==imagetype){
- CxImageSKA *newima = new CxImageSKA;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-
-#if CXIMAGE_SUPPORT_RAW
- if (CXIMAGE_FORMAT_RAW==imagetype){
- CxImageRAW *newima = new CxImageRAW;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-
-#if CXIMAGE_SUPPORT_PSD
- if (CXIMAGE_FORMAT_PSD==imagetype){
- CxImagePSD *newima = new CxImagePSD;
- if (!newima) return false;
- newima->Ghost(this);
- if (newima->Encode(hFile)){
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- delete newima;
- return false;
- }
- }
-#endif
-
- strcpy(info.szLastError,"Encode: Unknown format");
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Saves to disk or memory pagecount images, referenced by an array of CxImage pointers.
- * \param hFile: file handle.
- * \param pImages: array of CxImage pointers.
- * \param pagecount: number of images.
- * \param imagetype: can be CXIMAGE_FORMAT_TIF or CXIMAGE_FORMAT_GIF.
- * \return true if everything is ok
- */
-bool CxImage::Encode(FILE * hFile, CxImage ** pImages, int32_t pagecount, uint32_t imagetype)
-{
- CxIOFile file(hFile);
- return Encode(&file, pImages, pagecount,imagetype);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Saves to disk or memory pagecount images, referenced by an array of CxImage pointers.
- * \param hFile: file handle (CxMemFile or CxIOFile), with write access.
- * \param pImages: array of CxImage pointers.
- * \param pagecount: number of images.
- * \param imagetype: can be CXIMAGE_FORMAT_TIF, CXIMAGE_FORMAT_GIF or CXIMAGE_FORMAT_ICO.
- * \return true if everything is ok
- */
-bool CxImage::Encode(CxFile * hFile, CxImage ** pImages, int32_t pagecount, uint32_t imagetype)
-{
-#if CXIMAGE_SUPPORT_TIF
- if (imagetype==CXIMAGE_FORMAT_TIF){
- CxImageTIF newima;
- newima.Ghost(this);
- if (newima.Encode(hFile,pImages,pagecount)){
- return true;
- } else {
- strcpy(info.szLastError,newima.GetLastError());
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_GIF
- if (imagetype==CXIMAGE_FORMAT_GIF){
- CxImageGIF newima;
- newima.Ghost(this);
- if (newima.Encode(hFile,pImages,pagecount)){
- return true;
- } else {
- strcpy(info.szLastError,newima.GetLastError());
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_ICO
- if (imagetype==CXIMAGE_FORMAT_ICO){
- CxImageICO newima;
- newima.Ghost(this);
- if (newima.Encode(hFile,pImages,pagecount)){
- return true;
- } else {
- strcpy(info.szLastError,newima.GetLastError());
- return false;
- }
- }
-#endif
- strcpy(info.szLastError,"Multipage Encode, Unsupported operation for this format");
- return false;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * exports the image into a RGBA buffer, Useful for OpenGL applications.
- * \param buffer: output memory buffer pointer. Must be NULL,
- * the function allocates and fill the memory,
- * the application must free the buffer, see also FreeMemory().
- * \param size: output memory buffer size.
- * \param bFlipY: direction of Y axis. default = false.
- * \return true if everything is ok
- */
-bool CxImage::Encode2RGBA(uint8_t * &buffer, int32_t &size, bool bFlipY)
-{
- if (buffer!=NULL){
- strcpy(info.szLastError,"the buffer must be empty");
- return false;
- }
- CxMemFile file;
- file.Open();
- if(Encode2RGBA(&file,bFlipY)){
- buffer=file.GetBuffer();
- size=file.Size();
- return true;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * exports the image into a RGBA buffer, Useful for OpenGL applications.
- * \param hFile: file handle (CxMemFile or CxIOFile), with write access.
- * \param bFlipY: direction of Y axis. default = false.
- * \return true if everything is ok
- */
-bool CxImage::Encode2RGBA(CxFile *hFile, bool bFlipY)
-{
- if (EncodeSafeCheck(hFile)) return false;
-
- for (int32_t y1 = 0; y1 < head.biHeight; y1++) {
- int32_t y = bFlipY ? head.biHeight - 1 - y1 : y1;
- for(int32_t x = 0; x < head.biWidth; x++) {
- RGBQUAD color = BlindGetPixelColor(x,y);
- hFile->PutC(color.rgbRed);
- hFile->PutC(color.rgbGreen);
- hFile->PutC(color.rgbBlue);
- hFile->PutC(color.rgbReserved);
- }
- }
- return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-// For UNICODE support: char -> TCHAR
-/**
- * Reads from disk the image in a specific format.
- * - If decoding fails using the specified image format,
- * the function will try the automatic file format recognition.
- *
- * \param filename: file name
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- * \return true if everything is ok
- */
-bool CxImage::Load(const TCHAR * filename, uint32_t imagetype)
-//bool CxImage::Load(const char * filename, uint32_t imagetype)
-{
- /*FILE* hFile; //file handle to read the image
- if ((hFile=fopen(filename,"rb"))==NULL) return false;
- bool bOK = Decode(hFile,imagetype);
- fclose(hFile);*/
-
- /* automatic file type recognition */
- bool bOK = false;
- if ( GetTypeIndexFromId(imagetype) ){
- FILE* hFile; //file handle to read the image
-
-#ifdef WIN32
- if ((hFile=_tfopen(filename,_T("rb")))==NULL) return false; // For UNICODE support
-#else
- if ((hFile=fopen(filename,"rb"))==NULL) return false;
-#endif
-
- bOK = Decode(hFile,imagetype);
- fclose(hFile);
- if (bOK) return bOK;
- }
-
- char szError[256];
- strcpy(szError,info.szLastError); //save the first error
-
- // if failed, try automatic recognition of the file...
- FILE* hFile;
-
-#ifdef WIN32
- if ((hFile=_tfopen(filename,_T("rb")))==NULL) return false; // For UNICODE support
-#else
- if ((hFile=fopen(filename,"rb"))==NULL) return false;
-#endif
-
- bOK = Decode(hFile,CXIMAGE_FORMAT_UNKNOWN);
- fclose(hFile);
-
- if (!bOK && imagetype > 0) strcpy(info.szLastError,szError); //restore the first error
-
- return bOK;
-}
-////////////////////////////////////////////////////////////////////////////////
-#ifdef WIN32
-//bool CxImage::Load(LPCWSTR filename, uint32_t imagetype)
-//{
-// /*FILE* hFile; //file handle to read the image
-// if ((hFile=_wfopen(filename, L"rb"))==NULL) return false;
-// bool bOK = Decode(hFile,imagetype);
-// fclose(hFile);*/
-//
-// /* automatic file type recognition */
-// bool bOK = false;
-// if ( GetTypeIndexFromId(imagetype) ){
-// FILE* hFile; //file handle to read the image
-// if ((hFile=_wfopen(filename,L"rb"))==NULL) return false;
-// bOK = Decode(hFile,imagetype);
-// fclose(hFile);
-// if (bOK) return bOK;
-// }
-//
-// char szError[256];
-// strcpy(szError,info.szLastError); //save the first error
-//
-// // if failed, try automatic recognition of the file...
-// FILE* hFile; //file handle to read the image
-// if ((hFile=_wfopen(filename,L"rb"))==NULL) return false;
-// bOK = Decode(hFile,CXIMAGE_FORMAT_UNKNOWN);
-// fclose(hFile);
-//
-// if (!bOK && imagetype > 0) strcpy(info.szLastError,szError); //restore the first error
-//
-// return bOK;
-//}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Loads an image from the application resources.
- * \param hRes: the resource handle returned by FindResource().
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS.
- * \param hModule: NULL for internal resource, or external application/DLL hinstance returned by LoadLibray.
- * \return true if everything is ok
- */
-bool CxImage::LoadResource(HRSRC hRes, uint32_t imagetype, HMODULE hModule)
-{
- uint32_t rsize=SizeofResource(hModule,hRes);
- HGLOBAL hMem=::LoadResource(hModule,hRes);
- if (hMem){
- char* lpVoid=(char*)LockResource(hMem);
- if (lpVoid){
- // FILE* fTmp=tmpfile(); doesn't work with network
- /*char tmpPath[MAX_PATH] = {0};
- char tmpFile[MAX_PATH] = {0};
- GetTempPath(MAX_PATH,tmpPath);
- GetTempFileName(tmpPath,"IMG",0,tmpFile);
- FILE* fTmp=fopen(tmpFile,"w+b");
- if (fTmp){
- fwrite(lpVoid,rsize,1,fTmp);
- fseek(fTmp,0,SEEK_SET);
- bool bOK = Decode(fTmp,imagetype);
- fclose(fTmp);
- DeleteFile(tmpFile);
- return bOK;
- }*/
-
- CxMemFile fTmp((uint8_t*)lpVoid,rsize);
- return Decode(&fTmp,imagetype);
- }
- } else strcpy(info.szLastError,"Unable to load resource!");
- return false;
-}
-#endif //WIN32
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor from file name, see Load()
- * \param filename: file name
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- */
-//
-// > filename: file name
-// > imagetype: specify the image format (CXIMAGE_FORMAT_BMP,...)
-// For UNICODE support: char -> TCHAR
-CxImage::CxImage(const TCHAR * filename, uint32_t imagetype)
-//CxImage::CxImage(const char * filename, uint32_t imagetype)
-{
- Startup(imagetype);
- Load(filename,imagetype);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor from file handle, see Decode()
- * \param stream: file handle, with read access.
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- */
-CxImage::CxImage(FILE * stream, uint32_t imagetype)
-{
- Startup(imagetype);
- Decode(stream,imagetype);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor from CxFile object, see Decode()
- * \param stream: file handle (CxMemFile or CxIOFile), with read access.
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- */
-CxImage::CxImage(CxFile * stream, uint32_t imagetype)
-{
- Startup(imagetype);
- Decode(stream,imagetype);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor from memory buffer, see Decode()
- * \param buffer: memory buffer
- * \param size: size of buffer
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- */
-CxImage::CxImage(uint8_t * buffer, uint32_t size, uint32_t imagetype)
-{
- Startup(imagetype);
- CxMemFile stream(buffer,size);
- Decode(&stream,imagetype);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Loads an image from memory buffer
- * \param buffer: memory buffer
- * \param size: size of buffer
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- * \return true if everything is ok
- */
-bool CxImage::Decode(uint8_t * buffer, uint32_t size, uint32_t imagetype)
-{
- CxMemFile file(buffer,size);
- return Decode(&file,imagetype);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Loads an image from file handle.
- * \param hFile: file handle, with read access.
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- * \return true if everything is ok
- */
-bool CxImage::Decode(FILE *hFile, uint32_t imagetype)
-{
- CxIOFile file(hFile);
- return Decode(&file,imagetype);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Loads an image from CxFile object
- * \param hFile: file handle (CxMemFile or CxIOFile), with read access.
- * \param imagetype: file format, see ENUM_CXIMAGE_FORMATS
- * \return true if everything is ok
- * \sa ENUM_CXIMAGE_FORMATS
- */
-bool CxImage::Decode(CxFile *hFile, uint32_t imagetype)
-{
- if (hFile == NULL){
- strcpy(info.szLastError,CXIMAGE_ERR_NOFILE);
- return false;
- }
-
- uint32_t pos = hFile->Tell();
-
-#if CXIMAGE_SUPPORT_BMP
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_BMP==imagetype){
- CxImageBMP *newima = new CxImageBMP;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_JPG
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_JPG==imagetype){
- CxImageJPG *newima = new CxImageJPG;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_ICO
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_ICO==imagetype){
- CxImageICO *newima = new CxImageICO;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- info.nNumFrames = newima->info.nNumFrames;
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_GIF
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_GIF==imagetype){
- CxImageGIF *newima = new CxImageGIF;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- info.nNumFrames = newima->info.nNumFrames;
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_PNG
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_PNG==imagetype){
- CxImagePNG *newima = new CxImagePNG;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_TIF
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_TIF==imagetype){
- CxImageTIF *newima = new CxImageTIF;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- info.nNumFrames = newima->info.nNumFrames;
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_MNG
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_MNG==imagetype){
- CxImageMNG *newima = new CxImageMNG;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- info.nNumFrames = newima->info.nNumFrames;
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_TGA
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_TGA==imagetype){
- CxImageTGA *newima = new CxImageTGA;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_PCX
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_PCX==imagetype){
- CxImagePCX *newima = new CxImagePCX;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_WBMP
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_WBMP==imagetype){
- CxImageWBMP *newima = new CxImageWBMP;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_WMF==imagetype){
- CxImageWMF *newima = new CxImageWMF;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_JBG
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_JBG==imagetype){
- CxImageJBG *newima = new CxImageJBG;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_JASPER
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype ||
-#if CXIMAGE_SUPPORT_JP2
- CXIMAGE_FORMAT_JP2==imagetype ||
-#endif
-#if CXIMAGE_SUPPORT_JPC
- CXIMAGE_FORMAT_JPC==imagetype ||
-#endif
-#if CXIMAGE_SUPPORT_PGX
- CXIMAGE_FORMAT_PGX==imagetype ||
-#endif
-#if CXIMAGE_SUPPORT_PNM
- CXIMAGE_FORMAT_PNM==imagetype ||
-#endif
-#if CXIMAGE_SUPPORT_RAS
- CXIMAGE_FORMAT_RAS==imagetype ||
-#endif
- false ){
- CxImageJAS *newima = new CxImageJAS;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_SKA
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_SKA==imagetype){
- CxImageSKA *newima = new CxImageSKA;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_RAW
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_RAW==imagetype){
- CxImageRAW *newima = new CxImageRAW;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-#if CXIMAGE_SUPPORT_PSD
- if (CXIMAGE_FORMAT_UNKNOWN==imagetype || CXIMAGE_FORMAT_PSD==imagetype){
- CxImagePSD *newima = new CxImagePSD;
- if (!newima)
- return false;
- newima->CopyInfo(*this);
- if (newima->Decode(hFile)) {
- Transfer(*newima);
- delete newima;
- return true;
- } else {
- strcpy(info.szLastError,newima->GetLastError());
- hFile->Seek(pos,SEEK_SET);
- delete newima;
- if (CXIMAGE_FORMAT_UNKNOWN!=imagetype)
- return false;
- }
- }
-#endif
-
- strcpy(info.szLastError,"Decode: Unknown or wrong format");
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Loads an image from CxFile object
- * \param hFile: file handle (CxMemFile or CxIOFile), with read access.
- * \param imagetype: file format, default = 0 (CXIMAGE_FORMAT_UNKNOWN)
- * \return : if imagetype is not 0, the function returns true when imagetype
- * matches the file image format. If imagetype is 0, the function returns true
- * when the file image format is recognized as a supported format.
- * If the returned value is true, use GetHeight(), GetWidth() or GetType()
- * to retrieve the basic image information.
- * \sa ENUM_CXIMAGE_FORMATS
- */
-bool CxImage::CheckFormat(CxFile * hFile, uint32_t imagetype)
-{
- SetType(CXIMAGE_FORMAT_UNKNOWN);
- SetEscape(-1);
-
- if (!Decode(hFile,imagetype))
- return false;
-
- if (GetType() == CXIMAGE_FORMAT_UNKNOWN ||
- ((imagetype!=CXIMAGE_FORMAT_UNKNOWN)&&(GetType() != imagetype)))
- return false;
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::CheckFormat(uint8_t * buffer, uint32_t size, uint32_t imagetype)
-{
- if (buffer==NULL || size==0){
- strcpy(info.szLastError,"invalid or empty buffer");
- return false;
- }
- CxMemFile file(buffer,size);
- return CheckFormat(&file,imagetype);
-}
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_EXIF
-bool CxImage::GetExifThumbnail(const TCHAR *filename, const TCHAR *outname, int32_t type)
-{
- switch (type){
-#if CXIMAGE_SUPPORT_RAW
- case CXIMAGE_FORMAT_RAW:
- {
- CxImageRAW image;
- return image.GetExifThumbnail(filename, outname, type);
- }
-#endif //CXIMAGE_SUPPORT_RAW
-#if CXIMAGE_SUPPORT_JPG
- case CXIMAGE_FORMAT_JPG:
- {
- CxImageJPG image;
- return image.GetExifThumbnail(filename, outname, type);
- }
-#endif //CXIMAGE_SUPPORT_JPG
- default:
- return false;
- }
-}
-#endif //CXIMAGE_SUPPORT_EXIF
-
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
diff --git a/smelt/sdl/CxImage/ximaexif.cpp b/smelt/sdl/CxImage/ximaexif.cpp deleted file mode 100644 index f880d72..0000000 --- a/smelt/sdl/CxImage/ximaexif.cpp +++ /dev/null @@ -1,877 +0,0 @@ -/*
- * File: ximaexif.cpp
- * Purpose: EXIF reader
- * 18/Aug/2002 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- * based on jhead-1.8 by Matthias Wandel <mwandel(at)rim(dot)net>
- */
-
-#include "ximajpg.h"
-
-#if CXIMAGEJPG_SUPPORT_EXIF
-
-////////////////////////////////////////////////////////////////////////////////
-CxImageJPG::CxExifInfo::CxExifInfo(EXIFINFO* info)
-{
- if (info) {
- m_exifinfo = info;
- freeinfo = false;
- } else {
- m_exifinfo = new EXIFINFO;
- memset(m_exifinfo,0,sizeof(EXIFINFO));
- freeinfo = true;
- }
-
- m_szLastError[0]='\0';
- ExifImageWidth = MotorolaOrder = 0;
- SectionsRead=0;
- memset(&Sections, 0, MAX_SECTIONS * sizeof(Section_t));
-}
-////////////////////////////////////////////////////////////////////////////////
-CxImageJPG::CxExifInfo::~CxExifInfo()
-{
- for(int32_t i=0;i<MAX_SECTIONS;i++) if(Sections[i].Data) free(Sections[i].Data);
- if (freeinfo) delete m_exifinfo;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageJPG::CxExifInfo::DecodeExif(CxFile * hFile, int32_t nReadMode)
-{
- int32_t a;
- int32_t HaveCom = FALSE;
-
- a = hFile->GetC();
-
- if (a != 0xff || hFile->GetC() != M_SOI){
- return FALSE;
- }
-
- for(;;){
- int32_t itemlen;
- int32_t marker = 0;
- int32_t ll,lh, got;
- uint8_t * Data;
-
- if (SectionsRead >= MAX_SECTIONS){
- strcpy(m_szLastError,"Too many sections in jpg file");
- return false;
- }
-
- for (a=0;a<7;a++){
- marker = hFile->GetC();
- if (marker != 0xff) break;
-
- if (a >= 6){
- printf("too many padding bytes\n");
- return false;
- }
- }
-
- if (marker == 0xff){
- // 0xff is legal padding, but if we get that many, something's wrong.
- strcpy(m_szLastError,"too many padding bytes!");
- return false;
- }
-
- Sections[SectionsRead].Type = marker;
-
- // Read the length of the section.
- lh = hFile->GetC();
- ll = hFile->GetC();
-
- itemlen = (lh << 8) | ll;
-
- if (itemlen < 2){
- strcpy(m_szLastError,"invalid marker");
- return false;
- }
-
- Sections[SectionsRead].Size = itemlen;
-
- Data = (uint8_t *)malloc(itemlen);
- if (Data == NULL){
- strcpy(m_szLastError,"Could not allocate memory");
- return false;
- }
- Sections[SectionsRead].Data = Data;
-
- // Store first two pre-read bytes.
- Data[0] = (uint8_t)lh;
- Data[1] = (uint8_t)ll;
-
- got = hFile->Read(Data+2, 1, itemlen-2); // Read the whole section.
- if (got != itemlen-2){
- strcpy(m_szLastError,"Premature end of file?");
- return false;
- }
- SectionsRead += 1;
-
- switch(marker){
-
- case M_SOS: // stop before hitting compressed data
- // If reading entire image is requested, read the rest of the data.
- if (nReadMode & EXIF_READ_IMAGE){
- int32_t cp, ep, size;
- // Determine how much file is left.
- cp = hFile->Tell();
- hFile->Seek(0, SEEK_END);
- ep = hFile->Tell();
- hFile->Seek(cp, SEEK_SET);
-
- size = ep-cp;
- Data = (uint8_t *)malloc(size);
- if (Data == NULL){
- strcpy(m_szLastError,"could not allocate data for entire image");
- return false;
- }
-
- got = hFile->Read(Data, 1, size);
- if (got != size){
- strcpy(m_szLastError,"could not read the rest of the image");
- return false;
- }
-
- Sections[SectionsRead].Data = Data;
- Sections[SectionsRead].Size = size;
- Sections[SectionsRead].Type = PSEUDO_IMAGE_MARKER;
- SectionsRead ++;
- }
- return true;
-
- case M_EOI: // in case it's a tables-only JPEG stream
- printf("No image in jpeg!\n");
- return FALSE;
-
- case M_COM: // Comment section
- if (HaveCom || ((nReadMode & EXIF_READ_EXIF) == 0)){
- // Discard this section.
- free(Sections[--SectionsRead].Data);
- Sections[SectionsRead].Data=0;
- }else{
- process_COM(Data, itemlen);
- HaveCom = TRUE;
- }
- break;
-
- case M_JFIF:
- // Regular jpegs always have this tag, exif images have the exif
- // marker instead, althogh ACDsee will write images with both markers.
- // this program will re-create this marker on absence of exif marker.
- // hence no need to keep the copy from the file.
- free(Sections[--SectionsRead].Data);
- Sections[SectionsRead].Data=0;
- break;
-
- case M_EXIF:
- // Seen files from some 'U-lead' software with Vivitar scanner
- // that uses marker 31 for non exif stuff. Thus make sure
- // it says 'Exif' in the section before treating it as exif.
- if ((nReadMode & EXIF_READ_EXIF) && memcmp(Data+2, "Exif", 4) == 0){
- m_exifinfo->IsExif = process_EXIF((uint8_t *)Data+2, itemlen);
- }else{
- // Discard this section.
- free(Sections[--SectionsRead].Data);
- Sections[SectionsRead].Data=0;
- }
- break;
-
- case M_SOF0:
- case M_SOF1:
- case M_SOF2:
- case M_SOF3:
- case M_SOF5:
- case M_SOF6:
- case M_SOF7:
- case M_SOF9:
- case M_SOF10:
- case M_SOF11:
- case M_SOF13:
- case M_SOF14:
- case M_SOF15:
- process_SOFn(Data, marker);
- break;
- default:
- // Skip any other sections.
- //if (ShowTags) printf("Jpeg section marker 0x%02x size %d\n",marker, itemlen);
- break;
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/*--------------------------------------------------------------------------
- Process a EXIF marker
- Describes all the drivel that most digital cameras include...
---------------------------------------------------------------------------*/
-bool CxImageJPG::CxExifInfo::process_EXIF(uint8_t * CharBuf, uint32_t length)
-{
- m_exifinfo->FlashUsed = 0;
- /* If it's from a digicam, and it used flash, it says so. */
- m_exifinfo->Comments[0] = '\0'; /* Initial value - null string */
-
- ExifImageWidth = 0;
-
- { /* Check the EXIF header component */
- static const uint8_t ExifHeader[] = "Exif\0\0";
- if (memcmp(CharBuf+0, ExifHeader,6)){
- strcpy(m_szLastError,"Incorrect Exif header");
- return false;
- }
- }
-
- if (memcmp(CharBuf+6,"II",2) == 0){
- MotorolaOrder = 0;
- }else{
- if (memcmp(CharBuf+6,"MM",2) == 0){
- MotorolaOrder = 1;
- }else{
- strcpy(m_szLastError,"Invalid Exif alignment marker.");
- return false;
- }
- }
-
- /* Check the next two values for correctness. */
- if (Get16u(CharBuf+8) != 0x2a){
- strcpy(m_szLastError,"Invalid Exif start (1)");
- return false;
- }
-
- int32_t FirstOffset = Get32u(CharBuf+10);
- /* <Richard Collins>
- if (FirstOffset < 8 || FirstOffset > 16){
- // I used to ensure this was set to 8 (website I used indicated its 8)
- // but PENTAX Optio 230 has it set differently, and uses it as offset. (Sept 11 2002)
- strcpy(m_szLastError,"Suspicious offset of first IFD value");
- return false;
- }*/
-
- uint8_t * LastExifRefd = CharBuf;
-
- /* First directory starts 16 bytes in. Offsets start at 8 bytes in. */
- if (!ProcessExifDir(CharBuf+14, CharBuf+6, length-6, m_exifinfo, &LastExifRefd))
- return false;
-
- /* <Richard Collins> give a chance for a second directory */
- if (FirstOffset > 8) {
- if (!ProcessExifDir(CharBuf+14+FirstOffset-8, CharBuf+6, length-6, m_exifinfo, &LastExifRefd))
- return false;
- }
-
- /* This is how far the interesting (non thumbnail) part of the exif went. */
- // int32_t ExifSettingsLength = LastExifRefd - CharBuf;
-
- /* Compute the CCD width, in milimeters. */
- if (m_exifinfo->FocalplaneXRes != 0){
- m_exifinfo->CCDWidth = (float)(ExifImageWidth * m_exifinfo->FocalplaneUnits / m_exifinfo->FocalplaneXRes);
- }
-
- return true;
-}
-//--------------------------------------------------------------------------
-// Get 16 bits motorola order (always) for jpeg header stuff.
-//--------------------------------------------------------------------------
-int32_t CxImageJPG::CxExifInfo::Get16m(void * Short)
-{
- return (((uint8_t *)Short)[0] << 8) | ((uint8_t *)Short)[1];
-}
-////////////////////////////////////////////////////////////////////////////////
-/*--------------------------------------------------------------------------
- Convert a 16 bit unsigned value from file's native byte order
---------------------------------------------------------------------------*/
-int32_t CxImageJPG::CxExifInfo::Get16u(void * Short)
-{
- if (MotorolaOrder){
- return (((uint8_t *)Short)[0] << 8) | ((uint8_t *)Short)[1];
- }else{
- return (((uint8_t *)Short)[1] << 8) | ((uint8_t *)Short)[0];
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/*--------------------------------------------------------------------------
- Convert a 32 bit signed value from file's native byte order
---------------------------------------------------------------------------*/
-int32_t CxImageJPG::CxExifInfo::Get32s(void * Long)
-{
- if (MotorolaOrder){
- return ((( char *)Long)[0] << 24) | (((uint8_t *)Long)[1] << 16)
- | (((uint8_t *)Long)[2] << 8 ) | (((uint8_t *)Long)[3] << 0 );
- }else{
- return ((( char *)Long)[3] << 24) | (((uint8_t *)Long)[2] << 16)
- | (((uint8_t *)Long)[1] << 8 ) | (((uint8_t *)Long)[0] << 0 );
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/*--------------------------------------------------------------------------
- Convert a 32 bit unsigned value from file's native byte order
---------------------------------------------------------------------------*/
-uint32_t CxImageJPG::CxExifInfo::Get32u(void * Long)
-{
- return (uint32_t)Get32s(Long) & 0xffffffff;
-}
-////////////////////////////////////////////////////////////////////////////////
-
-/* Describes format descriptor */
-static const int32_t BytesPerFormat[] = {0,1,1,2,4,8,1,1,2,4,8,4,8};
-#define NUM_FORMATS 12
-
-#define FMT_BYTE 1
-#define FMT_STRING 2
-#define FMT_USHORT 3
-#define FMT_ULONG 4
-#define FMT_URATIONAL 5
-#define FMT_SBYTE 6
-#define FMT_UNDEFINED 7
-#define FMT_SSHORT 8
-#define FMT_SLONG 9
-#define FMT_SRATIONAL 10
-#define FMT_SINGLE 11
-#define FMT_DOUBLE 12
-
-/* Describes tag values */
-
-#define TAG_EXIF_VERSION 0x9000
-#define TAG_EXIF_OFFSET 0x8769
-#define TAG_INTEROP_OFFSET 0xa005
-
-#define TAG_MAKE 0x010F
-#define TAG_MODEL 0x0110
-
-#define TAG_ORIENTATION 0x0112
-#define TAG_XRESOLUTION 0x011A
-#define TAG_YRESOLUTION 0x011B
-#define TAG_RESOLUTIONUNIT 0x0128
-
-#define TAG_EXPOSURETIME 0x829A
-#define TAG_FNUMBER 0x829D
-
-#define TAG_SHUTTERSPEED 0x9201
-#define TAG_APERTURE 0x9202
-#define TAG_BRIGHTNESS 0x9203
-#define TAG_MAXAPERTURE 0x9205
-#define TAG_FOCALLENGTH 0x920A
-
-#define TAG_DATETIME_ORIGINAL 0x9003
-#define TAG_USERCOMMENT 0x9286
-
-#define TAG_SUBJECT_DISTANCE 0x9206
-#define TAG_FLASH 0x9209
-
-#define TAG_FOCALPLANEXRES 0xa20E
-#define TAG_FOCALPLANEYRES 0xa20F
-#define TAG_FOCALPLANEUNITS 0xa210
-#define TAG_EXIF_IMAGEWIDTH 0xA002
-#define TAG_EXIF_IMAGELENGTH 0xA003
-
-/* the following is added 05-jan-2001 vcs */
-#define TAG_EXPOSURE_BIAS 0x9204
-#define TAG_WHITEBALANCE 0x9208
-#define TAG_METERING_MODE 0x9207
-#define TAG_EXPOSURE_PROGRAM 0x8822
-#define TAG_ISO_EQUIVALENT 0x8827
-#define TAG_COMPRESSION_LEVEL 0x9102
-
-#define TAG_THUMBNAIL_OFFSET 0x0201
-#define TAG_THUMBNAIL_LENGTH 0x0202
-
-
-/*--------------------------------------------------------------------------
- Process one of the nested EXIF directories.
---------------------------------------------------------------------------*/
-bool CxImageJPG::CxExifInfo::ProcessExifDir(uint8_t * DirStart, uint8_t * OffsetBase, unsigned ExifLength,
- EXIFINFO * const m_exifinfo, uint8_t ** const LastExifRefdP, int32_t NestingLevel)
-{
- int32_t de;
- int32_t a;
- int32_t NumDirEntries;
- unsigned ThumbnailOffset = 0;
- unsigned ThumbnailSize = 0;
-
- if (NestingLevel > 4){
- strcpy(m_szLastError,"Maximum directory nesting exceeded (corrupt exif header)");
- return false;
- }
-
- NumDirEntries = Get16u(DirStart);
-
- if ((DirStart+2+NumDirEntries*12) > (OffsetBase+ExifLength)){
- strcpy(m_szLastError,"Illegally sized directory");
- return false;
- }
-
- for (de=0;de<NumDirEntries;de++){
- int32_t Tag, Format, Components;
- uint8_t * ValuePtr;
- /* This actually can point to a variety of things; it must be
- cast to other types when used. But we use it as a byte-by-byte
- cursor, so we declare it as a pointer to a generic byte here.
- */
- int32_t ByteCount;
- uint8_t * DirEntry;
- DirEntry = DirStart+2+12*de;
-
- Tag = Get16u(DirEntry);
- Format = Get16u(DirEntry+2);
- Components = Get32u(DirEntry+4);
-
- if ((Format-1) >= NUM_FORMATS) {
- /* (-1) catches illegal zero case as unsigned underflows to positive large */
- strcpy(m_szLastError,"Illegal format code in EXIF dir");
- return false;
- }
-
- ByteCount = Components * BytesPerFormat[Format];
-
- if (ByteCount > 4){
- unsigned OffsetVal;
- OffsetVal = Get32u(DirEntry+8);
- /* If its bigger than 4 bytes, the dir entry contains an offset.*/
- if (OffsetVal+ByteCount > ExifLength){
- /* Bogus pointer offset and / or bytecount value */
- strcpy(m_szLastError,"Illegal pointer offset value in EXIF.");
- return false;
- }
- ValuePtr = OffsetBase+OffsetVal;
- }else{
- /* 4 bytes or less and value is in the dir entry itself */
- ValuePtr = DirEntry+8;
- }
-
- if (*LastExifRefdP < ValuePtr+ByteCount){
- /* Keep track of last byte in the exif header that was
- actually referenced. That way, we know where the
- discardable thumbnail data begins.
- */
- *LastExifRefdP = ValuePtr+ByteCount;
- }
-
- /* Extract useful components of tag */
- switch(Tag){
-
- case TAG_MAKE:
- strncpy(m_exifinfo->CameraMake, (char*)ValuePtr, 31);
- break;
-
- case TAG_MODEL:
- strncpy(m_exifinfo->CameraModel, (char*)ValuePtr, 39);
- break;
-
- case TAG_EXIF_VERSION:
- strncpy(m_exifinfo->Version,(char*)ValuePtr, 4);
- break;
-
- case TAG_DATETIME_ORIGINAL:
- strncpy(m_exifinfo->DateTime, (char*)ValuePtr, 19);
- break;
-
- case TAG_USERCOMMENT:
- // Olympus has this padded with trailing spaces. Remove these first.
- for (a=ByteCount;;){
- a--;
- if (((char*)ValuePtr)[a] == ' '){
- ((char*)ValuePtr)[a] = '\0';
- }else{
- break;
- }
- if (a == 0) break;
- }
-
- /* Copy the comment */
- if (memcmp(ValuePtr, "ASCII",5) == 0){
- for (a=5;a<10;a++){
- char c;
- c = ((char*)ValuePtr)[a];
- if (c != '\0' && c != ' '){
- strncpy(m_exifinfo->Comments, (char*)ValuePtr+a, 199);
- break;
- }
- }
-
- }else{
- strncpy(m_exifinfo->Comments, (char*)ValuePtr, 199);
- }
- break;
-
- case TAG_FNUMBER:
- /* Simplest way of expressing aperture, so I trust it the most.
- (overwrite previously computd value if there is one)
- */
- m_exifinfo->ApertureFNumber = (float)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_APERTURE:
- case TAG_MAXAPERTURE:
- /* More relevant info always comes earlier, so only
- use this field if we don't have appropriate aperture
- information yet.
- */
- if (m_exifinfo->ApertureFNumber == 0){
- m_exifinfo->ApertureFNumber = (float)exp(ConvertAnyFormat(ValuePtr, Format)*log(2.0f)*0.5);
- }
- break;
-
- case TAG_BRIGHTNESS:
- m_exifinfo->Brightness = (float)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_FOCALLENGTH:
- /* Nice digital cameras actually save the focal length
- as a function of how farthey are zoomed in.
- */
-
- m_exifinfo->FocalLength = (float)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_SUBJECT_DISTANCE:
- /* Inidcates the distacne the autofocus camera is focused to.
- Tends to be less accurate as distance increases.
- */
- m_exifinfo->Distance = (float)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_EXPOSURETIME:
- /* Simplest way of expressing exposure time, so I
- trust it most. (overwrite previously computd value
- if there is one)
- */
- m_exifinfo->ExposureTime =
- (float)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_SHUTTERSPEED:
- /* More complicated way of expressing exposure time,
- so only use this value if we don't already have it
- from somewhere else.
- */
- if (m_exifinfo->ExposureTime == 0){
- m_exifinfo->ExposureTime = (float)
- (1/exp(ConvertAnyFormat(ValuePtr, Format)*log(2.0f)));
- }
- break;
-
- case TAG_FLASH:
- if ((int32_t)ConvertAnyFormat(ValuePtr, Format) & 7){
- m_exifinfo->FlashUsed = 1;
- }else{
- m_exifinfo->FlashUsed = 0;
- }
- break;
-
- case TAG_ORIENTATION:
- m_exifinfo->Orientation = (int32_t)ConvertAnyFormat(ValuePtr, Format);
- if (m_exifinfo->Orientation < 1 || m_exifinfo->Orientation > 8){
- strcpy(m_szLastError,"Undefined rotation value");
- m_exifinfo->Orientation = 0;
- }
- break;
-
- case TAG_EXIF_IMAGELENGTH:
- case TAG_EXIF_IMAGEWIDTH:
- /* Use largest of height and width to deal with images
- that have been rotated to portrait format.
- */
- a = (int32_t)ConvertAnyFormat(ValuePtr, Format);
- if (ExifImageWidth < a) ExifImageWidth = a;
- break;
-
- case TAG_FOCALPLANEXRES:
- m_exifinfo->FocalplaneXRes = (float)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_FOCALPLANEYRES:
- m_exifinfo->FocalplaneYRes = (float)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_RESOLUTIONUNIT:
- switch((int32_t)ConvertAnyFormat(ValuePtr, Format)){
- case 1: m_exifinfo->ResolutionUnit = 1.0f; break; /* 1 inch */
- case 2: m_exifinfo->ResolutionUnit = 1.0f; break;
- case 3: m_exifinfo->ResolutionUnit = 0.3937007874f; break; /* 1 centimeter*/
- case 4: m_exifinfo->ResolutionUnit = 0.03937007874f; break; /* 1 millimeter*/
- case 5: m_exifinfo->ResolutionUnit = 0.00003937007874f; /* 1 micrometer*/
- }
- break;
-
- case TAG_FOCALPLANEUNITS:
- switch((int32_t)ConvertAnyFormat(ValuePtr, Format)){
- case 1: m_exifinfo->FocalplaneUnits = 1.0f; break; /* 1 inch */
- case 2: m_exifinfo->FocalplaneUnits = 1.0f; break;
- case 3: m_exifinfo->FocalplaneUnits = 0.3937007874f; break; /* 1 centimeter*/
- case 4: m_exifinfo->FocalplaneUnits = 0.03937007874f; break; /* 1 millimeter*/
- case 5: m_exifinfo->FocalplaneUnits = 0.00003937007874f; /* 1 micrometer*/
- }
- break;
-
- // Remaining cases contributed by: Volker C. Schoech <schoech(at)gmx(dot)de>
-
- case TAG_EXPOSURE_BIAS:
- m_exifinfo->ExposureBias = (float) ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_WHITEBALANCE:
- m_exifinfo->Whitebalance = (int32_t)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_METERING_MODE:
- m_exifinfo->MeteringMode = (int32_t)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_EXPOSURE_PROGRAM:
- m_exifinfo->ExposureProgram = (int32_t)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_ISO_EQUIVALENT:
- m_exifinfo->ISOequivalent = (int32_t)ConvertAnyFormat(ValuePtr, Format);
- if ( m_exifinfo->ISOequivalent < 50 ) m_exifinfo->ISOequivalent *= 200;
- break;
-
- case TAG_COMPRESSION_LEVEL:
- m_exifinfo->CompressionLevel = (int32_t)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_XRESOLUTION:
- m_exifinfo->Xresolution = (float)ConvertAnyFormat(ValuePtr, Format);
- break;
- case TAG_YRESOLUTION:
- m_exifinfo->Yresolution = (float)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_THUMBNAIL_OFFSET:
- ThumbnailOffset = (unsigned)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- case TAG_THUMBNAIL_LENGTH:
- ThumbnailSize = (unsigned)ConvertAnyFormat(ValuePtr, Format);
- break;
-
- }
-
- if (Tag == TAG_EXIF_OFFSET || Tag == TAG_INTEROP_OFFSET){
- uint8_t * SubdirStart;
- unsigned Offset = Get32u(ValuePtr);
- if (Offset>8){
- SubdirStart = OffsetBase + Offset;
- if (SubdirStart < OffsetBase ||
- SubdirStart > OffsetBase+ExifLength){
- strcpy(m_szLastError,"Illegal subdirectory link");
- return false;
- }
- ProcessExifDir(SubdirStart, OffsetBase, ExifLength, m_exifinfo, LastExifRefdP, NestingLevel+1);
- }
- continue;
- }
- }
-
-
- {
- /* In addition to linking to subdirectories via exif tags,
- there's also a potential link to another directory at the end
- of each directory. This has got to be the result of a
- committee!
- */
- uint8_t * SubdirStart;
- unsigned Offset;
- Offset = Get16u(DirStart+2+12*NumDirEntries);
- if (Offset){
- SubdirStart = OffsetBase + Offset;
- if (SubdirStart < OffsetBase
- || SubdirStart > OffsetBase+ExifLength){
- strcpy(m_szLastError,"Illegal subdirectory link");
- return false;
- }
- ProcessExifDir(SubdirStart, OffsetBase, ExifLength, m_exifinfo, LastExifRefdP, NestingLevel+1);
- }
- }
-
-
- if (ThumbnailSize && ThumbnailOffset){
- if (ThumbnailSize + ThumbnailOffset <= ExifLength){
- /* The thumbnail pointer appears to be valid. Store it. */
- m_exifinfo->ThumbnailPointer = OffsetBase + ThumbnailOffset;
- m_exifinfo->ThumbnailSize = ThumbnailSize;
- }
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/*--------------------------------------------------------------------------
- Evaluate number, be it int32_t, rational, or float from directory.
---------------------------------------------------------------------------*/
-double CxImageJPG::CxExifInfo::ConvertAnyFormat(void * ValuePtr, int32_t Format)
-{
- double Value;
- Value = 0;
-
- switch(Format){
- case FMT_SBYTE: Value = *(signed char *)ValuePtr; break;
- case FMT_BYTE: Value = *(uint8_t *)ValuePtr; break;
-
- case FMT_USHORT: Value = Get16u(ValuePtr); break;
- case FMT_ULONG: Value = Get32u(ValuePtr); break;
-
- case FMT_URATIONAL:
- case FMT_SRATIONAL:
- {
- int32_t Num,Den;
- Num = Get32s(ValuePtr);
- Den = Get32s(4+(char *)ValuePtr);
- if (Den == 0){
- Value = 0;
- }else{
- Value = (double)Num/Den;
- }
- break;
- }
-
- case FMT_SSHORT: Value = (int16_t)Get16u(ValuePtr); break;
- case FMT_SLONG: Value = Get32s(ValuePtr); break;
-
- /* Not sure if this is correct (never seen float used in Exif format)
- */
- case FMT_SINGLE: Value = (double)*(float *)ValuePtr; break;
- case FMT_DOUBLE: Value = *(double *)ValuePtr; break;
- }
- return Value;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageJPG::CxExifInfo::process_COM (const uint8_t * Data, int32_t length)
-{
- int32_t ch;
- char Comment[MAX_COMMENT+1];
- int32_t nch;
- int32_t a;
-
- nch = 0;
-
- if (length > MAX_COMMENT) length = MAX_COMMENT; // Truncate if it won't fit in our structure.
-
- for (a=2;a<length;a++){
- ch = Data[a];
-
- if (ch == '\r' && Data[a+1] == '\n') continue; // Remove cr followed by lf.
-
- if (isprint(ch) || ch == '\n' || ch == '\t'){
- Comment[nch++] = (char)ch;
- }else{
- Comment[nch++] = '?';
- }
- }
-
- Comment[nch] = '\0'; // Null terminate
-
- //if (ShowTags) printf("COM marker comment: %s\n",Comment);
-
- strcpy(m_exifinfo->Comments,Comment);
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageJPG::CxExifInfo::process_SOFn (const uint8_t * Data, int32_t marker)
-{
- int32_t data_precision, num_components;
-
- data_precision = Data[2];
- m_exifinfo->Height = Get16m((void*)(Data+3));
- m_exifinfo->Width = Get16m((void*)(Data+5));
- num_components = Data[7];
-
- if (num_components == 3){
- m_exifinfo->IsColor = 1;
- }else{
- m_exifinfo->IsColor = 0;
- }
-
- m_exifinfo->Process = marker;
-
- //if (ShowTags) printf("JPEG image is %uw * %uh, %d color components, %d bits per sample\n",
- // ImageInfo.Width, ImageInfo.Height, num_components, data_precision);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * this will work only on a CxImageJPG object, if the image originally has valid EXIF data
- \verbatim
- CxImageJPG jpg;
- CxIOFile in,out;
- in.Open("D:\\exif_in.jpg","rb");
- out.Open("D:\\exif_out.jpg","w+b");
- jpg.Decode(&in);
- if (jpg.IsValid()){
- jpg.RotateLeft();
- jpg.Encode(&out);
- }
- \endverbatim
-*/
-bool CxImageJPG::CxExifInfo::EncodeExif(CxFile * hFile)
-{
- int32_t a;
-
- if (FindSection(M_SOS)==NULL){
- strcpy(m_szLastError,"Can't write exif : didn't read all");
- return false;
- }
-
- // Initial static jpeg marker.
- hFile->PutC(0xff);
- hFile->PutC(0xd8);
-
- if (Sections[0].Type != M_EXIF && Sections[0].Type != M_JFIF){
- // The image must start with an exif or jfif marker. If we threw those away, create one.
- static uint8_t JfifHead[18] = {
- 0xff, M_JFIF,
- 0x00, 0x10, 'J' , 'F' , 'I' , 'F' , 0x00, 0x01,
- 0x01, 0x01, 0x01, 0x2C, 0x01, 0x2C, 0x00, 0x00
- };
- hFile->Write(JfifHead, 18, 1);
- }
-
- // Write all the misc sections
- for (a=0;a<SectionsRead-1;a++){
- hFile->PutC(0xff);
- hFile->PutC((uint8_t)(Sections[a].Type));
- hFile->Write(Sections[a].Data, Sections[a].Size, 1);
- }
-
- // Write the remaining image data.
- hFile->Write(Sections[a].Data, Sections[a].Size, 1);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageJPG::CxExifInfo::DiscardAllButExif()
-{
- Section_t ExifKeeper;
- Section_t CommentKeeper;
- int32_t a;
-
- memset(&ExifKeeper, 0, sizeof(ExifKeeper));
- memset(&CommentKeeper, 0, sizeof(ExifKeeper));
-
- for (a=0;a<SectionsRead;a++){
- if (Sections[a].Type == M_EXIF && ExifKeeper.Type == 0){
- ExifKeeper = Sections[a];
- }else if (Sections[a].Type == M_COM && CommentKeeper.Type == 0){
- CommentKeeper = Sections[a];
- }else{
- free(Sections[a].Data);
- Sections[a].Data = 0;
- }
- }
- SectionsRead = 0;
- if (ExifKeeper.Type){
- Sections[SectionsRead++] = ExifKeeper;
- }
- if (CommentKeeper.Type){
- Sections[SectionsRead++] = CommentKeeper;
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void* CxImageJPG::CxExifInfo::FindSection(int32_t SectionType)
-{
- int32_t a;
- for (a=0;a<SectionsRead-1;a++){
- if (Sections[a].Type == SectionType){
- return &Sections[a];
- }
- }
- // Could not be found.
- return NULL;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGEJPG_SUPPORT_EXIF
diff --git a/smelt/sdl/CxImage/ximage.cpp b/smelt/sdl/CxImage/ximage.cpp deleted file mode 100644 index 904b807..0000000 --- a/smelt/sdl/CxImage/ximage.cpp +++ /dev/null @@ -1,537 +0,0 @@ -// ximage.cpp : main implementation file
-/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximage.h"
-
-////////////////////////////////////////////////////////////////////////////////
-// CxImage
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Initialize the internal structures
- */
-void CxImage::Startup(uint32_t imagetype)
-{
- //init pointers
- pDib = pSelection = pAlpha = NULL;
- ppLayers = ppFrames = NULL;
- //init structures
- memset(&head,0,sizeof(BITMAPINFOHEADER));
- memset(&info,0,sizeof(CXIMAGEINFO));
- //init default attributes
- info.dwType = imagetype;
- info.fQuality = 90.0f;
- info.nAlphaMax = 255;
- info.nBkgndIndex = -1;
- info.bEnabled = true;
- info.nJpegScale = 1;
- SetXDPI(CXIMAGE_DEFAULT_DPI);
- SetYDPI(CXIMAGE_DEFAULT_DPI);
-
- int16_t test = 1;
- info.bLittleEndianHost = (*((char *) &test) == 1);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Empty image constructor
- * \param imagetype: (optional) set the image format, see ENUM_CXIMAGE_FORMATS
- */
-CxImage::CxImage(uint32_t imagetype)
-{
- Startup(imagetype);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Call this function to destroy image pixels, alpha channel, selection and sub layers.
- * - Attributes are not erased, but IsValid returns false.
- *
- * \return true if everything is freed, false if the image is a Ghost
- */
-bool CxImage::Destroy()
-{
- //free this only if it's valid and it's not a ghost
- if (info.pGhost==NULL){
- if (ppLayers) {
- for(int32_t n=0; n<info.nNumLayers;n++){ delete ppLayers[n]; }
- delete [] ppLayers; ppLayers=0; info.nNumLayers = 0;
- }
- if (pSelection) {free(pSelection); pSelection=0;}
- if (pAlpha) {free(pAlpha); pAlpha=0;}
- if (pDib) {free(pDib); pDib=0;}
- return true;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::DestroyFrames()
-{
- if (info.pGhost==NULL) {
- if (ppFrames) {
- for (int32_t n=0; n<info.nNumFrames; n++) { delete ppFrames[n]; }
- delete [] ppFrames; ppFrames = NULL; info.nNumFrames = 0;
- }
- return true;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sized image constructor
- * \param dwWidth: width
- * \param dwHeight: height
- * \param wBpp: bit per pixel, can be 1, 4, 8, 24
- * \param imagetype: (optional) set the image format, see ENUM_CXIMAGE_FORMATS
- */
-CxImage::CxImage(uint32_t dwWidth, uint32_t dwHeight, uint32_t wBpp, uint32_t imagetype)
-{
- Startup(imagetype);
- Create(dwWidth,dwHeight,wBpp,imagetype);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * image constructor from existing source
- * \param src: source image.
- * \param copypixels: copy the pixels from the source image into the new image.
- * \param copyselection: copy the selection from source
- * \param copyalpha: copy the alpha channel from source
- * \sa Copy
- */
-CxImage::CxImage(const CxImage &src, bool copypixels, bool copyselection, bool copyalpha)
-{
- Startup(src.GetType());
- Copy(src,copypixels,copyselection,copyalpha);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Copies the image from an exsisting source
- * \param src: source image.
- * \param copypixels: copy the pixels from the source image into the new image.
- * \param copyselection: copy the selection from source
- * \param copyalpha: copy the alpha channel from source
- */
-void CxImage::Copy(const CxImage &src, bool copypixels, bool copyselection, bool copyalpha)
-{
- // if the source is a ghost, the copy is still a ghost
- if (src.info.pGhost){
- Ghost(&src);
- return;
- }
- //copy the attributes
- memcpy(&info,&src.info,sizeof(CXIMAGEINFO));
- memcpy(&head,&src.head,sizeof(BITMAPINFOHEADER)); // [andy] - fix for bitmap header DPI
- //rebuild the image
- Create(src.GetWidth(),src.GetHeight(),src.GetBpp(),src.GetType());
- //copy the pixels and the palette, or at least copy the palette only.
- if (copypixels && pDib && src.pDib) memcpy(pDib,src.pDib,GetSize());
- else SetPalette(src.GetPalette());
- int32_t nSize = head.biWidth * head.biHeight;
- //copy the selection
- if (copyselection && src.pSelection){
- if (pSelection) free(pSelection);
- pSelection = (uint8_t*)malloc(nSize);
- memcpy(pSelection,src.pSelection,nSize);
- }
- //copy the alpha channel
- if (copyalpha && src.pAlpha){
- if (pAlpha) free(pAlpha);
- pAlpha = (uint8_t*)malloc(nSize);
- memcpy(pAlpha,src.pAlpha,nSize);
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Copies the image attributes from an existing image.
- * - Works only on an empty image, and the image will be still empty.
- * - <b> Use it before Create() </b>
- */
-void CxImage::CopyInfo(const CxImage &src)
-{
- if (pDib==NULL) memcpy(&info,&src.info,sizeof(CXIMAGEINFO));
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \sa Copy
- */
-CxImage& CxImage::operator = (const CxImage& isrc)
-{
- if (this != &isrc) Copy(isrc);
- return *this;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Initializes or rebuilds the image.
- * \param dwWidth: width
- * \param dwHeight: height
- * \param wBpp: bit per pixel, can be 1, 4, 8, 24
- * \param imagetype: (optional) set the image format, see ENUM_CXIMAGE_FORMATS
- * \return pointer to the internal pDib object; NULL if an error occurs.
- */
-void* CxImage::Create(uint32_t dwWidth, uint32_t dwHeight, uint32_t wBpp, uint32_t imagetype)
-{
- // destroy the existing image (if any)
- if (!Destroy())
- return NULL;
-
- // prevent further actions if width or height are not vaild <Balabasnia>
- if ((dwWidth == 0) || (dwHeight == 0)){
- strcpy(info.szLastError,"CxImage::Create : width and height must be greater than zero");
- return NULL;
- }
-
- // Make sure bits per pixel is valid
- if (wBpp <= 1) wBpp = 1;
- else if (wBpp <= 4) wBpp = 4;
- else if (wBpp <= 8) wBpp = 8;
- else wBpp = 24;
-
- // limit memory requirements
- if ((((float)dwWidth*(float)dwHeight*(float)wBpp)/8.0f) > (float)CXIMAGE_MAX_MEMORY)
- {
- strcpy(info.szLastError,"CXIMAGE_MAX_MEMORY exceeded");
- return NULL;
- }
-
- // set the correct bpp value
- switch (wBpp){
- case 1:
- head.biClrUsed = 2; break;
- case 4:
- head.biClrUsed = 16; break;
- case 8:
- head.biClrUsed = 256; break;
- default:
- head.biClrUsed = 0;
- }
-
- //set the common image informations
- info.dwEffWidth = ((((wBpp * dwWidth) + 31) / 32) * 4);
- info.dwType = imagetype;
-
- // initialize BITMAPINFOHEADER
- head.biSize = sizeof(BITMAPINFOHEADER); //<ralphw>
- head.biWidth = dwWidth; // fill in width from parameter
- head.biHeight = dwHeight; // fill in height from parameter
- head.biPlanes = 1; // must be 1
- head.biBitCount = (uint16_t)wBpp; // from parameter
- head.biCompression = BI_RGB;
- head.biSizeImage = info.dwEffWidth * dwHeight;
-// head.biXPelsPerMeter = 0; See SetXDPI
-// head.biYPelsPerMeter = 0; See SetYDPI
-// head.biClrImportant = 0; See SetClrImportant
-
- pDib = malloc(GetSize()); // alloc memory block to store our bitmap
- if (!pDib){
- strcpy(info.szLastError,"CxImage::Create can't allocate memory");
- return NULL;
- }
-
- //clear the palette
- RGBQUAD* pal=GetPalette();
- if (pal) memset(pal,0,GetPaletteSize());
- //Destroy the existing selection
-#if CXIMAGE_SUPPORT_SELECTION
- if (pSelection) SelectionDelete();
-#endif //CXIMAGE_SUPPORT_SELECTION
- //Destroy the existing alpha channel
-#if CXIMAGE_SUPPORT_ALPHA
- if (pAlpha) AlphaDelete();
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- // use our bitmap info structure to fill in first part of
- // our DIB with the BITMAPINFOHEADER
- BITMAPINFOHEADER* lpbi;
- lpbi = (BITMAPINFOHEADER*)(pDib);
- *lpbi = head;
-
- info.pImage=GetBits();
-
- return pDib; //return handle to the DIB
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return pointer to the image pixels. <b> USE CAREFULLY </b>
- */
-uint8_t* CxImage::GetBits(uint32_t row)
-{
- if (pDib){
- if (row) {
- if (row<(uint32_t)head.biHeight){
- return ((uint8_t*)pDib + *(uint32_t*)pDib + GetPaletteSize() + (info.dwEffWidth * row));
- } else {
- return NULL;
- }
- } else {
- return ((uint8_t*)pDib + *(uint32_t*)pDib + GetPaletteSize());
- }
- }
- return NULL;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return the size in bytes of the internal pDib object
- */
-int32_t CxImage::GetSize()
-{
- return head.biSize + head.biSizeImage + GetPaletteSize();
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks if the coordinates are inside the image
- * \return true if x and y are both inside the image
- */
-bool CxImage::IsInside(int32_t x, int32_t y)
-{
- return (0<=y && y<head.biHeight && 0<=x && x<head.biWidth);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets the image bits to the specified value
- * - for indexed images, the output color is set by the palette entries.
- * - for RGB images, the output color is a shade of gray.
- */
-void CxImage::Clear(uint8_t bval)
-{
- if (pDib == 0) return;
-
- if (GetBpp() == 1){
- if (bval > 0) bval = 255;
- }
- if (GetBpp() == 4){
- bval = (uint8_t)(17*(0x0F & bval));
- }
-
- memset(info.pImage,bval,head.biSizeImage);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Transfers the image from an existing source image. The source becomes empty.
- * \return true if everything is ok
- */
-bool CxImage::Transfer(CxImage &from, bool bTransferFrames /*=true*/)
-{
- if (!Destroy())
- return false;
-
- memcpy(&head,&from.head,sizeof(BITMAPINFOHEADER));
- memcpy(&info,&from.info,sizeof(CXIMAGEINFO));
-
- pDib = from.pDib;
- pSelection = from.pSelection;
- pAlpha = from.pAlpha;
- ppLayers = from.ppLayers;
-
- memset(&from.head,0,sizeof(BITMAPINFOHEADER));
- memset(&from.info,0,sizeof(CXIMAGEINFO));
- from.pDib = from.pSelection = from.pAlpha = NULL;
- from.ppLayers = NULL;
-
- if (bTransferFrames){
- DestroyFrames();
- ppFrames = from.ppFrames;
- from.ppFrames = NULL;
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * (this) points to the same pDib owned by (*from), the image remains in (*from)
- * but (this) has the access to the pixels. <b>Use carefully !!!</b>
- */
-void CxImage::Ghost(const CxImage *from)
-{
- if (from){
- memcpy(&head,&from->head,sizeof(BITMAPINFOHEADER));
- memcpy(&info,&from->info,sizeof(CXIMAGEINFO));
- pDib = from->pDib;
- pSelection = from->pSelection;
- pAlpha = from->pAlpha;
- ppLayers = from->ppLayers;
- ppFrames = from->ppFrames;
- info.pGhost=(CxImage *)from;
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * turns a 16 or 32 bit bitfield image into a RGB image
- */
-void CxImage::Bitfield2RGB(uint8_t *src, uint32_t redmask, uint32_t greenmask, uint32_t bluemask, uint8_t bpp)
-{
- switch (bpp){
- case 16:
- {
- uint32_t ns[3]={0,0,0};
- // compute the number of shift for each mask
- for (int32_t i=0;i<16;i++){
- if ((redmask>>i)&0x01) ns[0]++;
- if ((greenmask>>i)&0x01) ns[1]++;
- if ((bluemask>>i)&0x01) ns[2]++;
- }
- ns[1]+=ns[0]; ns[2]+=ns[1]; ns[0]=8-ns[0]; ns[1]-=8; ns[2]-=8;
- // dword aligned width for 16 bit image
- int32_t effwidth2=(((head.biWidth + 1) / 2) * 4);
- uint16_t w;
- int32_t y2,y3,x2,x3;
- uint8_t *p=info.pImage;
- // scan the buffer in reverse direction to avoid reallocations
- for (int32_t y=head.biHeight-1; y>=0; y--){
- y2=effwidth2*y;
- y3=info.dwEffWidth*y;
- for (int32_t x=head.biWidth-1; x>=0; x--){
- x2 = 2*x+y2;
- x3 = 3*x+y3;
- w = (uint16_t)(src[x2]+256*src[1+x2]);
- p[ x3]=(uint8_t)((w & bluemask)<<ns[0]);
- p[1+x3]=(uint8_t)((w & greenmask)>>ns[1]);
- p[2+x3]=(uint8_t)((w & redmask)>>ns[2]);
- }
- }
- break;
- }
- case 32:
- {
- uint32_t ns[3]={0,0,0};
- // compute the number of shift for each mask
- for (int32_t i=8;i<32;i+=8){
- if (redmask>>i) ns[0]++;
- if (greenmask>>i) ns[1]++;
- if (bluemask>>i) ns[2]++;
- }
- // dword aligned width for 32 bit image
- int32_t effwidth4 = head.biWidth * 4;
- int32_t y4,y3,x4,x3;
- uint8_t *p=info.pImage;
- // scan the buffer in reverse direction to avoid reallocations
- for (int32_t y=head.biHeight-1; y>=0; y--){
- y4=effwidth4*y;
- y3=info.dwEffWidth*y;
- for (int32_t x=head.biWidth-1; x>=0; x--){
- x4 = 4*x+y4;
- x3 = 3*x+y3;
- p[ x3]=src[ns[2]+x4];
- p[1+x3]=src[ns[1]+x4];
- p[2+x3]=src[ns[0]+x4];
- }
- }
- }
-
- }
- return;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Creates an image from a generic buffer
- * \param pArray: source memory buffer
- * \param dwWidth: image width
- * \param dwHeight: image height
- * \param dwBitsperpixel: can be 1,4,8,24,32
- * \param dwBytesperline: line alignment, in bytes, for a single row stored in pArray
- * \param bFlipImage: tune this parameter if the image is upsidedown
- * \return true if everything is ok
- */
-bool CxImage::CreateFromArray(uint8_t* pArray,uint32_t dwWidth,uint32_t dwHeight,uint32_t dwBitsperpixel, uint32_t dwBytesperline, bool bFlipImage)
-{
- if (pArray==NULL) return false;
- if (!((dwBitsperpixel==1)||(dwBitsperpixel==4)||(dwBitsperpixel==8)||
- (dwBitsperpixel==24)||(dwBitsperpixel==32))) return false;
-
- if (!Create(dwWidth,dwHeight,dwBitsperpixel)) return false;
-
- if (dwBitsperpixel<24) SetGrayPalette();
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (dwBitsperpixel==32) AlphaCreate();
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- uint8_t *dst,*src;
-
- for (uint32_t y = 0; y<dwHeight; y++) {
- dst = info.pImage + (bFlipImage?(dwHeight-1-y):y) * info.dwEffWidth;
- src = pArray + y * dwBytesperline;
- if (dwBitsperpixel==32){
- for(uint32_t x=0;x<dwWidth;x++){
- *dst++=src[0];
- *dst++=src[1];
- *dst++=src[2];
-#if CXIMAGE_SUPPORT_ALPHA
- AlphaSet(x,(bFlipImage?(dwHeight-1-y):y),src[3]);
-#endif //CXIMAGE_SUPPORT_ALPHA
- src+=4;
- }
- } else {
- memcpy(dst,src,min(info.dwEffWidth,dwBytesperline));
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \sa CreateFromArray
- */
-bool CxImage::CreateFromMatrix(uint8_t** ppMatrix,uint32_t dwWidth,uint32_t dwHeight,uint32_t dwBitsperpixel, uint32_t dwBytesperline, bool bFlipImage)
-{
- if (ppMatrix==NULL) return false;
- if (!((dwBitsperpixel==1)||(dwBitsperpixel==4)||(dwBitsperpixel==8)||
- (dwBitsperpixel==24)||(dwBitsperpixel==32))) return false;
-
- if (!Create(dwWidth,dwHeight,dwBitsperpixel)) return false;
-
- if (dwBitsperpixel<24) SetGrayPalette();
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (dwBitsperpixel==32) AlphaCreate();
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- uint8_t *dst,*src;
-
- for (uint32_t y = 0; y<dwHeight; y++) {
- dst = info.pImage + (bFlipImage?(dwHeight-1-y):y) * info.dwEffWidth;
- src = ppMatrix[y];
- if (src){
- if (dwBitsperpixel==32){
- for(uint32_t x=0;x<dwWidth;x++){
- *dst++=src[0];
- *dst++=src[1];
- *dst++=src[2];
-#if CXIMAGE_SUPPORT_ALPHA
- AlphaSet(x,(bFlipImage?(dwHeight-1-y):y),src[3]);
-#endif //CXIMAGE_SUPPORT_ALPHA
- src+=4;
- }
- } else {
- memcpy(dst,src,min(info.dwEffWidth,dwBytesperline));
- }
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return lightness difference between elem1 and elem2
- */
-int32_t CxImage::CompareColors(const void *elem1, const void *elem2)
-{
- RGBQUAD* c1 = (RGBQUAD*)elem1;
- RGBQUAD* c2 = (RGBQUAD*)elem2;
-
- int32_t g1 = (int32_t)RGB2GRAY(c1->rgbRed,c1->rgbGreen,c1->rgbBlue);
- int32_t g2 = (int32_t)RGB2GRAY(c2->rgbRed,c2->rgbGreen,c2->rgbBlue);
-
- return (g1-g2);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * simply calls "if (memblock) free(memblock);".
- * Useful when calling Encode for a memory buffer,
- * from a DLL compiled with different memory management options.
- * CxImage::FreeMemory will use the same memory environment used by Encode.
- * \author [livecn]
- */
-void CxImage::FreeMemory(void* memblock)
-{
- if (memblock)
- free(memblock);
-}
-////////////////////////////////////////////////////////////////////////////////
-//EOF
diff --git a/smelt/sdl/CxImage/ximage.h b/smelt/sdl/CxImage/ximage.h deleted file mode 100644 index 4eed84e..0000000 --- a/smelt/sdl/CxImage/ximage.h +++ /dev/null @@ -1,808 +0,0 @@ -/*
- * File: ximage.h
- * Purpose: General Purpose Image Class
- */
-/*
- --------------------------------------------------------------------------------
-
- COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
-
- CxImage version 7.0.0 31/Dec/2010
-
- CxImage : Copyright (C) 2001 - 2010, Davide Pizzolato
-
- Original CImage and CImageIterator implementation are:
- Copyright (C) 1995, Alejandro Aguilar Sierra (asierra(at)servidor(dot)unam(dot)mx)
-
- Covered code is provided under this license on an "as is" basis, without warranty
- of any kind, either expressed or implied, including, without limitation, warranties
- that the covered code is free of defects, merchantable, fit for a particular purpose
- or non-infringing. The entire risk as to the quality and performance of the covered
- code is with you. Should any covered code prove defective in any respect, you (not
- the initial developer or any other contributor) assume the cost of any necessary
- servicing, repair or correction. This disclaimer of warranty constitutes an essential
- part of this license. No use of any covered code is authorized hereunder except under
- this disclaimer.
-
- Permission is hereby granted to use, copy, modify, and distribute this
- source code, or portions hereof, for any purpose, including commercial applications,
- freely and without fee, subject to the following restrictions:
-
- 1. The origin of this software must not be misrepresented; you must not
- claim that you wrote the original software. If you use this software
- in a product, an acknowledgment in the product documentation would be
- appreciated but is not required.
-
- 2. Altered source versions must be plainly marked as such, and must not be
- misrepresented as being the original software.
-
- 3. This notice may not be removed or altered from any source distribution.
-
- --------------------------------------------------------------------------------
-
- Other information about CxImage, and the latest version, can be found at the
- CxImage home page: http://www.xdp.it/cximage/
-
- --------------------------------------------------------------------------------
- */
-#if !defined(__CXIMAGE_H)
-#define __CXIMAGE_H
-
-#if _MSC_VER > 1000
-#pragma once
-#endif
-#ifdef _LINUX
-#ifndef _XOPEN_SOURCE
- #define _XOPEN_SOURCE
-#endif
- #include <unistd.h>
- #include <arpa/inet.h>
-#endif
-
-/////////////////////////////////////////////////////////////////////////////
-#include "xfile.h"
-#include "xiofile.h"
-#include "xmemfile.h"
-#include "ximadef.h" //<vho> adjust some #define
-
-/* see "ximacfg.h" for CxImage configuration options */
-
-/////////////////////////////////////////////////////////////////////////////
-// CxImage formats enumerator
-enum ENUM_CXIMAGE_FORMATS{
-CXIMAGE_FORMAT_UNKNOWN = 0,
-#if CXIMAGE_SUPPORT_BMP
-CXIMAGE_FORMAT_BMP = 1,
-#endif
-#if CXIMAGE_SUPPORT_GIF
-CXIMAGE_FORMAT_GIF = 2,
-#endif
-#if CXIMAGE_SUPPORT_JPG
-CXIMAGE_FORMAT_JPG = 3,
-#endif
-#if CXIMAGE_SUPPORT_PNG
-CXIMAGE_FORMAT_PNG = 4,
-#endif
-#if CXIMAGE_SUPPORT_ICO
-CXIMAGE_FORMAT_ICO = 5,
-#endif
-#if CXIMAGE_SUPPORT_TIF
-CXIMAGE_FORMAT_TIF = 6,
-#endif
-#if CXIMAGE_SUPPORT_TGA
-CXIMAGE_FORMAT_TGA = 7,
-#endif
-#if CXIMAGE_SUPPORT_PCX
-CXIMAGE_FORMAT_PCX = 8,
-#endif
-#if CXIMAGE_SUPPORT_WBMP
-CXIMAGE_FORMAT_WBMP = 9,
-#endif
-#if CXIMAGE_SUPPORT_WMF
-CXIMAGE_FORMAT_WMF = 10,
-#endif
-#if CXIMAGE_SUPPORT_JP2
-CXIMAGE_FORMAT_JP2 = 11,
-#endif
-#if CXIMAGE_SUPPORT_JPC
-CXIMAGE_FORMAT_JPC = 12,
-#endif
-#if CXIMAGE_SUPPORT_PGX
-CXIMAGE_FORMAT_PGX = 13,
-#endif
-#if CXIMAGE_SUPPORT_PNM
-CXIMAGE_FORMAT_PNM = 14,
-#endif
-#if CXIMAGE_SUPPORT_RAS
-CXIMAGE_FORMAT_RAS = 15,
-#endif
-#if CXIMAGE_SUPPORT_JBG
-CXIMAGE_FORMAT_JBG = 16,
-#endif
-#if CXIMAGE_SUPPORT_MNG
-CXIMAGE_FORMAT_MNG = 17,
-#endif
-#if CXIMAGE_SUPPORT_SKA
-CXIMAGE_FORMAT_SKA = 18,
-#endif
-#if CXIMAGE_SUPPORT_RAW
-CXIMAGE_FORMAT_RAW = 19,
-#endif
-#if CXIMAGE_SUPPORT_PSD
-CXIMAGE_FORMAT_PSD = 20,
-#endif
-CMAX_IMAGE_FORMATS = CXIMAGE_SUPPORT_BMP + CXIMAGE_SUPPORT_GIF + CXIMAGE_SUPPORT_JPG +
- CXIMAGE_SUPPORT_PNG + CXIMAGE_SUPPORT_MNG + CXIMAGE_SUPPORT_ICO +
- CXIMAGE_SUPPORT_TIF + CXIMAGE_SUPPORT_TGA + CXIMAGE_SUPPORT_PCX +
- CXIMAGE_SUPPORT_WBMP+ CXIMAGE_SUPPORT_WMF +
- CXIMAGE_SUPPORT_JBG + CXIMAGE_SUPPORT_JP2 + CXIMAGE_SUPPORT_JPC +
- CXIMAGE_SUPPORT_PGX + CXIMAGE_SUPPORT_PNM + CXIMAGE_SUPPORT_RAS +
- CXIMAGE_SUPPORT_SKA + CXIMAGE_SUPPORT_RAW + CXIMAGE_SUPPORT_PSD + 1
-};
-
-#if CXIMAGE_SUPPORT_EXIF
-
-#define MAX_COMMENT 255
-#define MAX_SECTIONS 20
-
-typedef struct tag_ExifInfo {
- char Version [5];
- char CameraMake [32];
- char CameraModel [40];
- char DateTime [20];
- int32_t Height, Width;
- int32_t Orientation;
- int32_t IsColor;
- int32_t Process;
- int32_t FlashUsed;
- float FocalLength;
- float ExposureTime;
- float ApertureFNumber;
- float Distance;
- float CCDWidth;
- float ExposureBias;
- int32_t Whitebalance;
- int32_t MeteringMode;
- int32_t ExposureProgram;
- int32_t ISOequivalent;
- int32_t CompressionLevel;
- float FocalplaneXRes;
- float FocalplaneYRes;
- float FocalplaneUnits;
- float Xresolution;
- float Yresolution;
- float ResolutionUnit;
- float Brightness;
- char Comments[MAX_COMMENT+1];
-
- uint8_t * ThumbnailPointer; /* Pointer at the thumbnail */
- unsigned ThumbnailSize; /* Size of thumbnail. */
-
- bool IsExif;
-} EXIFINFO;
-
-#endif //CXIMAGE_SUPPORT_EXIF
-
-/////////////////////////////////////////////////////////////////////////////
-// CxImage class
-/////////////////////////////////////////////////////////////////////////////
-class DLL_EXP CxImage
-{
-//extensible information collector
-typedef struct tagCxImageInfo {
- uint32_t dwEffWidth; ///< uint32_t aligned scan line width
- uint8_t* pImage; ///< THE IMAGE BITS
- CxImage* pGhost; ///< if this is a ghost, pGhost points to the body
- CxImage* pParent; ///< if this is a layer, pParent points to the body
- uint32_t dwType; ///< original image format
- char szLastError[256]; ///< debugging
- int32_t nProgress; ///< monitor
- int32_t nEscape; ///< escape
- int32_t nBkgndIndex; ///< used for GIF, PNG, MNG
- RGBQUAD nBkgndColor; ///< used for RGB transparency
- float fQuality; ///< used for JPEG, JPEG2000 (0.0f ... 100.0f)
- uint8_t nJpegScale; ///< used for JPEG [ignacio]
- int32_t nFrame; ///< used for TIF, GIF, MNG : actual frame
- int32_t nNumFrames; ///< used for TIF, GIF, MNG : total number of frames
- uint32_t dwFrameDelay; ///< used for GIF, MNG
- int32_t xDPI; ///< horizontal resolution
- int32_t yDPI; ///< vertical resolution
- RECT rSelectionBox; ///< bounding rectangle
- uint8_t nAlphaMax; ///< max opacity (fade)
- bool bAlphaPaletteEnabled; ///< true if alpha values in the palette are enabled.
- bool bEnabled; ///< enables the painting functions
- int32_t xOffset;
- int32_t yOffset;
- uint32_t dwCodecOpt[CMAX_IMAGE_FORMATS]; ///< for GIF, TIF : 0=def.1=unc,2=fax3,3=fax4,4=pack,5=jpg
- RGBQUAD last_c; ///< for GetNearestIndex optimization
- uint8_t last_c_index;
- bool last_c_isvalid;
- int32_t nNumLayers;
- uint32_t dwFlags; ///< 0x??00000 = reserved, 0x00??0000 = blend mode, 0x0000???? = layer id - user flags
- uint8_t dispmeth;
- bool bGetAllFrames;
- bool bLittleEndianHost;
-
-#if CXIMAGE_SUPPORT_EXIF
- EXIFINFO ExifInfo;
-#endif
-
-} CXIMAGEINFO;
-
-public:
- //public structures
-struct rgb_color { uint8_t r,g,b; };
-
-#if CXIMAGE_SUPPORT_WINDOWS
-// <VATI> text placement data
-// members must be initialized with the InitTextInfo(&this) function.
-typedef struct tagCxTextInfo
-{
-#if defined (_WIN32_WCE)
- TCHAR text[256]; ///< text for windows CE
-#else
- TCHAR text[4096]; ///< text (char -> TCHAR for UNICODE [Cesar M])
-#endif
- LOGFONT lfont; ///< font and codepage data
- COLORREF fcolor; ///< foreground color
- int32_t align; ///< DT_CENTER, DT_RIGHT, DT_LEFT aligment for multiline text
- uint8_t smooth; ///< text smoothing option. Default is false.
- uint8_t opaque; ///< text has background or hasn't. Default is true.
- ///< data for background (ignored if .opaque==FALSE)
- COLORREF bcolor; ///< background color
- float b_opacity; ///< opacity value for background between 0.0-1.0 Default is 0. (opaque)
- uint8_t b_outline; ///< outline width for background (zero: no outline)
- uint8_t b_round; ///< rounding radius for background rectangle. % of the height, between 0-50. Default is 10.
- ///< (backgr. always has a frame: width = 3 pixel + 10% of height by default.)
-} CXTEXTINFO;
-#endif
-
-public:
-/** \addtogroup Constructors */ //@{
- CxImage(uint32_t imagetype = 0);
- CxImage(uint32_t dwWidth, uint32_t dwHeight, uint32_t wBpp, uint32_t imagetype = 0);
- CxImage(const CxImage &src, bool copypixels = true, bool copyselection = true, bool copyalpha = true);
-#if CXIMAGE_SUPPORT_DECODE
- CxImage(const TCHAR * filename, uint32_t imagetype); // For UNICODE support: char -> TCHAR
- CxImage(FILE * stream, uint32_t imagetype);
- CxImage(CxFile * stream, uint32_t imagetype);
- CxImage(uint8_t * buffer, uint32_t size, uint32_t imagetype);
-#endif
- virtual ~CxImage() { DestroyFrames(); Destroy(); };
- CxImage& operator = (const CxImage&);
-//@}
-
-/** \addtogroup Initialization */ //@{
- void* Create(uint32_t dwWidth, uint32_t dwHeight, uint32_t wBpp, uint32_t imagetype = 0);
- bool Destroy();
- bool DestroyFrames();
- void Clear(uint8_t bval=0);
- void Copy(const CxImage &src, bool copypixels = true, bool copyselection = true, bool copyalpha = true);
- bool Transfer(CxImage &from, bool bTransferFrames = true);
- bool CreateFromArray(uint8_t* pArray,uint32_t dwWidth,uint32_t dwHeight,uint32_t dwBitsperpixel, uint32_t dwBytesperline, bool bFlipImage);
- bool CreateFromMatrix(uint8_t** ppMatrix,uint32_t dwWidth,uint32_t dwHeight,uint32_t dwBitsperpixel, uint32_t dwBytesperline, bool bFlipImage);
- void FreeMemory(void* memblock);
-
- uint32_t Dump(uint8_t * dst);
- uint32_t UnDump(const uint8_t * src);
- uint32_t DumpSize();
-
-//@}
-
-/** \addtogroup Attributes */ //@{
- int32_t GetSize();
- uint8_t* GetBits(uint32_t row = 0);
- uint8_t GetColorType();
- void* GetDIB() const;
- uint32_t GetHeight() const;
- uint32_t GetWidth() const;
- uint32_t GetEffWidth() const;
- uint32_t GetNumColors() const;
- uint16_t GetBpp() const;
- uint32_t GetType() const;
- const char* GetLastError();
- static const TCHAR* GetVersion();
- static const float GetVersionNumber();
-
- uint32_t GetFrameDelay() const;
- void SetFrameDelay(uint32_t d);
-
- void GetOffset(int32_t *x,int32_t *y);
- void SetOffset(int32_t x,int32_t y);
-
- uint8_t GetJpegQuality() const;
- void SetJpegQuality(uint8_t q);
- float GetJpegQualityF() const;
- void SetJpegQualityF(float q);
-
- uint8_t GetJpegScale() const;
- void SetJpegScale(uint8_t q);
-
-#if CXIMAGE_SUPPORT_EXIF
- EXIFINFO *GetExifInfo() {return &info.ExifInfo;};
- bool GetExifThumbnail(const TCHAR *filename, const TCHAR *outname, int32_t imageType);
- #if CXIMAGE_SUPPORT_TRANSFORMATION
- bool RotateExif(int32_t orientation = 0);
- #endif
-#endif
-
- int32_t GetXDPI() const;
- int32_t GetYDPI() const;
- void SetXDPI(int32_t dpi);
- void SetYDPI(int32_t dpi);
-
- uint32_t GetClrImportant() const;
- void SetClrImportant(uint32_t ncolors = 0);
-
- int32_t GetProgress() const;
- int32_t GetEscape() const;
- void SetProgress(int32_t p);
- void SetEscape(int32_t i);
-
- int32_t GetTransIndex() const;
- RGBQUAD GetTransColor();
- void SetTransIndex(int32_t idx);
- void SetTransColor(RGBQUAD rgb);
- bool IsTransparent() const;
-
- uint32_t GetCodecOption(uint32_t imagetype = 0);
- bool SetCodecOption(uint32_t opt, uint32_t imagetype = 0);
-
- uint32_t GetFlags() const;
- void SetFlags(uint32_t flags, bool bLockReservedFlags = true);
-
- uint8_t GetDisposalMethod() const;
- void SetDisposalMethod(uint8_t dm);
-
- bool SetType(uint32_t type);
-
- static uint32_t GetNumTypes();
- static uint32_t GetTypeIdFromName(const TCHAR* ext);
- static uint32_t GetTypeIdFromIndex(const uint32_t index);
- static uint32_t GetTypeIndexFromId(const uint32_t id);
-
- bool GetRetreiveAllFrames() const;
- void SetRetreiveAllFrames(bool flag);
- CxImage * GetFrame(int32_t nFrame) const;
-
- //void* GetUserData() const {return info.pUserData;}
- //void SetUserData(void* pUserData) {info.pUserData = pUserData;}
-//@}
-
-/** \addtogroup Palette
- * These functions have no effects on RGB images and in this case the returned value is always 0.
- * @{ */
- bool IsGrayScale();
- bool IsIndexed() const;
- bool IsSamePalette(CxImage &img, bool bCheckAlpha = true);
- uint32_t GetPaletteSize();
- RGBQUAD* GetPalette() const;
- RGBQUAD GetPaletteColor(uint8_t idx);
- bool GetPaletteColor(uint8_t i, uint8_t* r, uint8_t* g, uint8_t* b);
- uint8_t GetNearestIndex(RGBQUAD c);
- void BlendPalette(COLORREF cr,int32_t perc);
- void SetGrayPalette();
- void SetPalette(uint32_t n, uint8_t *r, uint8_t *g, uint8_t *b);
- void SetPalette(RGBQUAD* pPal,uint32_t nColors=256);
- void SetPalette(rgb_color *rgb,uint32_t nColors=256);
- void SetPaletteColor(uint8_t idx, uint8_t r, uint8_t g, uint8_t b, uint8_t alpha=0);
- void SetPaletteColor(uint8_t idx, RGBQUAD c);
- void SetPaletteColor(uint8_t idx, COLORREF cr);
- void SwapIndex(uint8_t idx1, uint8_t idx2);
- void SwapRGB2BGR();
- void SetStdPalette();
-//@}
-
-/** \addtogroup Pixel */ //@{
- bool IsInside(int32_t x, int32_t y);
- bool IsTransparent(int32_t x,int32_t y);
- bool GetTransparentMask(CxImage* iDst = 0);
- RGBQUAD GetPixelColor(int32_t x,int32_t y, bool bGetAlpha = true);
- uint8_t GetPixelIndex(int32_t x,int32_t y);
- uint8_t GetPixelGray(int32_t x, int32_t y);
- void SetPixelColor(int32_t x,int32_t y,RGBQUAD c, bool bSetAlpha = false);
- void SetPixelColor(int32_t x,int32_t y,COLORREF cr);
- void SetPixelIndex(int32_t x,int32_t y,uint8_t i);
- void DrawLine(int32_t StartX, int32_t EndX, int32_t StartY, int32_t EndY, RGBQUAD color, bool bSetAlpha=false);
- void DrawLine(int32_t StartX, int32_t EndX, int32_t StartY, int32_t EndY, COLORREF cr);
- void BlendPixelColor(int32_t x,int32_t y,RGBQUAD c, float blend, bool bSetAlpha = false);
-//@}
-
-protected:
-/** \addtogroup Protected */ //@{
- uint8_t BlindGetPixelIndex(const int32_t x,const int32_t y);
- RGBQUAD BlindGetPixelColor(const int32_t x,const int32_t y, bool bGetAlpha = true);
- void *BlindGetPixelPointer(const int32_t x,const int32_t y);
- void BlindSetPixelColor(int32_t x,int32_t y,RGBQUAD c, bool bSetAlpha = false);
- void BlindSetPixelIndex(int32_t x,int32_t y,uint8_t i);
-//@}
-
-public:
-
-#if CXIMAGE_SUPPORT_INTERPOLATION
-/** \addtogroup Interpolation */ //@{
- //overflow methods:
- enum OverflowMethod {
- OM_COLOR=1,
- OM_BACKGROUND=2,
- OM_TRANSPARENT=3,
- OM_WRAP=4,
- OM_REPEAT=5,
- OM_MIRROR=6
- };
- void OverflowCoordinates(float &x, float &y, OverflowMethod const ofMethod);
- void OverflowCoordinates(int32_t &x, int32_t &y, OverflowMethod const ofMethod);
- RGBQUAD GetPixelColorWithOverflow(int32_t x, int32_t y, OverflowMethod const ofMethod=OM_BACKGROUND, RGBQUAD* const rplColor=0);
- //interpolation methods:
- enum InterpolationMethod {
- IM_NEAREST_NEIGHBOUR=1,
- IM_BILINEAR =2,
- IM_BSPLINE =3,
- IM_BICUBIC =4,
- IM_BICUBIC2 =5,
- IM_LANCZOS =6,
- IM_BOX =7,
- IM_HERMITE =8,
- IM_HAMMING =9,
- IM_SINC =10,
- IM_BLACKMAN =11,
- IM_BESSEL =12,
- IM_GAUSSIAN =13,
- IM_QUADRATIC =14,
- IM_MITCHELL =15,
- IM_CATROM =16,
- IM_HANNING =17,
- IM_POWER =18
- };
- RGBQUAD GetPixelColorInterpolated(float x,float y, InterpolationMethod const inMethod=IM_BILINEAR, OverflowMethod const ofMethod=OM_BACKGROUND, RGBQUAD* const rplColor=0);
- RGBQUAD GetAreaColorInterpolated(float const xc, float const yc, float const w, float const h, InterpolationMethod const inMethod, OverflowMethod const ofMethod=OM_BACKGROUND, RGBQUAD* const rplColor=0);
-//@}
-
-protected:
-/** \addtogroup Protected */ //@{
- void AddAveragingCont(RGBQUAD const &color, float const surf, float &rr, float &gg, float &bb, float &aa);
-//@}
-
-/** \addtogroup Kernels */ //@{
-public:
- static float KernelBSpline(const float x);
- static float KernelLinear(const float t);
- static float KernelCubic(const float t);
- static float KernelGeneralizedCubic(const float t, const float a=-1);
- static float KernelLanczosSinc(const float t, const float r = 3);
- static float KernelBox(const float x);
- static float KernelHermite(const float x);
- static float KernelHamming(const float x);
- static float KernelSinc(const float x);
- static float KernelBlackman(const float x);
- static float KernelBessel_J1(const float x);
- static float KernelBessel_P1(const float x);
- static float KernelBessel_Q1(const float x);
- static float KernelBessel_Order1(float x);
- static float KernelBessel(const float x);
- static float KernelGaussian(const float x);
- static float KernelQuadratic(const float x);
- static float KernelMitchell(const float x);
- static float KernelCatrom(const float x);
- static float KernelHanning(const float x);
- static float KernelPower(const float x, const float a = 2);
-//@}
-#endif //CXIMAGE_SUPPORT_INTERPOLATION
-
-/** \addtogroup Painting */ //@{
-#if CXIMAGE_SUPPORT_WINDOWS
- int32_t Blt(HDC pDC, int32_t x=0, int32_t y=0);
- HBITMAP Draw2HBITMAP(HDC hdc, int32_t x, int32_t y, int32_t cx, int32_t cy, RECT* pClipRect, bool bSmooth);
- HBITMAP MakeBitmap(HDC hdc = NULL, bool bTransparency = false);
- HICON MakeIcon(HDC hdc = NULL, bool bTransparency = false);
- HANDLE CopyToHandle();
- bool CreateFromHANDLE(HANDLE hMem); //Windows objects (clipboard)
- bool CreateFromHBITMAP(HBITMAP hbmp, HPALETTE hpal=0, bool bTransparency = false); //Windows resource
- bool CreateFromHICON(HICON hico, bool bTransparency = false);
- int32_t Draw(HDC hdc, int32_t x=0, int32_t y=0, int32_t cx = -1, int32_t cy = -1, RECT* pClipRect = 0, bool bSmooth = false, bool bFlipY = false);
- int32_t Draw(HDC hdc, const RECT& rect, RECT* pClipRect=NULL, bool bSmooth = false, bool bFlipY = false);
- int32_t Stretch(HDC hdc, int32_t xoffset, int32_t yoffset, int32_t xsize, int32_t ysize, uint32_t dwRop = SRCCOPY);
- int32_t Stretch(HDC hdc, const RECT& rect, uint32_t dwRop = SRCCOPY);
- int32_t Tile(HDC hdc, RECT *rc);
- int32_t Draw2(HDC hdc, int32_t x=0, int32_t y=0, int32_t cx = -1, int32_t cy = -1);
- int32_t Draw2(HDC hdc, const RECT& rect);
- //int32_t DrawString(HDC hdc, int32_t x, int32_t y, const char* text, RGBQUAD color, const char* font, int32_t lSize=0, int32_t lWeight=400, uint8_t bItalic=0, uint8_t bUnderline=0, bool bSetAlpha=false);
- int32_t DrawString(HDC hdc, int32_t x, int32_t y, const TCHAR* text, RGBQUAD color, const TCHAR* font, int32_t lSize=0, int32_t lWeight=400, uint8_t bItalic=0, uint8_t bUnderline=0, bool bSetAlpha=false);
- // <VATI> extensions
- int32_t DrawStringEx(HDC hdc, int32_t x, int32_t y, CXTEXTINFO *pTextType, bool bSetAlpha=false );
- void InitTextInfo( CXTEXTINFO *txt );
-protected:
- bool IsHBITMAPAlphaValid( HBITMAP hbmp );
-public:
-#endif //CXIMAGE_SUPPORT_WINDOWS
-//@}
-
- // file operations
-#if CXIMAGE_SUPPORT_DECODE
-/** \addtogroup Decode */ //@{
-#ifdef WIN32
- //bool Load(LPCWSTR filename, uint32_t imagetype=0);
- bool LoadResource(HRSRC hRes, uint32_t imagetype, HMODULE hModule=NULL);
-#endif
- // For UNICODE support: char -> TCHAR
- bool Load(const TCHAR* filename, uint32_t imagetype=0);
- //bool Load(const char * filename, uint32_t imagetype=0);
- bool Decode(FILE * hFile, uint32_t imagetype);
- bool Decode(CxFile * hFile, uint32_t imagetype);
- bool Decode(uint8_t * buffer, uint32_t size, uint32_t imagetype);
-
- bool CheckFormat(CxFile * hFile, uint32_t imagetype = 0);
- bool CheckFormat(uint8_t * buffer, uint32_t size, uint32_t imagetype = 0);
-//@}
-#endif //CXIMAGE_SUPPORT_DECODE
-
-#if CXIMAGE_SUPPORT_ENCODE
-protected:
-/** \addtogroup Protected */ //@{
- bool EncodeSafeCheck(CxFile *hFile);
-//@}
-
-public:
-/** \addtogroup Encode */ //@{
-#ifdef WIN32
- //bool Save(LPCWSTR filename, uint32_t imagetype=0);
-#endif
- // For UNICODE support: char -> TCHAR
- bool Save(const TCHAR* filename, uint32_t imagetype);
- //bool Save(const char * filename, uint32_t imagetype=0);
- bool Encode(FILE * hFile, uint32_t imagetype);
- bool Encode(CxFile * hFile, uint32_t imagetype);
- bool Encode(CxFile * hFile, CxImage ** pImages, int32_t pagecount, uint32_t imagetype);
- bool Encode(FILE *hFile, CxImage ** pImages, int32_t pagecount, uint32_t imagetype);
- bool Encode(uint8_t * &buffer, int32_t &size, uint32_t imagetype);
-
- bool Encode2RGBA(CxFile *hFile, bool bFlipY = false);
- bool Encode2RGBA(uint8_t * &buffer, int32_t &size, bool bFlipY = false);
-//@}
-#endif //CXIMAGE_SUPPORT_ENCODE
-
-/** \addtogroup Attributes */ //@{
- //misc.
- bool IsValid() const;
- bool IsEnabled() const;
- void Enable(bool enable=true);
-
- // frame operations
- int32_t GetNumFrames() const;
- int32_t GetFrame() const;
- void SetFrame(int32_t nFrame);
-//@}
-
-#if CXIMAGE_SUPPORT_BASICTRANSFORMATIONS
-/** \addtogroup BasicTransformations */ //@{
- bool GrayScale();
- bool Flip(bool bFlipSelection = false, bool bFlipAlpha = true);
- bool Mirror(bool bMirrorSelection = false, bool bMirrorAlpha = true);
- bool Negative();
- bool RotateLeft(CxImage* iDst = NULL);
- bool RotateRight(CxImage* iDst = NULL);
- bool IncreaseBpp(uint32_t nbit);
-//@}
-#endif //CXIMAGE_SUPPORT_BASICTRANSFORMATIONS
-
-#if CXIMAGE_SUPPORT_TRANSFORMATION
-/** \addtogroup Transformations */ //@{
- // image operations
- bool Rotate(float angle, CxImage* iDst = NULL);
- bool Rotate2(float angle, CxImage *iDst = NULL, InterpolationMethod inMethod=IM_BILINEAR,
- OverflowMethod ofMethod=OM_BACKGROUND, RGBQUAD *replColor=0,
- bool const optimizeRightAngles=true, bool const bKeepOriginalSize=false);
- bool Rotate180(CxImage* iDst = NULL);
- bool Resample(int32_t newx, int32_t newy, int32_t mode = 1, CxImage* iDst = NULL);
- bool Resample2(int32_t newx, int32_t newy, InterpolationMethod const inMethod=IM_BICUBIC2,
- OverflowMethod const ofMethod=OM_REPEAT, CxImage* const iDst = NULL,
- bool const disableAveraging=false);
- bool DecreaseBpp(uint32_t nbit, bool errordiffusion, RGBQUAD* ppal = 0, uint32_t clrimportant = 0);
- bool Dither(int32_t method = 0);
- bool Crop(int32_t left, int32_t top, int32_t right, int32_t bottom, CxImage* iDst = NULL);
- bool Crop(const RECT& rect, CxImage* iDst = NULL);
- bool CropRotatedRectangle( int32_t topx, int32_t topy, int32_t width, int32_t height, float angle, CxImage* iDst = NULL);
- bool Skew(float xgain, float ygain, int32_t xpivot=0, int32_t ypivot=0, bool bEnableInterpolation = false);
- bool Expand(int32_t left, int32_t top, int32_t right, int32_t bottom, RGBQUAD canvascolor, CxImage* iDst = 0);
- bool Expand(int32_t newx, int32_t newy, RGBQUAD canvascolor, CxImage* iDst = 0);
- bool Thumbnail(int32_t newx, int32_t newy, RGBQUAD canvascolor, CxImage* iDst = 0);
- bool CircleTransform(int32_t type,int32_t rmax=0,float Koeff=1.0f);
- bool QIShrink(int32_t newx, int32_t newy, CxImage* const iDst = NULL, bool bChangeBpp = false);
-
-//@}
-#endif //CXIMAGE_SUPPORT_TRANSFORMATION
-
-#if CXIMAGE_SUPPORT_DSP
-/** \addtogroup DSP */ //@{
- bool Contour();
- bool HistogramStretch(int32_t method = 0, double threshold = 0);
- bool HistogramEqualize();
- bool HistogramNormalize();
- bool HistogramRoot();
- bool HistogramLog();
- int32_t Histogram(int32_t* red, int32_t* green = 0, int32_t* blue = 0, int32_t* gray = 0, int32_t colorspace = 0);
- bool Jitter(int32_t radius=2);
- bool Repair(float radius = 0.25f, int32_t niterations = 1, int32_t colorspace = 0);
- bool Combine(CxImage* r,CxImage* g,CxImage* b,CxImage* a, int32_t colorspace = 0);
- bool FFT2(CxImage* srcReal, CxImage* srcImag, CxImage* dstReal, CxImage* dstImag, int32_t direction = 1, bool bForceFFT = true, bool bMagnitude = true);
- bool Noise(int32_t level);
- bool Median(int32_t Ksize=3);
- bool Gamma(float gamma);
- bool GammaRGB(float gammaR, float gammaG, float gammaB);
- bool ShiftRGB(int32_t r, int32_t g, int32_t b);
- bool Threshold(uint8_t level);
- bool Threshold(CxImage* pThresholdMask);
- bool Threshold2(uint8_t level, bool bDirection, RGBQUAD nBkgndColor, bool bSetAlpha = false);
- bool Colorize(uint8_t hue, uint8_t sat, float blend = 1.0f);
- bool Light(int32_t brightness, int32_t contrast = 0);
- float Mean();
- bool Filter(int32_t* kernel, int32_t Ksize, int32_t Kfactor, int32_t Koffset);
- bool Erode(int32_t Ksize=2);
- bool Dilate(int32_t Ksize=2);
- bool Edge(int32_t Ksize=2);
- void HuePalette(float correction=1);
- enum ImageOpType { OpAdd, OpAnd, OpXor, OpOr, OpMask, OpSrcCopy, OpDstCopy, OpSub, OpSrcBlend, OpScreen, OpAvg, OpBlendAlpha };
- void Mix(CxImage & imgsrc2, ImageOpType op, int32_t lXOffset = 0, int32_t lYOffset = 0, bool bMixAlpha = false);
- void MixFrom(CxImage & imagesrc2, int32_t lXOffset, int32_t lYOffset);
- bool UnsharpMask(float radius = 5.0f, float amount = 0.5f, int32_t threshold = 0);
- bool Lut(uint8_t* pLut);
- bool Lut(uint8_t* pLutR, uint8_t* pLutG, uint8_t* pLutB, uint8_t* pLutA = 0);
- bool GaussianBlur(float radius = 1.0f, CxImage* iDst = 0);
- bool TextBlur(uint8_t threshold = 100, uint8_t decay = 2, uint8_t max_depth = 5, bool bBlurHorizontal = true, bool bBlurVertical = true, CxImage* iDst = 0);
- bool SelectiveBlur(float radius = 1.0f, uint8_t threshold = 25, CxImage* iDst = 0);
- bool Solarize(uint8_t level = 128, bool bLinkedChannels = true);
- bool FloodFill(const int32_t xStart, const int32_t yStart, const RGBQUAD cFillColor, const uint8_t tolerance = 0,
- uint8_t nOpacity = 255, const bool bSelectFilledArea = false, const uint8_t nSelectionLevel = 255);
- bool Saturate(const int32_t saturation, const int32_t colorspace = 1);
- bool ConvertColorSpace(const int32_t dstColorSpace, const int32_t srcColorSpace);
- int32_t OptimalThreshold(int32_t method = 0, RECT * pBox = 0, CxImage* pContrastMask = 0);
- bool AdaptiveThreshold(int32_t method = 0, int32_t nBoxSize = 64, CxImage* pContrastMask = 0, int32_t nBias = 0, float fGlobalLocalBalance = 0.5f);
- bool RedEyeRemove(float strength = 0.8f);
- bool Trace(RGBQUAD color_target, RGBQUAD color_trace);
-
-//@}
-
-protected:
-/** \addtogroup Protected */ //@{
- bool IsPowerof2(int32_t x);
- bool FFT(int32_t dir,int32_t m,double *x,double *y);
- bool DFT(int32_t dir,int32_t m,double *x1,double *y1,double *x2,double *y2);
- bool RepairChannel(CxImage *ch, float radius);
- // <nipper>
- int32_t gen_convolve_matrix (float radius, float **cmatrix_p);
- float* gen_lookup_table (float *cmatrix, int32_t cmatrix_length);
- void blur_line (float *ctable, float *cmatrix, int32_t cmatrix_length, uint8_t* cur_col, uint8_t* dest_col, int32_t y, int32_t bytes);
- void blur_text (uint8_t threshold, uint8_t decay, uint8_t max_depth, CxImage* iSrc, CxImage* iDst, uint8_t bytes);
-//@}
-
-public:
-/** \addtogroup ColorSpace */ //@{
- bool SplitRGB(CxImage* r,CxImage* g,CxImage* b);
- bool SplitYUV(CxImage* y,CxImage* u,CxImage* v);
- bool SplitHSL(CxImage* h,CxImage* s,CxImage* l);
- bool SplitYIQ(CxImage* y,CxImage* i,CxImage* q);
- bool SplitXYZ(CxImage* x,CxImage* y,CxImage* z);
- bool SplitCMYK(CxImage* c,CxImage* m,CxImage* y,CxImage* k);
- static RGBQUAD HSLtoRGB(COLORREF cHSLColor);
- static RGBQUAD RGBtoHSL(RGBQUAD lRGBColor);
- static RGBQUAD HSLtoRGB(RGBQUAD lHSLColor);
- static RGBQUAD YUVtoRGB(RGBQUAD lYUVColor);
- static RGBQUAD RGBtoYUV(RGBQUAD lRGBColor);
- static RGBQUAD YIQtoRGB(RGBQUAD lYIQColor);
- static RGBQUAD RGBtoYIQ(RGBQUAD lRGBColor);
- static RGBQUAD XYZtoRGB(RGBQUAD lXYZColor);
- static RGBQUAD RGBtoXYZ(RGBQUAD lRGBColor);
-#endif //CXIMAGE_SUPPORT_DSP
- static RGBQUAD RGBtoRGBQUAD(COLORREF cr);
- static COLORREF RGBQUADtoRGB (RGBQUAD c);
-//@}
-
-/** \addtogroup Selection */ //@{
- bool SelectionIsValid();
-#if CXIMAGE_SUPPORT_SELECTION
- bool SelectionClear(uint8_t level = 0);
- bool SelectionCreate();
- bool SelectionDelete();
- bool SelectionInvert();
- bool SelectionMirror();
- bool SelectionFlip();
- bool SelectionAddRect(RECT r, uint8_t level = 255);
- bool SelectionAddEllipse(RECT r, uint8_t level = 255);
- bool SelectionAddPolygon(POINT *points, int32_t npoints, uint8_t level = 255);
- bool SelectionAddColor(RGBQUAD c, uint8_t level = 255);
- bool SelectionAddPixel(int32_t x, int32_t y, uint8_t level = 255);
- bool SelectionCopy(CxImage &from);
- bool SelectionIsInside(int32_t x, int32_t y);
- void SelectionGetBox(RECT& r);
- bool SelectionToHRGN(HRGN& region);
- bool SelectionSplit(CxImage *dest);
- uint8_t SelectionGet(const int32_t x,const int32_t y);
- bool SelectionSet(CxImage &from);
- void SelectionRebuildBox();
- uint8_t* SelectionGetPointer(const int32_t x = 0,const int32_t y = 0);
-//@}
-
-protected:
-/** \addtogroup Protected */ //@{
- bool BlindSelectionIsInside(int32_t x, int32_t y);
- uint8_t BlindSelectionGet(const int32_t x,const int32_t y);
- void SelectionSet(const int32_t x,const int32_t y,const uint8_t level);
-
-public:
-
-#endif //CXIMAGE_SUPPORT_SELECTION
-//@}
-
-#if CXIMAGE_SUPPORT_ALPHA
-/** \addtogroup Alpha */ //@{
- void AlphaClear();
- bool AlphaCreate();
- void AlphaDelete();
- void AlphaInvert();
- bool AlphaMirror();
- bool AlphaFlip();
- bool AlphaCopy(CxImage &from);
- bool AlphaSplit(CxImage *dest);
- void AlphaStrip();
- void AlphaSet(uint8_t level);
- bool AlphaSet(CxImage &from);
- void AlphaSet(const int32_t x,const int32_t y,const uint8_t level);
- uint8_t AlphaGet(const int32_t x,const int32_t y);
- uint8_t AlphaGetMax() const;
- void AlphaSetMax(uint8_t nAlphaMax);
- bool AlphaIsValid();
- uint8_t* AlphaGetPointer(const int32_t x = 0,const int32_t y = 0);
- bool AlphaFromTransparency();
-
- void AlphaPaletteClear();
- void AlphaPaletteEnable(bool enable=true);
- bool AlphaPaletteIsEnabled();
- bool AlphaPaletteIsValid();
- bool AlphaPaletteSplit(CxImage *dest);
-//@}
-
-protected:
-/** \addtogroup Protected */ //@{
- uint8_t BlindAlphaGet(const int32_t x,const int32_t y);
-//@}
-#endif //CXIMAGE_SUPPORT_ALPHA
-
-public:
-#if CXIMAGE_SUPPORT_LAYERS
-/** \addtogroup Layers */ //@{
- bool LayerCreate(int32_t position = -1);
- bool LayerDelete(int32_t position = -1);
- void LayerDeleteAll();
- CxImage* GetLayer(int32_t position);
- CxImage* GetParent() const;
- int32_t GetNumLayers() const;
- int32_t LayerDrawAll(HDC hdc, int32_t x=0, int32_t y=0, int32_t cx = -1, int32_t cy = -1, RECT* pClipRect = 0, bool bSmooth = false);
- int32_t LayerDrawAll(HDC hdc, const RECT& rect, RECT* pClipRect=NULL, bool bSmooth = false);
-//@}
-#endif //CXIMAGE_SUPPORT_LAYERS
-
-protected:
-/** \addtogroup Protected */ //@{
- void Startup(uint32_t imagetype = 0);
- void CopyInfo(const CxImage &src);
- void Ghost(const CxImage *src);
- void RGBtoBGR(uint8_t *buffer, int32_t length);
- static float HueToRGB(float n1,float n2, float hue);
- void Bitfield2RGB(uint8_t *src, uint32_t redmask, uint32_t greenmask, uint32_t bluemask, uint8_t bpp);
- static int32_t CompareColors(const void *elem1, const void *elem2);
- int16_t m_ntohs(const int16_t word);
- int32_t m_ntohl(const int32_t dword);
- void bihtoh(BITMAPINFOHEADER* bih);
-
- void* pDib; //contains the header, the palette, the pixels
- BITMAPINFOHEADER head; //standard header
- CXIMAGEINFO info; //extended information
- uint8_t* pSelection; //selected region
- uint8_t* pAlpha; //alpha channel
- CxImage** ppLayers; //generic layers
- CxImage** ppFrames;
-//@}
-};
-
-////////////////////////////////////////////////////////////////////////////
-#endif // !defined(__CXIMAGE_H)
diff --git a/smelt/sdl/CxImage/ximagif.cpp b/smelt/sdl/CxImage/ximagif.cpp deleted file mode 100644 index 8c94b9e..0000000 --- a/smelt/sdl/CxImage/ximagif.cpp +++ /dev/null @@ -1,1681 +0,0 @@ -/*
- * File: ximagif.cpp
- * Purpose: Platform Independent GIF Image Class Loader and Writer
- * 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximagif.h"
-
-#if CXIMAGE_SUPPORT_GIF
-
-#include "ximaiter.h"
-
-#if defined (_WIN32_WCE)
- #define assert(s)
-#else
- #include <assert.h>
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-CxImageGIF::CxImageGIF(): CxImage(CXIMAGE_FORMAT_GIF)
-{
- buf = new uint8_t [GIFBUFTAM + 1];
-
- stack = new uint8_t [MAX_CODES + 1];
- suffix = new uint8_t [MAX_CODES + 1];
- prefix = new uint16_t [MAX_CODES + 1];
-
- htab = new int32_t [HSIZE];
- codetab = new uint16_t [HSIZE];
-
- byte_buff = new uint8_t [257];
- accum = new char [256];
- m_comment = new char [256];
-
- m_loops=0;
- info.dispmeth=0;
- m_comment[0]='\0';
-
-}
-////////////////////////////////////////////////////////////////////////////////
-CxImageGIF::~CxImageGIF()
-{
- delete [] buf;
-
- delete [] stack;
- delete [] suffix;
- delete [] prefix;
-
- delete [] htab;
- delete [] codetab;
-
- delete [] byte_buff;
- delete [] accum;
- delete [] m_comment;
-}
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageGIF::Decode(CxFile *fp)
-{
- /* AD - for transparency */
- struct_dscgif dscgif;
- struct_image image;
- struct_TabCol TabCol;
-
- if (fp == NULL) return false;
-
- fp->Read(&dscgif,/*sizeof(dscgif)*/13,1);
- //if (strncmp(dscgif.header,"GIF8",3)!=0) {
- if (strncmp(dscgif.header,"GIF8",4)!=0) return FALSE;
-
- // Avoid Byte order problem with Mac <AMSN>
- dscgif.scrheight = m_ntohs(dscgif.scrheight);
- dscgif.scrwidth = m_ntohs(dscgif.scrwidth);
-
- if (info.nEscape == -1) {
- // Return output dimensions only
- head.biWidth = dscgif.scrwidth;
- head.biHeight = dscgif.scrheight;
- info.dwType = CXIMAGE_FORMAT_GIF;
- return true;
- }
-
- /* AD - for interlace */
- TabCol.sogct = (int16_t)(1 << ((dscgif.pflds & 0x07)+1));
- TabCol.colres = (int16_t)(((dscgif.pflds & 0x70) >> 4) + 1);
-
- // assume that the image is a truecolor-gif if
- // 1) no global color map found
- // 2) (image.w, image.h) of the 1st image != (dscgif.scrwidth, dscgif.scrheight)
- int32_t bTrueColor=0;
- CxImage* imaRGB=NULL;
-
- // Global colour map?
- if (dscgif.pflds & 0x80)
- fp->Read(TabCol.paleta,sizeof(struct rgb_color)*TabCol.sogct,1);
- else
- bTrueColor++; //first chance for a truecolor gif
-
- int32_t first_transparent_index = 0;
-
- int32_t iImage = 0;
- info.nNumFrames=get_num_frames(fp,&TabCol,&dscgif);
-
- if ((info.nFrame<0)||(info.nFrame>=info.nNumFrames)) return false;
-
- //it cannot be a true color GIF with only one frame
- if (info.nNumFrames == 1)
- bTrueColor=0;
-
- char ch;
- bool bPreviousWasNull = true;
- int32_t prevdispmeth = 0;
- CxImage *previousFrame = NULL;
-
- for (BOOL bContinue = TRUE; bContinue; )
- {
- if (fp->Read(&ch, sizeof(ch), 1) != 1) {break;}
-
- if (info.nEscape > 0) return false; // <vho> - cancel decoding
- if (bPreviousWasNull || ch==0)
- {
- switch (ch)
- {
- case '!': // extension
- {
- bContinue = DecodeExtension(fp);
- break;
- }
- case ',': // image
- {
- assert(sizeof(image) == 9);
- fp->Read(&image,sizeof(image),1);
- //avoid byte order problems with Solaris <candan> <AMSN>
- image.l = m_ntohs(image.l);
- image.t = m_ntohs(image.t);
- image.w = m_ntohs(image.w);
- image.h = m_ntohs(image.h);
-
- if (((image.l + image.w) > dscgif.scrwidth)||((image.t + image.h) > dscgif.scrheight))
- break;
-
- // check if it could be a truecolor gif
- if ((iImage==0) && (image.w != dscgif.scrwidth) && (image.h != dscgif.scrheight))
- bTrueColor++;
-
- rgb_color locpal[256]; //Local Palette
- rgb_color* pcurpal = TabCol.paleta; //Current Palette
- int16_t palcount = TabCol.sogct; //Current Palette color count
-
- // Local colour map?
- if (image.pf & 0x80) {
- palcount = (int16_t)(1 << ((image.pf & 0x07) +1));
- assert(3 == sizeof(struct rgb_color));
- fp->Read(locpal,sizeof(struct rgb_color)*palcount,1);
- pcurpal = locpal;
- }
-
- int32_t bpp; //<DP> select the correct bit per pixel value
- if (palcount <= 2) bpp = 1;
- else if (palcount <= 16) bpp = 4;
- else bpp = 8;
-
- CxImageGIF backimage;
- backimage.CopyInfo(*this);
- if (iImage==0){
- //first frame: build image background
- backimage.Create(dscgif.scrwidth, dscgif.scrheight, bpp, CXIMAGE_FORMAT_GIF);
- first_transparent_index = info.nBkgndIndex;
- backimage.Clear((uint8_t)gifgce.transpcolindex);
- previousFrame = new CxImage(backimage);
- previousFrame->SetRetreiveAllFrames(false);
- } else {
- //generic frame: handle disposal method from previous one
- /*Values : 0 - No disposal specified. The decoder is
- not required to take any action.
- 1 - Do not dispose. The graphic is to be left
- in place.
- 2 - Restore to background color. The area used by the
- graphic must be restored to the background color.
- 3 - Restore to previous. The decoder is required to
- restore the area overwritten by the graphic with
- what was there prior to rendering the graphic.
- */
- /* backimage.Copy(*this);
- if (prevdispmeth==2){
- backimage.Clear((uint8_t)first_transparent_index);
- }*/
- if (prevdispmeth==2){
- backimage.Copy(*this,false,false,false);
- backimage.Clear((uint8_t)first_transparent_index);
- } else if (prevdispmeth==3) {
- backimage.Copy(*this,false,false,false);
- backimage.Create(previousFrame->GetWidth(),
- previousFrame->GetHeight(),
- previousFrame->GetBpp(),CXIMAGE_FORMAT_GIF);
- memcpy(backimage.GetDIB(),previousFrame->GetDIB(),
- backimage.GetSize());
- //backimage.AlphaSet(*previousFrame);
- } else {
- backimage.Copy(*this);
- }
- }
-
- //active frame
- Create(image.w, image.h, bpp, CXIMAGE_FORMAT_GIF);
-
- if ((image.pf & 0x80) || (dscgif.pflds & 0x80)) {
- uint8_t r[256], g[256], b[256];
- int32_t i;//, has_white = 0;
-
- for (i=0; i < palcount; i++) {
- r[i] = pcurpal[i].r;
- g[i] = pcurpal[i].g;
- b[i] = pcurpal[i].b;
- //if (RGB(r[i],g[i],b[i]) == 0xFFFFFF) has_white = 1;
- }
-
- // Force transparency colour white...
- //if (0) if (info.nBkgndIndex >= 0)
- // r[info.nBkgndIndex] = g[info.nBkgndIndex] = b[info.nBkgndIndex] = 255;
- // Fill in with white // AD
- if (info.nBkgndIndex >= 0) {
- while (i < 256) {
- //has_white = 1;
- r[i] = g[i] = b[i] = 255;
- i++;
- }
- }
-
- // Force last colour to white... // AD
- //if ((info.nBkgndIndex >= 0) && !has_white) {
- // r[255] = g[255] = b[255] = 255;
- //}
-
- SetPalette((info.nBkgndIndex >= 0 ? 256 : palcount), r, g, b);
- }
-
- CImageIterator* iter = new CImageIterator(this);
- iter->Upset();
- int32_t badcode=0;
- ibf = GIFBUFTAM+1;
-
- interlaced = image.pf & 0x40;
- iheight = image.h;
- istep = 8;
- iypos = 0;
- ipass = 0;
-
- int32_t pos_start = fp->Tell();
- //if (interlaced) log << "Interlaced" << endl;
- decoder(fp, iter, image.w, badcode);
- delete iter;
-
- if (info.nEscape) return false; // <vho> - cancel decoding
-
- if (bTrueColor<2 ){ //standard GIF: mix frame with background
- backimage.IncreaseBpp(bpp);
- backimage.GifMix(*this,image);
- backimage.SetTransIndex(first_transparent_index);
- backimage.SetPalette(GetPalette());
- Transfer(backimage,false);
- } else { //it's a truecolor gif!
- //force full image decoding
- info.nFrame=info.nNumFrames-1;
- //build the RGB image
- if (imaRGB==NULL) imaRGB = new CxImage(dscgif.scrwidth,dscgif.scrheight,24,CXIMAGE_FORMAT_GIF);
- //copy the partial image into the full RGB image
- for(int32_t y=0;y<image.h;y++){
- for (int32_t x=0;x<image.w;x++){
- imaRGB->SetPixelColor(x+image.l,dscgif.scrheight-1-image.t-y,GetPixelColor(x,image.h-y-1));
- }
- }
- }
-
- prevdispmeth = (gifgce.flags >> 2) & 0x7;
-
- //restore the correct position in the file for the next image
- if (badcode){
- seek_next_image(fp,pos_start);
- } else {
- fp->Seek(-(ibfmax - ibf - 1), SEEK_CUR);
- }
-
- if (info.bGetAllFrames && imaRGB == NULL) {
- if (iImage == 0) {
- DestroyFrames();
- ppFrames = new CxImage*[info.nNumFrames];
- for(int32_t frameIdx = 0; frameIdx < info.nNumFrames; frameIdx++){
- ppFrames[frameIdx] = NULL;
- }
- }
- ppFrames[iImage] = new CxImage(*this);
- ppFrames[iImage]->SetRetreiveAllFrames(false);
- }
- if (prevdispmeth <= 1) {
- delete previousFrame;
- previousFrame = new CxImage(*this);
- previousFrame->SetRetreiveAllFrames(false);
- }
-
- if ((info.nFrame==iImage) && (info.bGetAllFrames==false)) bContinue=false; else iImage++;
-
- break;
- }
- case ';': //terminator
- bContinue=false;
- break;
- default:
- bPreviousWasNull = (ch==0);
- break;
- }
- }
- }
-
- if (bTrueColor>=2 && imaRGB){
- if (gifgce.flags & 0x1){
- imaRGB->SetTransColor(GetPaletteColor((uint8_t)info.nBkgndIndex));
- imaRGB->SetTransIndex(0);
- }
- Transfer(*imaRGB);
- }
- delete imaRGB;
-
- delete previousFrame;
-
- return true;
-
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageGIF::DecodeExtension(CxFile *fp)
-{
- bool bContinue;
- uint8_t count;
- uint8_t fc;
-
- bContinue = (1 == fp->Read(&fc, sizeof(fc), 1));
- if (bContinue) {
- /* AD - for transparency */
- if (fc == 0xF9) {
- bContinue = (1 == fp->Read(&count, sizeof(count), 1));
- if (bContinue) {
- assert(sizeof(gifgce) == 4);
- bContinue = (count == fp->Read(&gifgce, 1, sizeof(gifgce)));
- gifgce.delaytime = m_ntohs(gifgce.delaytime); // Avoid Byte order problem with Mac <AMSN>
- if (bContinue) {
- info.nBkgndIndex = (gifgce.flags & 0x1) ? gifgce.transpcolindex : -1;
- info.dwFrameDelay = gifgce.delaytime;
- SetDisposalMethod((gifgce.flags >> 2) & 0x7);
- } } }
-
- if (fc == 0xFE) { //<DP> Comment block
- bContinue = (1 == fp->Read(&count, sizeof(count), 1));
- if (bContinue) {
- bContinue = (1 == fp->Read(m_comment, count, 1));
- m_comment[count]='\0';
- } }
-
- if (fc == 0xFF) { //<DP> Application Extension block
- bContinue = (1 == fp->Read(&count, sizeof(count), 1));
- if (bContinue) {
- bContinue = (count==11);
- if (bContinue){
- char AppID[11];
- bContinue = (1 == fp->Read(AppID, count, 1));
- if (bContinue) {
- bContinue = (1 == fp->Read(&count, sizeof(count), 1));
- if (bContinue) {
- uint8_t* dati = (uint8_t*)malloc(count);
- bContinue = (dati!=NULL);
- if (bContinue){
- bContinue = (1 == fp->Read(dati, count, 1));
- if (count>2){
- m_loops = dati[1]+256*dati[2];
- }
- }
- free(dati);
- } } } } }
-
- while (bContinue && fp->Read(&count, sizeof(count), 1) && count) {
- //log << "Skipping " << count << " bytes" << endl;
- fp->Seek(count, SEEK_CUR);
- }
- }
- return bContinue;
-
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-
-// - This external (machine specific) function is expected to return
-// either the next uint8_t from the GIF file, or a negative error number.
-int32_t CxImageGIF::get_byte(CxFile* file)
-{
- if (ibf>=GIFBUFTAM){
- // FW 06/02/98 >>>
- ibfmax = (int32_t)file->Read( buf , 1 , GIFBUFTAM) ;
- if( ibfmax < GIFBUFTAM ) buf[ ibfmax ] = 255 ;
- // FW 06/02/98 <<<
- ibf = 0;
- }
- if (ibf>=ibfmax) return -1; //<DP> avoid overflows
- return buf[ibf++];
-}
-////////////////////////////////////////////////////////////////////////////////
-/* - This function takes a full line of pixels (one uint8_t per pixel) and
- * displays them (or does whatever your program wants with them...). It
- * should return zero, or negative if an error or some other event occurs
- * which would require aborting the decode process... Note that the length
- * passed will almost always be equal to the line length passed to the
- * decoder function, with the sole exception occurring when an ending code
- * occurs in an odd place in the GIF file... In any case, linelen will be
- * equal to the number of pixels passed...
-*/
-int32_t CxImageGIF::out_line(CImageIterator* iter, uint8_t *pixels, int32_t linelen)
-{
- if (iter == NULL || pixels == NULL)
- return -1;
-
- //<DP> for 1 & 4 bpp images, the pixels are compressed
- if (head.biBitCount < 8){
- for(int32_t x=0;x<head.biWidth;x++){
- uint8_t pos;
- uint8_t* iDst= pixels + (x*head.biBitCount >> 3);
- if (head.biBitCount==4){
- pos = (uint8_t)(4*(1-x%2));
- *iDst &= ~(0x0F<<pos);
- *iDst |= ((pixels[x] & 0x0F)<<pos);
- } else if (head.biBitCount==1){
- pos = (uint8_t)(7-x%8);
- *iDst &= ~(0x01<<pos);
- *iDst |= ((pixels[x] & 0x01)<<pos);
- }
- }
- }
-
- /* AD - for interlace */
- if (interlaced) {
- iter->SetY(iheight-iypos-1);
- iter->SetRow(pixels, linelen);
-
- if ((iypos += istep) >= iheight) {
- do {
- if (ipass++ > 0) istep /= 2;
- iypos = istep / 2;
- }
- while (iypos > iheight);
- }
- return 0;
- } else {
- if (iter->ItOK()) {
- iter->SetRow(pixels, linelen);
- (void)iter->PrevRow();
- return 0;
- } else {
- // puts("chafeo");
- return -1;
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-// SaveFile - writes GIF87a gif file
-// Randy Spann 6/15/97
-// R.Spann@ConnRiver.net
-bool CxImageGIF::Encode(CxFile * fp)
-{
- if (EncodeSafeCheck(fp)) return false;
-
- if(head.biBitCount > 8) {
- //strcpy(info.szLastError,"GIF Images must be 8 bit or less");
- //return FALSE;
- return EncodeRGB(fp);
- }
-
- if ( GetNumFrames()>1 && ppFrames ) {
- return Encode(fp, ppFrames, GetNumFrames() );
- }
-
- EncodeHeader(fp);
-
- EncodeExtension(fp);
-
- EncodeComment(fp);
-
- EncodeBody(fp);
-
- fp->PutC(';'); // Write the GIF file terminator
-
- return true; // done!
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageGIF::Encode(CxFile * fp, CxImage ** pImages, int32_t pagecount, bool bLocalColorMap, bool bLocalDispMeth)
-{
- cx_try {
- if (fp==NULL) cx_throw("invalid file pointer");
- if (pImages==NULL || pagecount<=0 || pImages[0]==NULL) cx_throw("multipage GIF, no images!");
-
- int32_t i;
- for (i=0; i<pagecount; i++){
- if (pImages[i]==NULL)
- cx_throw("Bad image pointer");
- if (!(pImages[i]->IsValid()))
- cx_throw("Empty image");
- if (pImages[i]->GetNumColors()==0)
- cx_throw("CxImageGIF::Encode cannot create animated GIFs with a true color frame. Use DecreaseBpp before");
- }
-
- CxImageGIF ghost;
-
- //write the first image
- ghost.Ghost(pImages[0]);
- ghost.EncodeHeader(fp);
-
- if (m_loops!=1){
- ghost.SetLoops(max(0,m_loops-1));
- ghost.EncodeLoopExtension(fp);
- }
-
- if (bLocalDispMeth) {
- ghost.EncodeExtension(fp);
- } else {
- uint8_t dm = ghost.GetDisposalMethod();
- ghost.SetDisposalMethod(GetDisposalMethod());
- ghost.EncodeExtension(fp);
- ghost.SetDisposalMethod(dm);
- }
-
- EncodeComment(fp);
-
- ghost.EncodeBody(fp);
-
- for (i=1; i<pagecount; i++){
- ghost.Ghost(pImages[i]);
-
- if (bLocalDispMeth) {
- ghost.EncodeExtension(fp);
- } else {
- uint8_t dm = ghost.GetDisposalMethod();
- ghost.SetDisposalMethod(GetDisposalMethod());
- ghost.EncodeExtension(fp);
- ghost.SetDisposalMethod(dm);
- }
-
- ghost.EncodeBody(fp,bLocalColorMap);
- }
-
- fp->PutC(';'); // Write the GIF file terminator
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- return false;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::EncodeHeader(CxFile *fp)
-{
- fp->Write("GIF89a",1,6); //GIF Header
-
- Putword(head.biWidth,fp); //Logical screen descriptor
- Putword(head.biHeight,fp);
-
- uint8_t Flags;
- if (head.biClrUsed==0){
- Flags=0x11;
- } else {
- Flags = 0x80;
- Flags |=(head.biBitCount - 1) << 5;
- Flags |=(head.biBitCount - 1);
- }
-
- fp->PutC(Flags); //GIF "packed fields"
- fp->PutC(0); //GIF "BackGround"
- fp->PutC(0); //GIF "pixel aspect ratio"
-
- if (head.biClrUsed!=0){
- RGBQUAD* pPal = GetPalette();
- for(uint32_t i=0; i<head.biClrUsed; ++i)
- {
- fp->PutC(pPal[i].rgbRed);
- fp->PutC(pPal[i].rgbGreen);
- fp->PutC(pPal[i].rgbBlue);
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::EncodeExtension(CxFile *fp)
-{
- // TRK BEGIN : transparency
- fp->PutC('!');
- fp->PutC(TRANSPARENCY_CODE);
-
- gifgce.flags = 0;
- gifgce.flags |= ((info.nBkgndIndex != -1) ? 1 : 0);
- gifgce.flags |= ((GetDisposalMethod() & 0x7) << 2);
- gifgce.delaytime = (uint16_t)info.dwFrameDelay;
- gifgce.transpcolindex = (uint8_t)info.nBkgndIndex;
-
- //Invert byte order in case we use a byte order arch, then set it back <AMSN>
- gifgce.delaytime = m_ntohs(gifgce.delaytime);
- fp->PutC(sizeof(gifgce));
- fp->Write(&gifgce, sizeof(gifgce), 1);
- gifgce.delaytime = m_ntohs(gifgce.delaytime);
-
- fp->PutC(0);
- // TRK END
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::EncodeLoopExtension(CxFile *fp)
-{
- fp->PutC('!'); //byte 1 : 33 (hex 0x21) GIF Extension code
- fp->PutC(255); //byte 2 : 255 (hex 0xFF) Application Extension Label
- fp->PutC(11); //byte 3 : 11 (hex (0x0B) Length of Application Block (eleven bytes of data to follow)
- fp->Write("NETSCAPE2.0",11,1);
- fp->PutC(3); //byte 15 : 3 (hex 0x03) Length of Data Sub-Block (three bytes of data to follow)
- fp->PutC(1); //byte 16 : 1 (hex 0x01)
- Putword(m_loops,fp); //bytes 17 to 18 : 0 to 65535, an unsigned integer in lo-hi byte format.
- //This indicate the number of iterations the loop should be executed.
- fp->PutC(0); //bytes 19 : 0 (hex 0x00) a Data Sub-block Terminator.
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::EncodeBody(CxFile *fp, bool bLocalColorMap)
-{
- curx = 0;
- cury = head.biHeight - 1; //because we read the image bottom to top
- CountDown = (int32_t)head.biWidth * (int32_t)head.biHeight;
-
- fp->PutC(',');
-
- Putword(info.xOffset,fp);
- Putword(info.yOffset,fp);
- Putword(head.biWidth,fp);
- Putword(head.biHeight,fp);
-
- uint8_t Flags=0x00; //non-interlaced (0x40 = interlaced) (0x80 = LocalColorMap)
- if (bLocalColorMap) { Flags|=0x80; Flags|=head.biBitCount-1; }
- fp->PutC(Flags);
-
- if (bLocalColorMap){
- Flags|=0x87;
- RGBQUAD* pPal = GetPalette();
- for(uint32_t i=0; i<head.biClrUsed; ++i)
- {
- fp->PutC(pPal[i].rgbRed);
- fp->PutC(pPal[i].rgbGreen);
- fp->PutC(pPal[i].rgbBlue);
- }
- }
-
- int32_t InitCodeSize = head.biBitCount <=1 ? 2 : head.biBitCount;
- // Write out the initial code size
- fp->PutC((uint8_t)InitCodeSize);
-
- // Go and actually compress the data
- switch (GetCodecOption(CXIMAGE_FORMAT_GIF))
- {
- case 1: //uncompressed
- compressNONE(InitCodeSize+1, fp);
- break;
- case 2: //RLE
- compressRLE(InitCodeSize+1, fp);
- break;
- default: //LZW
- compressLZW(InitCodeSize+1, fp);
- }
-
- // Write out a Zero-length packet (to end the series)
- fp->PutC(0);
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::EncodeComment(CxFile *fp)
-{
- uint32_t n = (uint32_t) strlen(m_comment);
- if (n>255) n=255;
- if (n) {
- fp->PutC('!'); //extension code:
- fp->PutC(254); //comment extension
- fp->PutC((uint8_t)n); //size of comment
- fp->Write(m_comment,n,1);
- fp->PutC(0); //block terminator
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageGIF::EncodeRGB(CxFile *fp)
-{
- EncodeHeader(fp);
-
-// EncodeLoopExtension(fp);
-
- EncodeComment(fp);
-
- uint32_t w,h;
- w=h=0;
- const int32_t cellw = 17;
- const int32_t cellh = 15;
- CxImageGIF tmp;
- for (int32_t y=0;y<head.biHeight;y+=cellh){
- for (int32_t x=0;x<head.biWidth;x+=cellw){
- if ((head.biWidth -x)<cellw) w=head.biWidth -x; else w=cellw;
- if ((head.biHeight-y)<cellh) h=head.biHeight-y; else h=cellh;
-
- if (w!=tmp.GetWidth() || h!=tmp.GetHeight()) tmp.Create(w,h,8);
-
- if (IsTransparent()){
- tmp.SetTransIndex(0);
- tmp.SetPaletteColor(0,GetTransColor());
- }
-
- uint8_t i;
- for (uint32_t j=0;j<h;j++){
- for (uint32_t k=0;k<w;k++){
- i=(uint8_t)(1+k+cellw*j);
- tmp.SetPaletteColor(i,GetPixelColor(x+k,head.biHeight-y-h+j));
- tmp.SetPixelIndex(k,j,tmp.GetNearestIndex(tmp.GetPaletteColor(i)));
- }
- }
-
- tmp.SetOffset(x,y);
- tmp.EncodeExtension(fp);
- tmp.EncodeBody(fp,true);
- }
- }
-
- fp->PutC(';'); // Write the GIF file terminator
-
- return true; // done!
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-// Return the next pixel from the image
-// <DP> fix for 1 & 4 bpp images
-int32_t CxImageGIF::GifNextPixel( )
-{
- if( CountDown == 0 ) return EOF;
- --CountDown;
- int32_t r = GetPixelIndex(curx,cury);
- // Bump the current X position
- ++curx;
- if( curx == head.biWidth ){
- curx = 0;
- cury--; //bottom to top
- }
- return r;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::Putword(int32_t w, CxFile *fp )
-{
- fp->PutC((uint8_t)(w & 0xff));
- fp->PutC((uint8_t)((w >> 8) & 0xff));
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::compressNONE( int32_t init_bits, CxFile* outfile)
-{
- register int32_t c;
- register int32_t ent;
-
- // g_init_bits - initial number of bits
- // g_outfile - pointer to output file
- g_init_bits = init_bits;
- g_outfile = outfile;
-
- // Set up the necessary values
- cur_accum = cur_bits = clear_flg = 0;
- maxcode = (int16_t)MAXCODE(n_bits = g_init_bits);
- code_int maxmaxcode = (code_int)1 << MAXBITSCODES;
-
- ClearCode = (1 << (init_bits - 1));
- EOFCode = ClearCode + 1;
- free_ent = (int16_t)(ClearCode + 2);
-
- a_count=0;
- ent = GifNextPixel( );
-
- output( (code_int)ClearCode );
-
- while ( ent != EOF ) {
- c = GifNextPixel();
-
- output ( (code_int) ent );
- ent = c;
- if ( free_ent < maxmaxcode ) {
- free_ent++;
- } else {
- free_ent=(int16_t)(ClearCode+2);
- clear_flg=1;
- output((code_int)ClearCode);
- }
- }
- // Put out the final code.
- output( (code_int) EOFCode );
-}
-////////////////////////////////////////////////////////////////////////////////
-
-/***************************************************************************
- *
- * GIFCOMPR.C - LZW GIF Image compression routines
- *
- ***************************************************************************/
-
-void CxImageGIF::compressLZW( int32_t init_bits, CxFile* outfile)
-{
- register int32_t fcode;
- register int32_t c;
- register int32_t ent;
- register int32_t hshift;
- register int32_t disp;
- register int32_t i;
-
- // g_init_bits - initial number of bits
- // g_outfile - pointer to output file
- g_init_bits = init_bits;
- g_outfile = outfile;
-
- // Set up the necessary values
- cur_accum = cur_bits = clear_flg = 0;
- maxcode = (int16_t)MAXCODE(n_bits = g_init_bits);
- code_int maxmaxcode = (code_int)1 << MAXBITSCODES;
-
- ClearCode = (1 << (init_bits - 1));
- EOFCode = ClearCode + 1;
- free_ent = (int16_t)(ClearCode + 2);
-
- a_count=0;
- ent = GifNextPixel( );
-
- hshift = 0;
- for ( fcode = (int32_t) HSIZE; fcode < 65536L; fcode *= 2L ) ++hshift;
- hshift = 8 - hshift; /* set hash code range bound */
- cl_hash((int32_t)HSIZE); /* clear hash table */
- output( (code_int)ClearCode );
-
- while ( (c = GifNextPixel( )) != EOF ) {
-
- fcode = (int32_t) (((int32_t) c << MAXBITSCODES) + ent);
- i = (((code_int)c << hshift) ^ ent); /* xor hashing */
-
- if ( HashTabOf (i) == fcode ) {
- ent = CodeTabOf (i);
- continue;
- } else if ( (int32_t)HashTabOf (i) < 0 ) /* empty slot */
- goto nomatch;
- disp = HSIZE - i; /* secondary hash (after G. Knott) */
- if ( i == 0 ) disp = 1;
-probe:
- if ( (i -= disp) < 0 ) i += HSIZE;
- if ( HashTabOf (i) == fcode ) { ent = CodeTabOf (i); continue; }
- if ( (int32_t)HashTabOf (i) > 0 ) goto probe;
-nomatch:
- output ( (code_int) ent );
- ent = c;
- if ( free_ent < maxmaxcode ) {
- CodeTabOf (i) = free_ent++; /* code -> hashtable */
- HashTabOf (i) = fcode;
- } else {
- cl_hash((int32_t)HSIZE);
- free_ent=(int16_t)(ClearCode+2);
- clear_flg=1;
- output((code_int)ClearCode);
- }
- }
- // Put out the final code.
- output( (code_int)ent );
- output( (code_int) EOFCode );
-}
-////////////////////////////////////////////////////////////////////////////////
-
-static const uint32_t code_mask[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
- 0x001F, 0x003F, 0x007F, 0x00FF,
- 0x01FF, 0x03FF, 0x07FF, 0x0FFF,
- 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
-
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::output( code_int code)
-{
- cur_accum &= code_mask[ cur_bits ];
-
- if( cur_bits > 0 )
- cur_accum |= ((int32_t)code << cur_bits);
- else
- cur_accum = code;
-
- cur_bits += n_bits;
-
- while( cur_bits >= 8 ) {
- char_out( (uint32_t)(cur_accum & 0xff) );
- cur_accum >>= 8;
- cur_bits -= 8;
- }
-
- /*
- * If the next entry is going to be too big for the code size,
- * then increase it, if possible.
- */
-
- if ( free_ent > maxcode || clear_flg ) {
- if( clear_flg ) {
- maxcode = (int16_t)MAXCODE(n_bits = g_init_bits);
- clear_flg = 0;
- } else {
- ++n_bits;
- if ( n_bits == MAXBITSCODES )
- maxcode = (code_int)1 << MAXBITSCODES; /* should NEVER generate this code */
- else
- maxcode = (int16_t)MAXCODE(n_bits);
- }
- }
-
- if( code == EOFCode ) {
- // At EOF, write the rest of the buffer.
- while( cur_bits > 0 ) {
- char_out( (uint32_t)(cur_accum & 0xff) );
- cur_accum >>= 8;
- cur_bits -= 8;
- }
-
- flush_char();
- g_outfile->Flush();
-
- if(g_outfile->Error()) strcpy(info.szLastError,"Write Error in GIF file");
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-
-void CxImageGIF::cl_hash(int32_t hsize)
-
-{
- register int32_t *htab_p = htab+hsize;
-
- register int32_t i;
- register int32_t m1 = -1L;
-
- i = hsize - 16;
-
- do {
- *(htab_p-16)=m1;
- *(htab_p-15)=m1;
- *(htab_p-14)=m1;
- *(htab_p-13)=m1;
- *(htab_p-12)=m1;
- *(htab_p-11)=m1;
- *(htab_p-10)=m1;
- *(htab_p-9)=m1;
- *(htab_p-8)=m1;
- *(htab_p-7)=m1;
- *(htab_p-6)=m1;
- *(htab_p-5)=m1;
- *(htab_p-4)=m1;
- *(htab_p-3)=m1;
- *(htab_p-2)=m1;
- *(htab_p-1)=m1;
-
- htab_p-=16;
- } while ((i-=16) >=0);
-
- for (i+=16;i>0;--i)
- *--htab_p=m1;
-}
-
-/*******************************************************************************
-* GIF specific
-*******************************************************************************/
-
-void CxImageGIF::char_out(int32_t c)
-{
- accum[a_count++]=(char)c;
- if (a_count >=254)
- flush_char();
-}
-
-void CxImageGIF::flush_char()
-{
- if (a_count > 0) {
- g_outfile->PutC((uint8_t)a_count);
- g_outfile->Write(accum,1,a_count);
- a_count=0;
- }
-}
-
-/*******************************************************************************
-* GIF decoder
-*******************************************************************************/
-/* DECODE.C - An LZW decoder for GIF
- * Copyright (C) 1987, by Steven A. Bennett
- * Copyright (C) 1994, C++ version by Alejandro Aguilar Sierra
-*
- * Permission is given by the author to freely redistribute and include
- * this code in any program as int32_t as this credit is given where due.
- *
- * In accordance with the above, I want to credit Steve Wilhite who wrote
- * the code which this is heavily inspired by...
- *
- * GIF and 'Graphics Interchange Format' are trademarks (tm) of
- * Compuserve, Incorporated, an H&R Block Company.
- *
- * Release Notes: This file contains a decoder routine for GIF images
- * which is similar, structurally, to the original routine by Steve Wilhite.
- * It is, however, somewhat noticably faster in most cases.
- *
- */
-
-////////////////////////////////////////////////////////////////////////////////
-
-int16_t CxImageGIF::init_exp(int16_t size)
-{
- curr_size = (int16_t)(size + 1);
- top_slot = (int16_t)(1 << curr_size);
- clear = (int16_t)(1 << size);
- ending = (int16_t)(clear + 1);
- slot = newcodes = (int16_t)(ending + 1);
- navail_bytes = nbits_left = 0;
-
- memset(stack,0,MAX_CODES + 1);
- memset(prefix,0,MAX_CODES + 1);
- memset(suffix,0,MAX_CODES + 1);
- return(0);
-}
-////////////////////////////////////////////////////////////////////////////////
-
-/* get_next_code()
- * - gets the next code from the GIF file. Returns the code, or else
- * a negative number in case of file errors...
- */
-int16_t CxImageGIF::get_next_code(CxFile* file)
-{
- int16_t i, x;
- uint32_t ret;
-
- if (nbits_left == 0) {
- if (navail_bytes <= 0) {
- /* Out of bytes in current block, so read next block */
- pbytes = byte_buff;
- if ((navail_bytes = (int16_t)get_byte(file)) < 0)
- return(navail_bytes);
- else if (navail_bytes) {
- for (i = 0; i < navail_bytes; ++i) {
- if ((x = (int16_t)get_byte(file)) < 0) return(x);
- byte_buff[i] = (uint8_t)x;
- }
- }
- }
- b1 = *pbytes++;
- nbits_left = 8;
- --navail_bytes;
- }
-
- if (navail_bytes<0) return ending; // prevent deadlocks (thanks to Mike Melnikov)
-
- ret = b1 >> (8 - nbits_left);
- while (curr_size > nbits_left){
- if (navail_bytes <= 0){
- /* Out of bytes in current block, so read next block*/
- pbytes = byte_buff;
- if ((navail_bytes = (int16_t)get_byte(file)) < 0)
- return(navail_bytes);
- else if (navail_bytes){
- for (i = 0; i < navail_bytes; ++i){
- if ((x = (int16_t)get_byte(file)) < 0) return(x);
- byte_buff[i] = (uint8_t)x;
- }
- }
- }
- b1 = *pbytes++;
- ret |= b1 << nbits_left;
- nbits_left += 8;
- --navail_bytes;
- }
- nbits_left = (int16_t)(nbits_left-curr_size);
- ret &= code_mask[curr_size];
- return((int16_t)(ret));
-}
-////////////////////////////////////////////////////////////////////////////////
-
-/* int16_t decoder(linewidth)
- * int16_t linewidth; * Pixels per line of image *
- *
- * - This function decodes an LZW image, according to the method used
- * in the GIF spec. Every *linewidth* "characters" (ie. pixels) decoded
- * will generate a call to out_line(), which is a user specific function
- * to display a line of pixels. The function gets it's codes from
- * get_next_code() which is responsible for reading blocks of data and
- * seperating them into the proper size codes. Finally, get_byte() is
- * the global routine to read the next uint8_t from the GIF file.
- *
- * It is generally a good idea to have linewidth correspond to the actual
- * width of a line (as specified in the Image header) to make your own
- * code a bit simpler, but it isn't absolutely necessary.
- *
- * Returns: 0 if successful, else negative. (See ERRS.H)
- *
- */
-/* bad_code_count is incremented each time an out of range code is read.
- * When this value is non-zero after a decode, your GIF file is probably
- * corrupt in some way...
- */
-int16_t CxImageGIF::decoder(CxFile* file, CImageIterator* iter, int16_t linewidth, int32_t &bad_code_count)
-{
- register uint8_t *sp, *bufptr;
- uint8_t *buf;
- register int16_t code, fc, oc, bufcnt;
- int16_t c, size, ret;
-
- if (linewidth<=0)
- return BAD_LINE_WIDTH;
-
- /* Initialize for decoding a new image... */
- bad_code_count = 0;
- if ((size = (int16_t)get_byte(file)) < 0) return(size);
- if (size < 2 || 9 < size) return(BAD_CODE_SIZE);
- // out_line = outline;
- init_exp(size);
- //printf("L %d %x\n",linewidth,size);
-
- /* Initialize in case they forgot to put in a clear code.
- * (This shouldn't happen, but we'll try and decode it anyway...)
- */
- oc = fc = 0;
-
- /* Allocate space for the decode buffer */
- if ((buf = new uint8_t[linewidth + 1]) == NULL) return(OUT_OF_MEMORY);
-
- /* Set up the stack pointer and decode buffer pointer */
- sp = stack;
- bufptr = buf;
- bufcnt = linewidth;
-
- /* This is the main loop. For each code we get we pass through the
- * linked list of prefix codes, pushing the corresponding "character" for
- * each code onto the stack. When the list reaches a single "character"
- * we push that on the stack too, and then start unstacking each
- * character for output in the correct order. Special handling is
- * included for the clear code, and the whole thing ends when we get
- * an ending code.
- */
- while ((c = get_next_code(file)) != ending) {
- /* If we had a file error, return without completing the decode*/
- if (c < 0){
- delete [] buf;
- return(0);
- }
- /* If the code is a clear code, reinitialize all necessary items.*/
- if (c == clear){
- curr_size = (int16_t)(size + 1);
- slot = newcodes;
- top_slot = (int16_t)(1 << curr_size);
-
- /* Continue reading codes until we get a non-clear code
- * (Another unlikely, but possible case...)
- */
- while ((c = get_next_code(file)) == clear);
-
- /* If we get an ending code immediately after a clear code
- * (Yet another unlikely case), then break out of the loop.
- */
- if (c == ending) break;
-
- /* Finally, if the code is beyond the range of already set codes,
- * (This one had better NOT happen... I have no idea what will
- * result from this, but I doubt it will look good...) then set it
- * to color zero.
- */
- if (c >= slot) c = 0;
- oc = fc = c;
-
- /* And let us not forget to put the char into the buffer... And
- * if, on the off chance, we were exactly one pixel from the end
- * of the line, we have to send the buffer to the out_line()
- * routine...
- */
- *bufptr++ = (uint8_t)c;
- if (--bufcnt == 0) {
- if (iter) {
- if ((ret = (int16_t)out_line(iter, buf, linewidth)) < 0) {
- delete [] buf;
- return(ret);
- }
- }
- bufptr = buf;
- bufcnt = linewidth;
- }
- } else {
- /* In this case, it's not a clear code or an ending code, so
- * it must be a code code... So we can now decode the code into
- * a stack of character codes. (Clear as mud, right?)
- */
- code = c;
-
- /* Here we go again with one of those off chances... If, on the
- * off chance, the code we got is beyond the range of those already
- * set up (Another thing which had better NOT happen...) we trick
- * the decoder into thinking it actually got the last code read.
- * (Hmmn... I'm not sure why this works... But it does...)
- */
- if (code >= slot && sp<(stack+MAX_CODES-1)) {
- if (code > slot)
- ++bad_code_count;
- code = oc;
- *sp++ = (uint8_t)fc;
- }
-
- /* Here we scan back along the linked list of prefixes, pushing
- * helpless characters (ie. suffixes) onto the stack as we do so.
- */
- while (code >= newcodes && sp<(stack+MAX_CODES-1)) {
- *sp++ = suffix[code];
- code = prefix[code];
- }
-
- /* Push the last character on the stack, and set up the new
- * prefix and suffix, and if the required slot number is greater
- * than that allowed by the current bit size, increase the bit
- * size. (NOTE - If we are all full, we *don't* save the new
- * suffix and prefix... I'm not certain if this is correct...
- * it might be more proper to overwrite the last code...
- */
- *sp++ = (uint8_t)code;
- if (slot < top_slot){
- suffix[slot] = (uint8_t)(fc = (uint8_t)code);
- prefix[slot++] = oc;
- oc = c;
- }
- if (slot >= top_slot){
- if (curr_size < 12) {
- top_slot <<= 1;
- ++curr_size;
- }
- }
-
- /* Now that we've pushed the decoded string (in reverse order)
- * onto the stack, lets pop it off and put it into our decode
- * buffer... And when the decode buffer is full, write another
- * line...
- */
- while (sp > stack) {
- *bufptr++ = *(--sp);
- if (--bufcnt == 0) {
- if (iter) {
- if ((ret = (int16_t)out_line(iter, buf, linewidth)) < 0) {
- delete [] buf;
- return(ret);
- }
- }
- bufptr = buf;
- bufcnt = linewidth;
- }
- }
- }
- }
- ret = 0;
- if (bufcnt != linewidth && iter)
- ret = (int16_t)out_line(iter, buf, (linewidth - bufcnt));
- delete [] buf;
- return(ret);
-}
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImageGIF::get_num_frames(CxFile *fp,struct_TabCol* TabColSrc,struct_dscgif* dscgif)
-{
- struct_image image;
-
- int32_t pos=fp->Tell();
- int32_t nframes=0;
-
- struct_TabCol TempTabCol;
- memcpy(&TempTabCol,TabColSrc,sizeof(struct_TabCol));
-
- char ch;
- bool bPreviousWasNull = true;
-
- for (BOOL bContinue = TRUE; bContinue; )
- {
- if (fp->Read(&ch, sizeof(ch), 1) != 1) {break;}
-
- if (bPreviousWasNull || ch==0)
- {
- switch (ch)
- {
- case '!': // extension
- {
- DecodeExtension(fp);
- break;
- }
- case ',': // image
- {
-
- assert(sizeof(image) == 9);
- //log << "Image header" << endl;
- fp->Read(&image,sizeof(image),1);
-
- //avoid byte order problems with Solaris <candan> <AMSN>
- image.l = m_ntohs(image.l);
- image.t = m_ntohs(image.t);
- image.w = m_ntohs(image.w);
- image.h = m_ntohs(image.h);
-
- // in case of images with empty screen descriptor, give a last chance
- if (dscgif->scrwidth==0 && dscgif->scrheight==0){
- dscgif->scrwidth = image.w;
- dscgif->scrheight = image.h;
- }
-
- if (((image.l + image.w) > dscgif->scrwidth)||((image.t + image.h) > dscgif->scrheight))
- break;
-
- nframes++;
-
- // Local colour map?
- if (image.pf & 0x80) {
- TempTabCol.sogct = (int16_t)(1 << ((image.pf & 0x07) +1));
- assert(3 == sizeof(struct rgb_color));
- fp->Read(TempTabCol.paleta,sizeof(struct rgb_color)*TempTabCol.sogct,1);
- //log << "Local colour map" << endl;
- }
-
- int32_t badcode=0;
- ibf = GIFBUFTAM+1;
-
- interlaced = image.pf & 0x40;
- iheight = image.h;
- istep = 8;
- iypos = 0;
- ipass = 0;
-
- int32_t pos_start = fp->Tell();
-
- //if (interlaced) log << "Interlaced" << endl;
- decoder(fp, 0, image.w, badcode);
-
- if (badcode){
- seek_next_image(fp,pos_start);
- } else {
- fp->Seek(-(ibfmax - ibf - 1), SEEK_CUR);
- }
-
- break;
- }
- case ';': //terminator
- bContinue=false;
- break;
- default:
- bPreviousWasNull = (ch==0);
- break;
- }
- }
- }
-
- fp->Seek(pos,SEEK_SET);
- return nframes;
-}
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImageGIF::seek_next_image(CxFile* fp, int32_t position)
-{
- fp->Seek(position, SEEK_SET);
- char ch1,ch2;
- ch1=ch2=0;
- while(fp->Read(&ch2,sizeof(char),1)>0){
- if (ch1 == 0 && ch2 == ','){
- fp->Seek(-1,SEEK_CUR);
- return fp->Tell();
- } else {
- ch1 = ch2;
- }
- }
- return -1;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::SetLoops(int32_t loops)
-{ m_loops=loops; }
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImageGIF::GetLoops()
-{ return m_loops; }
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::SetComment(const char* sz_comment_in)
-{ if (sz_comment_in) strncpy(m_comment,sz_comment_in,255); }
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::GetComment(char* sz_comment_out)
-{ if (sz_comment_out) strncpy(sz_comment_out,m_comment,255); }
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::GifMix(CxImage & imgsrc2, struct_image & imgdesc)
-{
- int32_t ymin = max(0,(int32_t)(GetHeight()-imgdesc.t - imgdesc.h));
- int32_t ymax = GetHeight()-imgdesc.t;
- int32_t xmin = imgdesc.l;
- int32_t xmax = min(GetWidth(), (uint32_t)(imgdesc.l + imgdesc.w));
-
- int32_t ibg2= imgsrc2.GetTransIndex();
- uint8_t i2;
-
- for(int32_t y = ymin; y < ymax; y++){
- for(int32_t x = xmin; x < xmax; x++){
- i2 = imgsrc2.GetPixelIndex(x-xmin,y-ymin);
- if(i2!=ibg2) SetPixelIndex(x,y,i2);
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/*-----------------------------------------------------------------------
- *
- * miGIF Compression - mouse and ivo's GIF-compatible compression
- *
- * -run length encoding compression routines-
- *
- * Copyright (C) 1998 Hutchison Avenue Software Corporation
- * http://www.hasc.com
- * info@hasc.com
- *
- * Permission to use, copy, modify, and distribute this software and its
- * documentation for any purpose and without fee is hereby granted, provided
- * that the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation. This software is provided "AS IS." The Hutchison Avenue
- * Software Corporation disclaims all warranties, either express or implied,
- * including but not limited to implied warranties of merchantability and
- * fitness for a particular purpose, with respect to this code and accompanying
- * documentation.
- *
- * The miGIF compression routines do not, strictly speaking, generate files
- * conforming to the GIF spec, since the image data is not LZW-compressed
- * (this is the point: in order to avoid transgression of the Unisys patent
- * on the LZW algorithm.) However, miGIF generates data streams that any
- * reasonably sane LZW decompresser will decompress to what we want.
- *
- * miGIF compression uses run length encoding. It compresses horizontal runs
- * of pixels of the same color. This type of compression gives good results
- * on images with many runs, for example images with lines, text and solid
- * shapes on a solid-colored background. It gives little or no compression
- * on images with few runs, for example digital or scanned photos.
- *
- * der Mouse
- * mouse@rodents.montreal.qc.ca
- * 7D C8 61 52 5D E7 2D 39 4E F1 31 3E E8 B3 27 4B
- *
- * ivo@hasc.com
- *
- * The Graphics Interchange Format(c) is the Copyright property of
- * CompuServe Incorporated. GIF(sm) is a Service Mark property of
- * CompuServe Incorporated.
- *
- */
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_clear(struct_RLE* rle)
-{
- rle->out_bits = rle->out_bits_init;
- rle->out_bump = rle->out_bump_init;
- rle->out_clear = rle->out_clear_init;
- rle->out_count = 0;
- rle->rl_table_max = 0;
- rle->just_cleared = 1;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_flush(struct_RLE* rle)
-{
- if (rle->rl_count == 1){
- rle_output_plain(rle->rl_pixel,rle);
- rle->rl_count = 0;
- return;
- }
- if (rle->just_cleared){
- rle_flush_fromclear(rle->rl_count,rle);
- } else if ((rle->rl_table_max < 2) || (rle->rl_table_pixel != rle->rl_pixel)) {
- rle_flush_clearorrep(rle->rl_count,rle);
- } else {
- rle_flush_withtable(rle->rl_count,rle);
- }
- rle->rl_count = 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_output_plain(int32_t c,struct_RLE* rle)
-{
- rle->just_cleared = 0;
- rle_output(c,rle);
- rle->out_count++;
- if (rle->out_count >= rle->out_bump){
- rle->out_bits ++;
- rle->out_bump += 1 << (rle->out_bits - 1);
- }
- if (rle->out_count >= rle->out_clear){
- rle_output(rle->code_clear,rle);
- rle_clear(rle);
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_flush_fromclear(int32_t count,struct_RLE* rle)
-{
- int32_t n;
-
- rle->out_clear = rle->max_ocodes;
- rle->rl_table_pixel = rle->rl_pixel;
- n = 1;
- while (count > 0){
- if (n == 1){
- rle->rl_table_max = 1;
- rle_output_plain(rle->rl_pixel,rle);
- count --;
- } else if (count >= n){
- rle->rl_table_max = n;
- rle_output_plain(rle->rl_basecode+n-2,rle);
- count -= n;
- } else if (count == 1){
- rle->rl_table_max ++;
- rle_output_plain(rle->rl_pixel,rle);
- count = 0;
- } else {
- rle->rl_table_max ++;
- rle_output_plain(rle->rl_basecode+count-2,rle);
- count = 0;
- }
- if (rle->out_count == 0) n = 1; else n ++;
- }
- rle_reset_out_clear(rle);
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_reset_out_clear(struct_RLE* rle)
-{
- rle->out_clear = rle->out_clear_init;
- if (rle->out_count >= rle->out_clear){
- rle_output(rle->code_clear,rle);
- rle_clear(rle);
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_flush_withtable(int32_t count, struct_RLE* rle)
-{
- int32_t repmax;
- int32_t repleft;
- int32_t leftover;
-
- repmax = count / rle->rl_table_max;
- leftover = count % rle->rl_table_max;
- repleft = (leftover ? 1 : 0);
- if (rle->out_count+repmax+repleft > rle->max_ocodes){
- repmax = rle->max_ocodes - rle->out_count;
- leftover = count - (repmax * rle->rl_table_max);
- repleft = 1 + rle_compute_triangle_count(leftover,rle->max_ocodes);
- }
- if (1+rle_compute_triangle_count(count,rle->max_ocodes) < (uint32_t)(repmax+repleft)){
- rle_output(rle->code_clear,rle);
- rle_clear(rle);
- rle_flush_fromclear(count,rle);
- return;
- }
- rle->out_clear = rle->max_ocodes;
- for (;repmax>0;repmax--) rle_output_plain(rle->rl_basecode+rle->rl_table_max-2,rle);
- if (leftover){
- if (rle->just_cleared){
- rle_flush_fromclear(leftover,rle);
- } else if (leftover == 1){
- rle_output_plain(rle->rl_pixel,rle);
- } else {
- rle_output_plain(rle->rl_basecode+leftover-2,rle);
- }
- }
- rle_reset_out_clear(rle);
-}
-////////////////////////////////////////////////////////////////////////////////
-uint32_t CxImageGIF::rle_compute_triangle_count(uint32_t count, uint32_t nrepcodes)
-{
- uint32_t perrep;
- uint32_t cost;
-
- cost = 0;
- perrep = (nrepcodes * (nrepcodes+1)) / 2;
- while (count >= perrep){
- cost += nrepcodes;
- count -= perrep;
- }
- if (count > 0){
- uint32_t n;
- n = rle_isqrt(count);
- while ((n*(n+1)) >= 2*count) n --;
- while ((n*(n+1)) < 2*count) n ++;
- cost += n;
- }
- return(cost);
-}
-////////////////////////////////////////////////////////////////////////////////
-uint32_t CxImageGIF::rle_isqrt(uint32_t x)
-{
- uint32_t r;
- uint32_t v;
-
- if (x < 2) return(x);
- for (v=x,r=1;v;v>>=2,r<<=1) ;
- for( ;; )
- {
- v = ((x / r) + r) / 2;
- if ((v == r) || (v == r+1)) return(r);
- r = v;
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_flush_clearorrep(int32_t count, struct_RLE* rle)
-{
- int32_t withclr;
- withclr = 1 + rle_compute_triangle_count(count,rle->max_ocodes);
- if (withclr < count) {
- rle_output(rle->code_clear,rle);
- rle_clear(rle);
- rle_flush_fromclear(count,rle);
- } else {
- for (;count>0;count--) rle_output_plain(rle->rl_pixel,rle);
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_write_block(struct_RLE* rle)
-{
- g_outfile->PutC((uint8_t)rle->oblen);
- g_outfile->Write(rle->oblock,1,rle->oblen);
- rle->oblen = 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_block_out(uint8_t c, struct_RLE* rle)
-{
- rle->oblock[rle->oblen++] = c;
- if (rle->oblen >= 255) rle_write_block(rle);
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_block_flush(struct_RLE* rle)
-{
- if (rle->oblen > 0) rle_write_block(rle);
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_output(int32_t val, struct_RLE* rle)
-{
- rle->obuf |= val << rle->obits;
- rle->obits += rle->out_bits;
- while (rle->obits >= 8){
- rle_block_out((uint8_t)(rle->obuf&0xff),rle);
- rle->obuf >>= 8;
- rle->obits -= 8;
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::rle_output_flush(struct_RLE* rle)
-{
- if (rle->obits > 0) rle_block_out((uint8_t)(rle->obuf),rle);
- rle_block_flush(rle);
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageGIF::compressRLE( int32_t init_bits, CxFile* outfile)
-{
- g_init_bits = init_bits;
- g_outfile = outfile;
-
- struct_RLE rle;
- rle.code_clear = 1 << (init_bits - 1);
- rle.code_eof = rle.code_clear + 1;
- rle.rl_basecode = rle.code_eof + 1;
- rle.out_bump_init = (1 << (init_bits - 1)) - 1;
- rle.out_clear_init = (init_bits <= 3) ? 9 : (rle.out_bump_init-1);
- rle.out_bits_init = init_bits;
- rle.max_ocodes = (1 << MAXBITSCODES) - ((1 << (rle.out_bits_init - 1)) + 3);
- rle.rl_count = 0;
- rle_clear(&rle);
- rle.obuf = 0;
- rle.obits = 0;
- rle.oblen = 0;
-
- rle_output(rle.code_clear,&rle);
-
- int32_t c;
- for( ;; )
- {
- c = GifNextPixel();
- if ((rle.rl_count > 0) && (c != rle.rl_pixel)) rle_flush(&rle);
- if (c == EOF) break;
- if (rle.rl_pixel == c){
- rle.rl_count++;
- } else {
- rle.rl_pixel = c;
- rle.rl_count = 1;
- }
- }
- rle_output(rle.code_eof,&rle);
- rle_output_flush(&rle);
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_GIF
diff --git a/smelt/sdl/CxImage/ximagif.h b/smelt/sdl/CxImage/ximagif.h deleted file mode 100644 index 4eec35e..0000000 --- a/smelt/sdl/CxImage/ximagif.h +++ /dev/null @@ -1,244 +0,0 @@ -/*
- * File: ximagif.h
- * Purpose: GIF Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImageGIF (c) 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- *
- * Special thanks to Troels Knakkergaard for new features, enhancements and bugfixes
- *
- * original CImageGIF and CImageIterator implementation are:
- * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra(at)servidor(dot)unam(dot)mx>
- *
- * 6/15/97 Randy Spann: Added GIF87a writing support
- * R.Spann@ConnRiver.net
- *
- * DECODE.C - An LZW decoder for GIF
- * Copyright (C) 1987, by Steven A. Bennett
- * Copyright (C) 1994, C++ version by Alejandro Aguilar Sierra
- *
- * In accordance with the above, I want to credit Steve Wilhite who wrote
- * the code which this is heavily inspired by...
- *
- * GIF and 'Graphics Interchange Format' are trademarks (tm) of
- * Compuserve, Incorporated, an H&R Block Company.
- *
- * Release Notes: This file contains a decoder routine for GIF images
- * which is similar, structurally, to the original routine by Steve Wilhite.
- * It is, however, somewhat noticably faster in most cases.
- *
- * ==========================================================
- */
-
-#if !defined(__ximaGIF_h)
-#define __ximaGIF_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_GIF
-
-typedef int16_t code_int;
-
-/* Various error codes used by decoder */
-#define OUT_OF_MEMORY -10
-#define BAD_CODE_SIZE -20
-#define READ_ERROR -1
-#define WRITE_ERROR -2
-#define OPEN_ERROR -3
-#define CREATE_ERROR -4
-#define BAD_LINE_WIDTH -5
-#define MAX_CODES 4095
-#define GIFBUFTAM 16383
-#define TRANSPARENCY_CODE 0xF9
-
-//LZW GIF Image compression
-#define MAXBITSCODES 12
-#define HSIZE 5003 /* 80% occupancy */
-#define MAXCODE(n_bits) (((code_int) 1 << (n_bits)) - 1)
-#define HashTabOf(i) htab[i]
-#define CodeTabOf(i) codetab[i]
-
-
-class CImageIterator;
-class DLL_EXP CxImageGIF: public CxImage
-{
-#pragma pack(1)
-
-typedef struct tag_gifgce{
- uint8_t flags; /*res:3|dispmeth:3|userinputflag:1|transpcolflag:1*/
- uint16_t delaytime;
- uint8_t transpcolindex;
-} struct_gifgce;
-
-typedef struct tag_dscgif{ /* Logic Screen Descriptor */
- char header[6]; /* Firma and version */
- uint16_t scrwidth;
- uint16_t scrheight;
- char pflds;
- char bcindx;
- char pxasrat;
-} struct_dscgif;
-
-typedef struct tag_image{ /* Image Descriptor */
- uint16_t l;
- uint16_t t;
- uint16_t w;
- uint16_t h;
- uint8_t pf;
-} struct_image;
-
-typedef struct tag_TabCol{ /* Tabla de colores */
- int16_t colres; /* color resolution */
- int16_t sogct; /* size of global color table */
- rgb_color paleta[256]; /* paleta */
-} struct_TabCol;
-
-typedef struct tag_RLE{
- int32_t rl_pixel;
- int32_t rl_basecode;
- int32_t rl_count;
- int32_t rl_table_pixel;
- int32_t rl_table_max;
- int32_t just_cleared;
- int32_t out_bits;
- int32_t out_bits_init;
- int32_t out_count;
- int32_t out_bump;
- int32_t out_bump_init;
- int32_t out_clear;
- int32_t out_clear_init;
- int32_t max_ocodes;
- int32_t code_clear;
- int32_t code_eof;
- uint32_t obuf;
- int32_t obits;
- uint8_t oblock[256];
- int32_t oblen;
-} struct_RLE;
-#pragma pack()
-
-public:
- CxImageGIF();
- ~CxImageGIF();
-
-// bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_GIF);}
-// bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_GIF);}
-
- bool Decode(CxFile * fp);
- bool Decode(FILE *fp) { CxIOFile file(fp); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * fp);
- bool Encode(CxFile * fp, CxImage ** pImages, int32_t pagecount, bool bLocalColorMap = false, bool bLocalDispMeth = false);
- bool Encode(FILE *fp) { CxIOFile file(fp); return Encode(&file); }
- bool Encode(FILE *fp, CxImage ** pImages, int32_t pagecount, bool bLocalColorMap = false)
- { CxIOFile file(fp); return Encode(&file, pImages, pagecount, bLocalColorMap); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-
- void SetLoops(int32_t loops);
- int32_t GetLoops();
- void SetComment(const char* sz_comment_in);
- void GetComment(char* sz_comment_out);
-
-protected:
- bool DecodeExtension(CxFile *fp);
- void EncodeHeader(CxFile *fp);
- void EncodeLoopExtension(CxFile *fp);
- void EncodeExtension(CxFile *fp);
- void EncodeBody(CxFile *fp, bool bLocalColorMap = false);
- void EncodeComment(CxFile *fp);
- bool EncodeRGB(CxFile *fp);
- void GifMix(CxImage & imgsrc2, struct_image & imgdesc);
-
- struct_gifgce gifgce;
-
- int32_t curx, cury;
- int32_t CountDown;
- uint32_t cur_accum;
- int32_t cur_bits;
- int32_t interlaced, iypos, istep, iheight, ipass;
- int32_t ibf;
- int32_t ibfmax;
- uint8_t * buf;
-// Implementation
- int32_t GifNextPixel ();
- void Putword (int32_t w, CxFile* fp );
- void compressNONE (int32_t init_bits, CxFile* outfile);
- void compressLZW (int32_t init_bits, CxFile* outfile);
- void output (code_int code );
- void cl_hash (int32_t hsize);
- void char_out (int32_t c);
- void flush_char ();
- int16_t init_exp(int16_t size);
- int16_t get_next_code(CxFile*);
- int16_t decoder(CxFile*, CImageIterator* iter, int16_t linewidth, int32_t &bad_code_count);
- int32_t get_byte(CxFile*);
- int32_t out_line(CImageIterator* iter, uint8_t *pixels, int32_t linelen);
- int32_t get_num_frames(CxFile *f,struct_TabCol* TabColSrc,struct_dscgif* dscgif);
- int32_t seek_next_image(CxFile* fp, int32_t position);
-
- int16_t curr_size; /* The current code size */
- int16_t clear; /* Value for a clear code */
- int16_t ending; /* Value for a ending code */
- int16_t newcodes; /* First available code */
- int16_t top_slot; /* Highest code for current size */
- int16_t slot; /* Last read code */
-
- /* The following static variables are used
- * for seperating out codes */
- int16_t navail_bytes; /* # bytes left in block */
- int16_t nbits_left; /* # bits left in current uint8_t */
- uint8_t b1; /* Current uint8_t */
- uint8_t * byte_buff; /* Current block */
- uint8_t *pbytes; /* Pointer to next uint8_t in block */
- /* The reason we have these seperated like this instead of using
- * a structure like the original Wilhite code did, is because this
- * stuff generally produces significantly faster code when compiled...
- * This code is full of similar speedups... (For a good book on writing
- * C for speed or for space optomisation, see Efficient C by Tom Plum,
- * published by Plum-Hall Associates...)
- */
- uint8_t * stack; /* Stack for storing pixels */
- uint8_t * suffix; /* Suffix table */
- uint16_t * prefix; /* Prefix linked list */
-
-//LZW GIF Image compression routines
- int32_t * htab;
- uint16_t * codetab;
- int32_t n_bits; /* number of bits/code */
- code_int maxcode; /* maximum code, given n_bits */
- code_int free_ent; /* first unused entry */
- int32_t clear_flg;
- int32_t g_init_bits;
- CxFile* g_outfile;
- int32_t ClearCode;
- int32_t EOFCode;
-
- int32_t a_count;
- char * accum;
-
- char * m_comment;
- int32_t m_loops;
-
-//RLE compression routines
- void compressRLE( int32_t init_bits, CxFile* outfile);
- void rle_clear(struct_RLE* rle);
- void rle_flush(struct_RLE* rle);
- void rle_flush_withtable(int32_t count, struct_RLE* rle);
- void rle_flush_clearorrep(int32_t count, struct_RLE* rle);
- void rle_flush_fromclear(int32_t count,struct_RLE* rle);
- void rle_output_plain(int32_t c,struct_RLE* rle);
- void rle_reset_out_clear(struct_RLE* rle);
- uint32_t rle_compute_triangle_count(uint32_t count, uint32_t nrepcodes);
- uint32_t rle_isqrt(uint32_t x);
- void rle_write_block(struct_RLE* rle);
- void rle_block_out(uint8_t c, struct_RLE* rle);
- void rle_block_flush(struct_RLE* rle);
- void rle_output(int32_t val, struct_RLE* rle);
- void rle_output_flush(struct_RLE* rle);
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximahist.cpp b/smelt/sdl/CxImage/ximahist.cpp deleted file mode 100644 index 830337f..0000000 --- a/smelt/sdl/CxImage/ximahist.cpp +++ /dev/null @@ -1,627 +0,0 @@ -// xImaHist.cpp : histogram functions
-/* 28/01/2004 v1.00 - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_DSP
-
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImage::Histogram(int32_t* red, int32_t* green, int32_t* blue, int32_t* gray, int32_t colorspace)
-{
- if (!pDib) return 0;
- RGBQUAD color;
-
- if (red) memset(red,0,256*sizeof(int32_t));
- if (green) memset(green,0,256*sizeof(int32_t));
- if (blue) memset(blue,0,256*sizeof(int32_t));
- if (gray) memset(gray,0,256*sizeof(int32_t));
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- for(int32_t y=ymin; y<ymax; y++){
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- switch (colorspace){
- case 1:
- color = HSLtoRGB(BlindGetPixelColor(x,y));
- break;
- case 2:
- color = YUVtoRGB(BlindGetPixelColor(x,y));
- break;
- case 3:
- color = YIQtoRGB(BlindGetPixelColor(x,y));
- break;
- case 4:
- color = XYZtoRGB(BlindGetPixelColor(x,y));
- break;
- default:
- color = BlindGetPixelColor(x,y);
- }
-
- if (red) red[color.rgbRed]++;
- if (green) green[color.rgbGreen]++;
- if (blue) blue[color.rgbBlue]++;
- if (gray) gray[(uint8_t)RGB2GRAY(color.rgbRed,color.rgbGreen,color.rgbBlue)]++;
- }
- }
- }
-
- int32_t n=0;
- for (int32_t i=0; i<256; i++){
- if (red && red[i]>n) n=red[i];
- if (green && green[i]>n) n=green[i];
- if (blue && blue[i]>n) n=blue[i];
- if (gray && gray[i]>n) n=gray[i];
- }
-
- return n;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * HistogramStretch
- * \param method: 0 = luminance (default), 1 = linked channels , 2 = independent channels.
- * \param threshold: minimum percentage level in the histogram to recognize it as meaningful. Range: 0.0 to 1.0; default = 0; typical = 0.005 (0.5%);
- * \return true if everything is ok
- * \author [dave] and [nipper]; changes [DP]
- */
-bool CxImage::HistogramStretch(int32_t method, double threshold)
-{
- if (!pDib) return false;
-
- double dbScaler = 50.0/head.biHeight;
- int32_t x,y;
-
- if ((head.biBitCount==8) && IsGrayScale()){
-
- double p[256];
- memset(p, 0, 256*sizeof(double));
- for (y=0; y<head.biHeight; y++)
- {
- info.nProgress = (int32_t)(y*dbScaler);
- if (info.nEscape) break;
- for (x=0; x<head.biWidth; x++) {
- p[BlindGetPixelIndex(x, y)]++;
- }
- }
-
- double maxh = 0;
- for (y=0; y<255; y++) if (maxh < p[y]) maxh = p[y];
- threshold *= maxh;
- int32_t minc = 0;
- while (minc<255 && p[minc]<=threshold) minc++;
- int32_t maxc = 255;
- while (maxc>0 && p[maxc]<=threshold) maxc--;
-
- if (minc == 0 && maxc == 255) return true;
- if (minc >= maxc) return true;
-
- // calculate LUT
- uint8_t lut[256];
- for (x = 0; x <256; x++){
- lut[x] = (uint8_t)max(0,min(255,(255 * (x - minc) / (maxc - minc))));
- }
-
- for (y=0; y<head.biHeight; y++) {
- if (info.nEscape) break;
- info.nProgress = (int32_t)(50.0+y*dbScaler);
- for (x=0; x<head.biWidth; x++)
- {
- BlindSetPixelIndex(x, y, lut[BlindGetPixelIndex(x, y)]);
- }
- }
- } else {
- switch(method){
- case 1:
- { // <nipper>
- double p[256];
- memset(p, 0, 256*sizeof(double));
- for (y=0; y<head.biHeight; y++)
- {
- info.nProgress = (int32_t)(y*dbScaler);
- if (info.nEscape) break;
- for (x=0; x<head.biWidth; x++) {
- RGBQUAD color = BlindGetPixelColor(x, y);
- p[color.rgbRed]++;
- p[color.rgbBlue]++;
- p[color.rgbGreen]++;
- }
- }
- double maxh = 0;
- for (y=0; y<255; y++) if (maxh < p[y]) maxh = p[y];
- threshold *= maxh;
- int32_t minc = 0;
- while (minc<255 && p[minc]<=threshold) minc++;
- int32_t maxc = 255;
- while (maxc>0 && p[maxc]<=threshold) maxc--;
-
- if (minc == 0 && maxc == 255) return true;
- if (minc >= maxc) return true;
-
- // calculate LUT
- uint8_t lut[256];
- for (x = 0; x <256; x++){
- lut[x] = (uint8_t)max(0,min(255,(255 * (x - minc) / (maxc - minc))));
- }
-
- // normalize image
- for (y=0; y<head.biHeight; y++) {
- if (info.nEscape) break;
- info.nProgress = (int32_t)(50.0+y*dbScaler);
-
- for (x=0; x<head.biWidth; x++)
- {
- RGBQUAD color = BlindGetPixelColor(x, y);
-
- color.rgbRed = lut[color.rgbRed];
- color.rgbBlue = lut[color.rgbBlue];
- color.rgbGreen = lut[color.rgbGreen];
-
- BlindSetPixelColor(x, y, color);
- }
- }
- }
- break;
- case 2:
- { // <nipper>
- double pR[256];
- memset(pR, 0, 256*sizeof(double));
- double pG[256];
- memset(pG, 0, 256*sizeof(double));
- double pB[256];
- memset(pB, 0, 256*sizeof(double));
- for (y=0; y<head.biHeight; y++)
- {
- info.nProgress = (int32_t)(y*dbScaler);
- if (info.nEscape) break;
- for (int32_t x=0; x<head.biWidth; x++) {
- RGBQUAD color = BlindGetPixelColor(x, y);
- pR[color.rgbRed]++;
- pB[color.rgbBlue]++;
- pG[color.rgbGreen]++;
- }
- }
-
- double maxh = 0;
- for (y=0; y<255; y++) if (maxh < pR[y]) maxh = pR[y];
- double threshold2 = threshold*maxh;
- int32_t minR = 0;
- while (minR<255 && pR[minR]<=threshold2) minR++;
- int32_t maxR = 255;
- while (maxR>0 && pR[maxR]<=threshold2) maxR--;
-
- maxh = 0;
- for (y=0; y<255; y++) if (maxh < pG[y]) maxh = pG[y];
- threshold2 = threshold*maxh;
- int32_t minG = 0;
- while (minG<255 && pG[minG]<=threshold2) minG++;
- int32_t maxG = 255;
- while (maxG>0 && pG[maxG]<=threshold2) maxG--;
-
- maxh = 0;
- for (y=0; y<255; y++) if (maxh < pB[y]) maxh = pB[y];
- threshold2 = threshold*maxh;
- int32_t minB = 0;
- while (minB<255 && pB[minB]<=threshold2) minB++;
- int32_t maxB = 255;
- while (maxB>0 && pB[maxB]<=threshold2) maxB--;
-
- if (minR == 0 && maxR == 255 && minG == 0 && maxG == 255 && minB == 0 && maxB == 255)
- return true;
-
- // calculate LUT
- uint8_t lutR[256];
- uint8_t range = maxR - minR;
- if (range != 0) {
- for (x = 0; x <256; x++){
- lutR[x] = (uint8_t)max(0,min(255,(255 * (x - minR) / range)));
- }
- } else lutR[minR] = minR;
-
- uint8_t lutG[256];
- range = maxG - minG;
- if (range != 0) {
- for (x = 0; x <256; x++){
- lutG[x] = (uint8_t)max(0,min(255,(255 * (x - minG) / range)));
- }
- } else lutG[minG] = minG;
-
- uint8_t lutB[256];
- range = maxB - minB;
- if (range != 0) {
- for (x = 0; x <256; x++){
- lutB[x] = (uint8_t)max(0,min(255,(255 * (x - minB) / range)));
- }
- } else lutB[minB] = minB;
-
- // normalize image
- for (y=0; y<head.biHeight; y++)
- {
- info.nProgress = (int32_t)(50.0+y*dbScaler);
- if (info.nEscape) break;
-
- for (x=0; x<head.biWidth; x++)
- {
- RGBQUAD color = BlindGetPixelColor(x, y);
-
- color.rgbRed = lutR[color.rgbRed];
- color.rgbBlue = lutB[color.rgbBlue];
- color.rgbGreen = lutG[color.rgbGreen];
-
- BlindSetPixelColor(x, y, color);
- }
- }
- }
- break;
- default:
- { // <dave>
- double p[256];
- memset(p, 0, 256*sizeof(double));
- for (y=0; y<head.biHeight; y++)
- {
- info.nProgress = (int32_t)(y*dbScaler);
- if (info.nEscape) break;
- for (x=0; x<head.biWidth; x++) {
- RGBQUAD color = BlindGetPixelColor(x, y);
- p[RGB2GRAY(color.rgbRed, color.rgbGreen, color.rgbBlue)]++;
- }
- }
-
- double maxh = 0;
- for (y=0; y<255; y++) if (maxh < p[y]) maxh = p[y];
- threshold *= maxh;
- int32_t minc = 0;
- while (minc<255 && p[minc]<=threshold) minc++;
- int32_t maxc = 255;
- while (maxc>0 && p[maxc]<=threshold) maxc--;
-
- if (minc == 0 && maxc == 255) return true;
- if (minc >= maxc) return true;
-
- // calculate LUT
- uint8_t lut[256];
- for (x = 0; x <256; x++){
- lut[x] = (uint8_t)max(0,min(255,(255 * (x - minc) / (maxc - minc))));
- }
-
- for(y=0; y<head.biHeight; y++){
- info.nProgress = (int32_t)(50.0+y*dbScaler);
- if (info.nEscape) break;
- for(x=0; x<head.biWidth; x++){
-
- RGBQUAD color = BlindGetPixelColor( x, y );
- RGBQUAD yuvClr = RGBtoYUV(color);
- yuvClr.rgbRed = lut[yuvClr.rgbRed];
- color = YUVtoRGB(yuvClr);
- BlindSetPixelColor( x, y, color );
- }
- }
- }
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-// HistogramEqualize function by <dave> : dave(at)posortho(dot)com
-bool CxImage::HistogramEqualize()
-{
- if (!pDib) return false;
-
- int32_t histogram[256];
- int32_t map[256];
- int32_t equalize_map[256];
- int32_t x, y, i, j;
- RGBQUAD color;
- RGBQUAD yuvClr;
- uint32_t YVal, high, low;
-
- memset( &histogram, 0, sizeof(int32_t) * 256 );
- memset( &map, 0, sizeof(int32_t) * 256 );
- memset( &equalize_map, 0, sizeof(int32_t) * 256 );
-
- // form histogram
- for(y=0; y < head.biHeight; y++){
- info.nProgress = (int32_t)(50*y/head.biHeight);
- if (info.nEscape) break;
- for(x=0; x < head.biWidth; x++){
- color = BlindGetPixelColor( x, y );
- YVal = (uint32_t)RGB2GRAY(color.rgbRed, color.rgbGreen, color.rgbBlue);
- histogram[YVal]++;
- }
- }
-
- // integrate the histogram to get the equalization map.
- j = 0;
- for(i=0; i <= 255; i++){
- j += histogram[i];
- map[i] = j;
- }
-
- // equalize
- low = map[0];
- high = map[255];
- if (low == high) return false;
- for( i = 0; i <= 255; i++ ){
- equalize_map[i] = (uint32_t)((((double)( map[i] - low ) ) * 255) / ( high - low ) );
- }
-
- // stretch the histogram
- if(head.biClrUsed == 0){ // No Palette
- for( y = 0; y < head.biHeight; y++ ){
- info.nProgress = (int32_t)(50+50*y/head.biHeight);
- if (info.nEscape) break;
- for( x = 0; x < head.biWidth; x++ ){
-
- color = BlindGetPixelColor( x, y );
- yuvClr = RGBtoYUV(color);
-
- yuvClr.rgbRed = (uint8_t)equalize_map[yuvClr.rgbRed];
-
- color = YUVtoRGB(yuvClr);
- BlindSetPixelColor( x, y, color );
- }
- }
- } else { // Palette
- for( i = 0; i < (int32_t)head.biClrUsed; i++ ){
-
- color = GetPaletteColor((uint8_t)i);
- yuvClr = RGBtoYUV(color);
-
- yuvClr.rgbRed = (uint8_t)equalize_map[yuvClr.rgbRed];
-
- color = YUVtoRGB(yuvClr);
- SetPaletteColor( (uint8_t)i, color );
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-// HistogramNormalize function by <dave> : dave(at)posortho(dot)com
-bool CxImage::HistogramNormalize()
-{
- if (!pDib) return false;
-
- int32_t histogram[256];
- int32_t threshold_intensity, intense;
- int32_t x, y, i;
- uint32_t normalize_map[256];
- uint32_t high, low, YVal;
-
- RGBQUAD color;
- RGBQUAD yuvClr;
-
- memset( &histogram, 0, sizeof( int32_t ) * 256 );
- memset( &normalize_map, 0, sizeof( uint32_t ) * 256 );
-
- // form histogram
- for(y=0; y < head.biHeight; y++){
- info.nProgress = (int32_t)(50*y/head.biHeight);
- if (info.nEscape) break;
- for(x=0; x < head.biWidth; x++){
- color = BlindGetPixelColor( x, y );
- YVal = (uint32_t)RGB2GRAY(color.rgbRed, color.rgbGreen, color.rgbBlue);
- histogram[YVal]++;
- }
- }
-
- // find histogram boundaries by locating the 1 percent levels
- threshold_intensity = ( head.biWidth * head.biHeight) / 100;
-
- intense = 0;
- for( low = 0; low < 255; low++ ){
- intense += histogram[low];
- if( intense > threshold_intensity ) break;
- }
-
- intense = 0;
- for( high = 255; high != 0; high--){
- intense += histogram[ high ];
- if( intense > threshold_intensity ) break;
- }
-
- if ( low == high ){
- // Unreasonable contrast; use zero threshold to determine boundaries.
- threshold_intensity = 0;
- intense = 0;
- for( low = 0; low < 255; low++){
- intense += histogram[low];
- if( intense > threshold_intensity ) break;
- }
- intense = 0;
- for( high = 255; high != 0; high-- ){
- intense += histogram [high ];
- if( intense > threshold_intensity ) break;
- }
- }
- if( low == high ) return false; // zero span bound
-
- // Stretch the histogram to create the normalized image mapping.
- for(i = 0; i <= 255; i++){
- if ( i < (int32_t) low ){
- normalize_map[i] = 0;
- } else {
- if(i > (int32_t) high)
- normalize_map[i] = 255;
- else
- normalize_map[i] = ( 255 - 1) * ( i - low) / ( high - low );
- }
- }
-
- // Normalize
- if( head.biClrUsed == 0 ){
- for( y = 0; y < head.biHeight; y++ ){
- info.nProgress = (int32_t)(50+50*y/head.biHeight);
- if (info.nEscape) break;
- for( x = 0; x < head.biWidth; x++ ){
-
- color = BlindGetPixelColor( x, y );
- yuvClr = RGBtoYUV( color );
-
- yuvClr.rgbRed = (uint8_t)normalize_map[yuvClr.rgbRed];
-
- color = YUVtoRGB( yuvClr );
- BlindSetPixelColor( x, y, color );
- }
- }
- } else {
- for(i = 0; i < (int32_t)head.biClrUsed; i++){
-
- color = GetPaletteColor( (uint8_t)i );
- yuvClr = RGBtoYUV( color );
-
- yuvClr.rgbRed = (uint8_t)normalize_map[yuvClr.rgbRed];
-
- color = YUVtoRGB( yuvClr );
- SetPaletteColor( (uint8_t)i, color );
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-// HistogramLog function by <dave> : dave(at)posortho(dot)com
-bool CxImage::HistogramLog()
-{
- if (!pDib) return false;
-
- //q(i,j) = 255/log(1 + |high|) * log(1 + |p(i,j)|);
- int32_t x, y, i;
- RGBQUAD color;
- RGBQUAD yuvClr;
-
- uint32_t YVal, high = 1;
-
- // Find Highest Luminance Value in the Image
- if( head.biClrUsed == 0 ){ // No Palette
- for(y=0; y < head.biHeight; y++){
- info.nProgress = (int32_t)(50*y/head.biHeight);
- if (info.nEscape) break;
- for(x=0; x < head.biWidth; x++){
- color = BlindGetPixelColor( x, y );
- YVal = (uint32_t)RGB2GRAY(color.rgbRed, color.rgbGreen, color.rgbBlue);
- if (YVal > high ) high = YVal;
- }
- }
- } else { // Palette
- for(i = 0; i < (int32_t)head.biClrUsed; i++){
- color = GetPaletteColor((uint8_t)i);
- YVal = (uint32_t)RGB2GRAY(color.rgbRed, color.rgbGreen, color.rgbBlue);
- if (YVal > high ) high = YVal;
- }
- }
-
- // Logarithm Operator
- double k = 255.0 / ::log( 1.0 + (double)high );
- if( head.biClrUsed == 0 ){
- for( y = 0; y < head.biHeight; y++ ){
- info.nProgress = (int32_t)(50+50*y/head.biHeight);
- if (info.nEscape) break;
- for( x = 0; x < head.biWidth; x++ ){
-
- color = BlindGetPixelColor( x, y );
- yuvClr = RGBtoYUV( color );
-
- yuvClr.rgbRed = (uint8_t)(k * ::log( 1.0 + (double)yuvClr.rgbRed ) );
-
- color = YUVtoRGB( yuvClr );
- BlindSetPixelColor( x, y, color );
- }
- }
- } else {
- for(i = 0; i < (int32_t)head.biClrUsed; i++){
-
- color = GetPaletteColor( (uint8_t)i );
- yuvClr = RGBtoYUV( color );
-
- yuvClr.rgbRed = (uint8_t)(k * ::log( 1.0 + (double)yuvClr.rgbRed ) );
-
- color = YUVtoRGB( yuvClr );
- SetPaletteColor( (uint8_t)i, color );
- }
- }
-
- return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// HistogramRoot function by <dave> : dave(at)posortho(dot)com
-bool CxImage::HistogramRoot()
-{
- if (!pDib) return false;
- //q(i,j) = sqrt(|p(i,j)|);
-
- int32_t x, y, i;
- RGBQUAD color;
- RGBQUAD yuvClr;
- double dtmp;
- uint32_t YVal, high = 1;
-
- // Find Highest Luminance Value in the Image
- if( head.biClrUsed == 0 ){ // No Palette
- for(y=0; y < head.biHeight; y++){
- info.nProgress = (int32_t)(50*y/head.biHeight);
- if (info.nEscape) break;
- for(x=0; x < head.biWidth; x++){
- color = BlindGetPixelColor( x, y );
- YVal = (uint32_t)RGB2GRAY(color.rgbRed, color.rgbGreen, color.rgbBlue);
- if (YVal > high ) high = YVal;
- }
- }
- } else { // Palette
- for(i = 0; i < (int32_t)head.biClrUsed; i++){
- color = GetPaletteColor((uint8_t)i);
- YVal = (uint32_t)RGB2GRAY(color.rgbRed, color.rgbGreen, color.rgbBlue);
- if (YVal > high ) high = YVal;
- }
- }
-
- // Root Operator
- double k = 256.0 / ::sqrt( 1.0 + (double)high );
- if( head.biClrUsed == 0 ){
- for( y = 0; y < head.biHeight; y++ ){
- info.nProgress = (int32_t)(50+50*y/head.biHeight);
- if (info.nEscape) break;
- for( x = 0; x < head.biWidth; x++ ){
-
- color = BlindGetPixelColor( x, y );
- yuvClr = RGBtoYUV( color );
-
- dtmp = k * ::sqrt( (double)yuvClr.rgbRed );
- if ( dtmp > 255.0 ) dtmp = 255.0;
- if ( dtmp < 0 ) dtmp = 0;
- yuvClr.rgbRed = (uint8_t)dtmp;
-
- color = YUVtoRGB( yuvClr );
- BlindSetPixelColor( x, y, color );
- }
- }
- } else {
- for(i = 0; i < (int32_t)head.biClrUsed; i++){
-
- color = GetPaletteColor( (uint8_t)i );
- yuvClr = RGBtoYUV( color );
-
- dtmp = k * ::sqrt( (double)yuvClr.rgbRed );
- if ( dtmp > 255.0 ) dtmp = 255.0;
- if ( dtmp < 0 ) dtmp = 0;
- yuvClr.rgbRed = (uint8_t)dtmp;
-
- color = YUVtoRGB( yuvClr );
- SetPaletteColor( (uint8_t)i, color );
- }
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif
diff --git a/smelt/sdl/CxImage/ximaico.cpp b/smelt/sdl/CxImage/ximaico.cpp deleted file mode 100644 index a808697..0000000 --- a/smelt/sdl/CxImage/ximaico.cpp +++ /dev/null @@ -1,470 +0,0 @@ -/*
- * File: ximaico.cpp
- * Purpose: Platform Independent ICON Image Class Loader and Writer (MS version)
- * 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximaico.h"
-
-#if CXIMAGE_SUPPORT_ICO
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageICO::Decode(CxFile *hFile)
-{
- if (hFile==NULL) return false;
-
- uint32_t off = hFile->Tell(); //<yuandi>
- int32_t page=info.nFrame; //internal icon structure indexes
-
- // read the first part of the header
- ICONHEADER icon_header;
- hFile->Read(&icon_header,sizeof(ICONHEADER),1);
-
- icon_header.idType = m_ntohs(icon_header.idType);
- icon_header.idCount = m_ntohs(icon_header.idCount);
-
- // check if it's an icon or a cursor
- if ((icon_header.idReserved == 0) && ((icon_header.idType == 1)||(icon_header.idType == 2))) {
-
- info.nNumFrames = icon_header.idCount;
-
- // load the icon descriptions
- ICONDIRENTRY *icon_list = (ICONDIRENTRY *)malloc(icon_header.idCount * sizeof(ICONDIRENTRY));
- int32_t c;
- for (c = 0; c < icon_header.idCount; c++) {
- hFile->Read(icon_list + c, sizeof(ICONDIRENTRY), 1);
-
- icon_list[c].wPlanes = m_ntohs(icon_list[c].wPlanes);
- icon_list[c].wBitCount = m_ntohs(icon_list[c].wBitCount);
- icon_list[c].dwBytesInRes = m_ntohl(icon_list[c].dwBytesInRes);
- icon_list[c].dwImageOffset = m_ntohl(icon_list[c].dwImageOffset);
- }
-
- if ((page>=0)&&(page<icon_header.idCount)){
-
- if (info.nEscape == -1) {
- // Return output dimensions only
- head.biWidth = icon_list[page].bWidth;
- head.biHeight = icon_list[page].bHeight;
-#if CXIMAGE_SUPPORT_PNG
- if (head.biWidth==0 && head.biHeight==0)
- { // Vista icon support
- hFile->Seek(off + icon_list[page].dwImageOffset, SEEK_SET);
- CxImage png;
- png.SetEscape(-1);
- if (png.Decode(hFile,CXIMAGE_FORMAT_PNG)){
- Transfer(png);
- info.nNumFrames = icon_header.idCount;
- }
- }
-#endif //CXIMAGE_SUPPORT_PNG
- free(icon_list);
- info.dwType = CXIMAGE_FORMAT_ICO;
- return true;
- }
-
- // get the bit count for the colors in the icon <CoreyRLucier>
- BITMAPINFOHEADER bih;
- hFile->Seek(off + icon_list[page].dwImageOffset, SEEK_SET);
-
- if (icon_list[page].bWidth==0 && icon_list[page].bHeight==0)
- { // Vista icon support
-#if CXIMAGE_SUPPORT_PNG
- CxImage png;
- if (png.Decode(hFile,CXIMAGE_FORMAT_PNG)){
- Transfer(png);
- info.nNumFrames = icon_header.idCount;
- }
- SetType(CXIMAGE_FORMAT_ICO);
-#endif //CXIMAGE_SUPPORT_PNG
- }
- else
- { // standard icon
- hFile->Read(&bih,sizeof(BITMAPINFOHEADER),1);
-
- bihtoh(&bih);
-
- c = bih.biBitCount;
-
- // allocate memory for one icon
- Create(icon_list[page].bWidth,icon_list[page].bHeight, c, CXIMAGE_FORMAT_ICO); //image creation
-
- // read the palette
- RGBQUAD pal[256];
- if (bih.biClrUsed)
- hFile->Read(pal,bih.biClrUsed*sizeof(RGBQUAD), 1);
- else
- hFile->Read(pal,head.biClrUsed*sizeof(RGBQUAD), 1);
-
- SetPalette(pal,head.biClrUsed); //palette assign
-
- //read the icon
- if (c<=24){
- hFile->Read(info.pImage, head.biSizeImage, 1);
- } else { // 32 bit icon
- uint8_t* buf=(uint8_t*)malloc(4*head.biHeight*head.biWidth);
- uint8_t* src = buf;
- hFile->Read(buf, 4*head.biHeight*head.biWidth, 1);
-#if CXIMAGE_SUPPORT_ALPHA
- if (!AlphaIsValid()) AlphaCreate();
-#endif //CXIMAGE_SUPPORT_ALPHA
- for (int32_t y = 0; y < head.biHeight; y++) {
- uint8_t* dst = GetBits(y);
- for(int32_t x=0;x<head.biWidth;x++){
- *dst++=src[0];
- *dst++=src[1];
- *dst++=src[2];
-#if CXIMAGE_SUPPORT_ALPHA
- AlphaSet(x,y,src[3]);
-#endif //CXIMAGE_SUPPORT_ALPHA
- src+=4;
- }
- }
- free(buf);
- }
- // apply the AND and XOR masks
- int32_t maskwdt = ((head.biWidth+31) / 32) * 4; //line width of AND mask (always 1 Bpp)
- int32_t masksize = head.biHeight * maskwdt; //size of mask
- uint8_t *mask = (uint8_t *)malloc(masksize);
- if (hFile->Read(mask, masksize, 1)){
-
- bool bGoodMask=false;
- for (int32_t im=0;im<masksize;im++){
- if (mask[im]!=255){
- bGoodMask=true;
- break;
- }
- }
-
- if (bGoodMask){
-#if CXIMAGE_SUPPORT_ALPHA
- bool bNeedAlpha = false;
- if (!AlphaIsValid()){
- AlphaCreate();
- } else {
- bNeedAlpha=true; //32bit icon
- }
- int32_t x,y;
- for (y = 0; y < head.biHeight; y++) {
- for (x = 0; x < head.biWidth; x++) {
- if (((mask[y*maskwdt+(x>>3)]>>(7-x%8))&0x01)){
- AlphaSet(x,y,0);
- bNeedAlpha=true;
- }
- }
- }
- if (!bNeedAlpha) AlphaDelete();
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- //check if there is only one transparent color
- RGBQUAD cc,ct;
- int32_t nTransColors=0;
- int32_t nTransIndex=0;
- for (y = 0; y < head.biHeight; y++){
- for (x = 0; x < head.biWidth; x++){
- if (((mask[y*maskwdt+(x>>3)] >> (7-x%8)) & 0x01)){
- cc = GetPixelColor(x,y,false);
- if (nTransColors==0){
- nTransIndex = GetPixelIndex(x,y);
- nTransColors++;
- ct = cc;
- } else {
- if (memcmp(&cc, &ct, sizeof(RGBQUAD)) != 0){
- nTransColors++;
- }
- }
- }
- }
- }
- if (nTransColors==1 && c<=8){
- SetTransColor(ct);
- SetTransIndex(nTransIndex);
-#if CXIMAGE_SUPPORT_ALPHA
- AlphaDelete(); //because we have a unique transparent color in the image
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
-
- // <vho> - Transparency support w/o Alpha support
- if (c <= 8){ // only for icons with less than 256 colors (XP icons need alpha).
-
- // find a color index, which is not used in the image
- // it is almost sure to find one, bcs. nobody uses all possible colors for an icon
-
- uint8_t colorsUsed[256];
- memset(colorsUsed, 0, sizeof(colorsUsed));
-
- for (y = 0; y < head.biHeight; y++){
- for (x = 0; x < head.biWidth; x++){
- colorsUsed[BlindGetPixelIndex(x,y)] = 1;
- }
- }
-
- int32_t iTransIdx = -1;
- for (x = (int32_t)(head.biClrUsed-1); x>=0 ; x--){
- if (colorsUsed[x] == 0){
- iTransIdx = x; // this one is not in use. we may use it as transparent color
- break;
- }
- }
-
- // Go thru image and set unused color as transparent index if needed
- if (iTransIdx >= 0){
- bool bNeedTrans = false;
- for (y = 0; y < head.biHeight; y++){
- for (x = 0; x < head.biWidth; x++){
- // AND mask (Each Byte represents 8 Pixels)
- if (((mask[y*maskwdt+(x>>3)] >> (7-x%8)) & 0x01)){
- // AND mask is set (!=0). This is a transparent part
- SetPixelIndex(x, y, (uint8_t)iTransIdx);
- bNeedTrans = true;
- }
- }
- }
- // set transparent index if needed
- if (bNeedTrans) SetTransIndex(iTransIdx);
-#if CXIMAGE_SUPPORT_ALPHA
- AlphaDelete(); //because we have a transparent color in the palette
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- }
- } else {
- SetTransIndex(0); //empty mask, set black as transparent color
- Negative();
- }
- }
- free(mask);
- }
- free(icon_list);
- // icon has been loaded successfully!
- return true;
- }
- free(icon_list);
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-// Thanks to <Alas>
-bool CxImageICO::Encode(CxFile * hFile, CxImage ** pImages, int32_t nPageCount)
-{
- cx_try
- {
- if (hFile==NULL) cx_throw("invalid file pointer");
- if (pImages==NULL || nPageCount<=0) cx_throw("multipage ICO, no images!");
-
- int32_t i;
- for (i=0; i<nPageCount; i++){
- if (pImages[i]==NULL)
- cx_throw("Bad image pointer");
- if (!(pImages[i]->IsValid()))
- cx_throw("Empty image");
- }
-
- CxImageICO ghost;
- for (i=0; i<nPageCount; i++){ //write headers
- ghost.Ghost(pImages[i]);
- ghost.info.nNumFrames = nPageCount;
- if (i==0) {
- if (!ghost.Encode(hFile,false,nPageCount))
- cx_throw("Error writing ICO file header");
- }
- if (!ghost.Encode(hFile,true,nPageCount))
- cx_throw("Error saving ICO image header");
- }
- for (i=0; i<nPageCount; i++){ //write bodies
- ghost.Ghost(pImages[i]);
- ghost.info.nNumFrames = nPageCount;
- if (!ghost.Encode(hFile,true,i))
- cx_throw("Error saving ICO body");
- }
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- return false;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageICO::Encode(CxFile * hFile, bool bAppend, int32_t nPageCount)
-{
- if (EncodeSafeCheck(hFile)) return false;
-
-#if CXIMAGE_SUPPORT_PNG == 0
- //check format limits
- if ((head.biWidth>255)||(head.biHeight>255)){
- strcpy(info.szLastError,"Can't save this image as icon");
- return false;
- }
-#endif
-
- //prepare the palette struct
- RGBQUAD* pal=GetPalette();
- if (head.biBitCount<=8 && pal==NULL) return false;
-
- int32_t maskwdt=((head.biWidth+31)/32)*4; //mask line width
- int32_t masksize=head.biHeight * maskwdt; //size of mask
- int32_t bitcount=head.biBitCount;
- int32_t imagesize=head.biSizeImage;
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid() && head.biClrUsed==0){
- bitcount=32;
- imagesize=4*head.biHeight*head.biWidth;
- }
-#endif
-
- //fill the icon headers
- int32_t nPages = nPageCount;
- if (nPages<1) nPages = 1;
-
- ICONHEADER icon_header={0,1,nPages};
-
- if (!bAppend)
- m_dwImageOffset = sizeof(ICONHEADER) + nPages * sizeof(ICONDIRENTRY);
-
- uint32_t dwBytesInRes = sizeof(BITMAPINFOHEADER)+head.biClrUsed*sizeof(RGBQUAD)+imagesize+masksize;
-
- ICONDIRENTRY icon_list={
- (uint8_t)head.biWidth,
- (uint8_t)head.biHeight,
- (uint8_t)head.biClrUsed,
- 0, 0,
- (uint16_t)bitcount,
- dwBytesInRes,
- m_dwImageOffset
- };
-
- BITMAPINFOHEADER bi={
- sizeof(BITMAPINFOHEADER),
- head.biWidth,
- 2*head.biHeight,
- 1,
- (uint16_t)bitcount,
- 0, imagesize,
- 0, 0, 0, 0
- };
-
-#if CXIMAGE_SUPPORT_PNG // Vista icon support
- CxImage png(*this);
- CxMemFile memfile;
- if (head.biWidth>255 || head.biHeight>255){
- icon_list.bWidth = icon_list.bHeight = 0;
- memfile.Open();
- png.Encode(&memfile,CXIMAGE_FORMAT_PNG);
- icon_list.dwBytesInRes = dwBytesInRes = memfile.Size();
- }
-#endif //CXIMAGE_SUPPORT_PNG
-
- if (!bAppend){
- icon_header.idType = m_ntohs(icon_header.idType);
- icon_header.idCount = m_ntohs(icon_header.idCount);
- hFile->Write(&icon_header,sizeof(ICONHEADER),1); //write the file header
- icon_header.idType = m_ntohs(icon_header.idType);
- icon_header.idCount = m_ntohs(icon_header.idCount);
- }
-
-
- if ((bAppend && nPageCount==info.nNumFrames) || (!bAppend && nPageCount==0)){
- icon_list.wPlanes = m_ntohs(icon_list.wPlanes);
- icon_list.wBitCount = m_ntohs(icon_list.wBitCount);
- icon_list.dwBytesInRes = m_ntohl(icon_list.dwBytesInRes);
- icon_list.dwImageOffset = m_ntohl(icon_list.dwImageOffset);
- hFile->Write(&icon_list,sizeof(ICONDIRENTRY),1); //write the image entry
- icon_list.wPlanes = m_ntohs(icon_list.wPlanes);
- icon_list.wBitCount = m_ntohs(icon_list.wBitCount);
- icon_list.dwBytesInRes = m_ntohl(icon_list.dwBytesInRes);
- icon_list.dwImageOffset = m_ntohl(icon_list.dwImageOffset);
-
- m_dwImageOffset += dwBytesInRes; //update offset for next header
- }
-
- if ((bAppend && nPageCount<info.nNumFrames) || (!bAppend && nPageCount==0))
- {
-#if CXIMAGE_SUPPORT_PNG
- if (icon_list.bWidth==0 && icon_list.bHeight==0) { // Vista icon support
- hFile->Write(memfile.GetBuffer(false),dwBytesInRes,1);
- } else
-#endif //CXIMAGE_SUPPORT_PNG
- { // standard icon
- bihtoh(&bi);
- hFile->Write(&bi,sizeof(BITMAPINFOHEADER),1); //write the image header
- bihtoh(&bi);
-
- bool bTransparent = info.nBkgndIndex >= 0;
- RGBQUAD ct = GetTransColor();
- if (pal){
- if (bTransparent) SetPaletteColor((uint8_t)info.nBkgndIndex,0,0,0,0);
- hFile->Write(pal,head.biClrUsed*sizeof(RGBQUAD),1); //write palette
- if (bTransparent) SetPaletteColor((uint8_t)info.nBkgndIndex,ct);
- }
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid() && head.biClrUsed==0){
- uint8_t* buf=(uint8_t*)malloc(imagesize);
- uint8_t* dst = buf;
- for (int32_t y = 0; y < head.biHeight; y++) {
- uint8_t* src = GetBits(y);
- for(int32_t x=0;x<head.biWidth;x++){
- *dst++=*src++;
- *dst++=*src++;
- *dst++=*src++;
- *dst++=AlphaGet(x,y);
- }
- }
- hFile->Write(buf,imagesize, 1);
- free(buf);
- } else {
- hFile->Write(info.pImage,imagesize,1); //write image
- }
-#else
- hFile->Write(info.pImage,imagesize,1); //write image
-#endif
-
- //save transparency mask
- uint8_t* mask=(uint8_t*)calloc(masksize,1); //create empty AND/XOR masks
- if (!mask) return false;
-
- //prepare the variables to build the mask
- uint8_t* iDst;
- int32_t pos,i;
- RGBQUAD c={0,0,0,0};
- int32_t* pc = (int32_t*)&c;
- int32_t* pct= (int32_t*)&ct;
-#if CXIMAGE_SUPPORT_ALPHA
- bool bAlphaPaletteIsValid = AlphaPaletteIsValid();
- bool bAlphaIsValid = AlphaIsValid();
-#endif
- //build the mask
- for (int32_t y = 0; y < head.biHeight; y++) {
- for (int32_t x = 0; x < head.biWidth; x++) {
- i=0;
-#if CXIMAGE_SUPPORT_ALPHA
- if (bAlphaIsValid && AlphaGet(x,y)==0) i=1;
- if (bAlphaPaletteIsValid && BlindGetPixelColor(x,y).rgbReserved==0) i=1;
-#endif
- c=GetPixelColor(x,y,false);
- if (bTransparent && *pc==*pct) i=1;
- iDst = mask + y*maskwdt + (x>>3);
- pos = 7-x%8;
- *iDst &= ~(0x01<<pos);
- *iDst |= ((i & 0x01)<<pos);
- }
- }
- //write AND/XOR masks
- hFile->Write(mask,masksize,1);
- free(mask);
- }
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ICO
-
diff --git a/smelt/sdl/CxImage/ximaico.h b/smelt/sdl/CxImage/ximaico.h deleted file mode 100644 index 8d81b02..0000000 --- a/smelt/sdl/CxImage/ximaico.h +++ /dev/null @@ -1,58 +0,0 @@ -/*
- * File: ximaico.h
- * Purpose: ICON Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImageICO (c) 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- * ==========================================================
- */
-#if !defined(__ximaICO_h)
-#define __ximaICO_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_ICO
-
-class CxImageICO: public CxImage
-{
-typedef struct tagIconDirectoryEntry {
- uint8_t bWidth;
- uint8_t bHeight;
- uint8_t bColorCount;
- uint8_t bReserved;
- uint16_t wPlanes;
- uint16_t wBitCount;
- uint32_t dwBytesInRes;
- uint32_t dwImageOffset;
-} ICONDIRENTRY;
-
-typedef struct tagIconDir {
- uint16_t idReserved;
- uint16_t idType;
- uint16_t idCount;
-} ICONHEADER;
-
-public:
- CxImageICO(): CxImage(CXIMAGE_FORMAT_ICO) {m_dwImageOffset=0;}
-
-// bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_ICO);}
-// bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_ICO);}
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile, bool bAppend=false, int32_t nPageCount=0);
- bool Encode(CxFile * hFile, CxImage ** pImages, int32_t nPageCount);
- bool Encode(FILE *hFile, bool bAppend=false, int32_t nPageCount=0)
- { CxIOFile file(hFile); return Encode(&file,bAppend,nPageCount); }
- bool Encode(FILE *hFile, CxImage ** pImages, int32_t nPageCount)
- { CxIOFile file(hFile); return Encode(&file, pImages, nPageCount); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-protected:
- uint32_t m_dwImageOffset;
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximainfo.cpp b/smelt/sdl/CxImage/ximainfo.cpp deleted file mode 100644 index 582d9ed..0000000 --- a/smelt/sdl/CxImage/ximainfo.cpp +++ /dev/null @@ -1,958 +0,0 @@ -// ximainfo.cpp : main attributes
-/* 03/10/2004 v1.00 - Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximage.h"
-
-#if defined(_LINUX) || defined(__APPLE__)
- #define _tcsnicmp(a,b,c) strcasecmp(a,b)
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return the color used for transparency, and/or for background color
- */
-RGBQUAD CxImage::GetTransColor()
-{
- if (head.biBitCount<24 && info.nBkgndIndex>=0) return GetPaletteColor((uint8_t)info.nBkgndIndex);
- return info.nBkgndColor;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the index used for transparency. Returns -1 for no transparancy.
- */
-int32_t CxImage::GetTransIndex() const
-{
- return info.nBkgndIndex;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets the index used for transparency with 1, 4 and 8 bpp images. Set to -1 to remove the effect.
- */
-void CxImage::SetTransIndex(int32_t idx)
-{
- if (idx<(int32_t)head.biClrUsed)
- info.nBkgndIndex = idx;
- else
- info.nBkgndIndex = 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets the color used for transparency with 24 bpp images.
- * You must call SetTransIndex(0) to enable the effect, SetTransIndex(-1) to disable it.
- */
-void CxImage::SetTransColor(RGBQUAD rgb)
-{
- rgb.rgbReserved=0;
- info.nBkgndColor = rgb;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::IsTransparent() const
-{
- return info.nBkgndIndex>=0; // <vho>
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns true if the image has 256 colors or less.
- */
-bool CxImage::IsIndexed() const
-{
- return head.biClrUsed!=0;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return 1 = indexed, 2 = RGB, 4 = RGBA
- */
-uint8_t CxImage::GetColorType()
-{
- uint8_t b = (uint8_t)((head.biBitCount>8) ? 2 /*COLORTYPE_COLOR*/ : 1 /*COLORTYPE_PALETTE*/);
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) b = 4 /*COLORTYPE_ALPHA*/;
-#endif //CXIMAGE_SUPPORT_ALPHA
- return b;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return Resolution for TIFF, JPEG, PNG and BMP formats.
- */
-int32_t CxImage::GetXDPI() const
-{
- return info.xDPI;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return Resolution for TIFF, JPEG, PNG and BMP formats.
- */
-int32_t CxImage::GetYDPI() const
-{
- return info.yDPI;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Set resolution for TIFF, JPEG, PNG and BMP formats.
- */
-void CxImage::SetXDPI(int32_t dpi)
-{
- if (dpi<=0) dpi = CXIMAGE_DEFAULT_DPI;
- info.xDPI = dpi;
- head.biXPelsPerMeter = (int32_t) floor(dpi * 10000.0 / 254.0 + 0.5);
- if (pDib) ((BITMAPINFOHEADER*)pDib)->biXPelsPerMeter = head.biXPelsPerMeter;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Set resolution for TIFF, JPEG, PNG and BMP formats.
- */
-void CxImage::SetYDPI(int32_t dpi)
-{
- if (dpi<=0) dpi = CXIMAGE_DEFAULT_DPI;
- info.yDPI = dpi;
- head.biYPelsPerMeter = (int32_t) floor(dpi * 10000.0 / 254.0 + 0.5);
- if (pDib) ((BITMAPINFOHEADER*)pDib)->biYPelsPerMeter = head.biYPelsPerMeter;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \sa SetFlags
- */
-uint32_t CxImage::GetFlags() const
-{
- return info.dwFlags;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Image flags, for future use
- * \param flags
- * - 0x??00000 = reserved for 16 bit, CMYK, multilayer
- * - 0x00??0000 = blend modes
- * - 0x0000???? = layer id or user flags
- *
- * \param bLockReservedFlags protects the "reserved" and "blend modes" flags
- */
-void CxImage::SetFlags(uint32_t flags, bool bLockReservedFlags)
-{
- if (bLockReservedFlags) info.dwFlags = flags & 0x0000ffff;
- else info.dwFlags = flags;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \sa SetCodecOption
- */
-uint32_t CxImage::GetCodecOption(uint32_t imagetype)
-{
- imagetype = GetTypeIndexFromId(imagetype);
- if (imagetype==0){
- imagetype = GetTypeIndexFromId(GetType());
- }
- return info.dwCodecOpt[imagetype];
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Encode option for GIF, TIF, JPG, PNG and RAW
- * - GIF : 0 = LZW (default), 1 = none, 2 = RLE.
- * - TIF : 0 = automatic (default), or a valid compression code as defined in "tiff.h" (COMPRESSION_NONE = 1, COMPRESSION_CCITTRLE = 2, ...)
- * - JPG : valid values stored in enum CODEC_OPTION ( ENCODE_BASELINE = 0x01, ENCODE_PROGRESSIVE = 0x10, ...)
- * - PNG : combination of interlace option and compression option
- * interlace option : 1 = interlace, 0 = no interlace
- * compression option : 2 = no compression, 4 = best speed, 6 = best compression, 8 = default compression
- * default is no interlace and default compression
- * example : 5 = 1+4 = interlace + best speed
- * - RAW : valid values stored in enum CODEC_OPTION ( DECODE_QUALITY_LIN = 0x00, DECODE_QUALITY_VNG = 0x01, ...)
- *
- * \return true if everything is ok
- */
-bool CxImage::SetCodecOption(uint32_t opt, uint32_t imagetype)
-{
- imagetype = GetTypeIndexFromId(imagetype);
- if (imagetype==0){
- imagetype = GetTypeIndexFromId(GetType());
- }
- info.dwCodecOpt[imagetype] = opt;
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return internal hDib object..
- */
-void* CxImage::GetDIB() const
-{
- return pDib;
-}
-////////////////////////////////////////////////////////////////////////////////
-uint32_t CxImage::GetHeight() const
-{
- return head.biHeight;
-}
-////////////////////////////////////////////////////////////////////////////////
-uint32_t CxImage::GetWidth() const
-{
- return head.biWidth;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return uint32_t aligned width of the image.
- */
-uint32_t CxImage::GetEffWidth() const
-{
- return info.dwEffWidth;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return 2, 16, 256; 0 for RGB images.
- */
-uint32_t CxImage::GetNumColors() const
-{
- return head.biClrUsed;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return: 1, 4, 8, 24.
- */
-uint16_t CxImage::GetBpp() const
-{
- return head.biBitCount;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return original image format
- * \sa ENUM_CXIMAGE_FORMATS.
- */
-uint32_t CxImage::GetType() const
-{
- return info.dwType;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * change image format identifier
- * \sa ENUM_CXIMAGE_FORMATS.
- */
-bool CxImage::SetType(uint32_t type)
-{
- switch (type){
-#if CXIMAGE_SUPPORT_BMP
- case CXIMAGE_FORMAT_BMP:
-#endif
-#if CXIMAGE_SUPPORT_GIF
- case CXIMAGE_FORMAT_GIF:
-#endif
-#if CXIMAGE_SUPPORT_JPG
- case CXIMAGE_FORMAT_JPG:
-#endif
-#if CXIMAGE_SUPPORT_PNG
- case CXIMAGE_FORMAT_PNG:
-#endif
-#if CXIMAGE_SUPPORT_MNG
- case CXIMAGE_FORMAT_MNG:
-#endif
-#if CXIMAGE_SUPPORT_ICO
- case CXIMAGE_FORMAT_ICO:
-#endif
-#if CXIMAGE_SUPPORT_TIF
- case CXIMAGE_FORMAT_TIF:
-#endif
-#if CXIMAGE_SUPPORT_TGA
- case CXIMAGE_FORMAT_TGA:
-#endif
-#if CXIMAGE_SUPPORT_PCX
- case CXIMAGE_FORMAT_PCX:
-#endif
-#if CXIMAGE_SUPPORT_WBMP
- case CXIMAGE_FORMAT_WBMP:
-#endif
-#if CXIMAGE_SUPPORT_WMF
- case CXIMAGE_FORMAT_WMF:
-#endif
-#if CXIMAGE_SUPPORT_JBG
- case CXIMAGE_FORMAT_JBG:
-#endif
-#if CXIMAGE_SUPPORT_JP2
- case CXIMAGE_FORMAT_JP2:
-#endif
-#if CXIMAGE_SUPPORT_JPC
- case CXIMAGE_FORMAT_JPC:
-#endif
-#if CXIMAGE_SUPPORT_PGX
- case CXIMAGE_FORMAT_PGX:
-#endif
-#if CXIMAGE_SUPPORT_PNM
- case CXIMAGE_FORMAT_PNM:
-#endif
-#if CXIMAGE_SUPPORT_RAS
- case CXIMAGE_FORMAT_RAS:
-#endif
-#if CXIMAGE_SUPPORT_SKA
- case CXIMAGE_FORMAT_SKA:
-#endif
-#if CXIMAGE_SUPPORT_RAW
- case CXIMAGE_FORMAT_RAW:
-#endif
-#if CXIMAGE_SUPPORT_PSD
- case CXIMAGE_FORMAT_PSD:
-#endif
- info.dwType = type;
- return true;
- case CXIMAGE_FORMAT_UNKNOWN:
- default:
- info.dwType = CXIMAGE_FORMAT_UNKNOWN;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-uint32_t CxImage::GetNumTypes()
-{
- return CMAX_IMAGE_FORMATS-1;
-}
-////////////////////////////////////////////////////////////////////////////////
-uint32_t CxImage::GetTypeIdFromName(const TCHAR* ext)
-{
-#if CXIMAGE_SUPPORT_BMP
- if (_tcsnicmp(ext,_T("bmp"),3)==0 ) return CXIMAGE_FORMAT_BMP;
-#endif
-#if CXIMAGE_SUPPORT_JPG
- if (_tcsnicmp(ext,_T("jpg"),3)==0 ||
- _tcsnicmp(ext,_T("jpe"),3)==0 ||
- _tcsnicmp(ext,_T("jfi"),3)==0 ) return CXIMAGE_FORMAT_JPG;
-#endif
-#if CXIMAGE_SUPPORT_GIF
- if (_tcsnicmp(ext,_T("gif"),3)==0 ) return CXIMAGE_FORMAT_GIF;
-#endif
-#if CXIMAGE_SUPPORT_PNG
- if (_tcsnicmp(ext,_T("png"),3)==0 ) return CXIMAGE_FORMAT_PNG;
-#endif
-#if CXIMAGE_SUPPORT_ICO
- if (_tcsnicmp(ext,_T("ico"),3)==0 ||
- _tcsnicmp(ext,_T("cur"),3)==0 ) return CXIMAGE_FORMAT_ICO;
-#endif
-#if CXIMAGE_SUPPORT_TIF
- if (_tcsnicmp(ext,_T("tif"),3)==0 ) return CXIMAGE_FORMAT_TIF;
-#endif
-#if CXIMAGE_SUPPORT_TGA
- if (_tcsnicmp(ext,_T("tga"),3)==0 ) return CXIMAGE_FORMAT_TGA;
-#endif
-#if CXIMAGE_SUPPORT_PCX
- if (_tcsnicmp(ext,_T("pcx"),3)==0 ) return CXIMAGE_FORMAT_PCX;
-#endif
-#if CXIMAGE_SUPPORT_WBMP
- if (_tcsnicmp(ext,_T("wbm"),3)==0 ) return CXIMAGE_FORMAT_WBMP;
-#endif
-#if CXIMAGE_SUPPORT_WMF
- if (_tcsnicmp(ext,_T("wmf"),3)==0 ||
- _tcsnicmp(ext,_T("emf"),3)==0 ) return CXIMAGE_FORMAT_WMF;
-#endif
-#if CXIMAGE_SUPPORT_JP2
- if (_tcsnicmp(ext,_T("jp2"),3)==0 ||
- _tcsnicmp(ext,_T("j2k"),3)==0 ) return CXIMAGE_FORMAT_JP2;
-#endif
-#if CXIMAGE_SUPPORT_JPC
- if (_tcsnicmp(ext,_T("jpc"),3)==0 ||
- _tcsnicmp(ext,_T("j2c"),3)==0 ) return CXIMAGE_FORMAT_JPC;
-#endif
-#if CXIMAGE_SUPPORT_PGX
- if (_tcsnicmp(ext,_T("pgx"),3)==0 ) return CXIMAGE_FORMAT_PGX;
-#endif
-#if CXIMAGE_SUPPORT_RAS
- if (_tcsnicmp(ext,_T("ras"),3)==0 ) return CXIMAGE_FORMAT_RAS;
-#endif
-#if CXIMAGE_SUPPORT_PNM
- if (_tcsnicmp(ext,_T("pnm"),3)==0 ||
- _tcsnicmp(ext,_T("pgm"),3)==0 ||
- _tcsnicmp(ext,_T("ppm"),3)==0 ) return CXIMAGE_FORMAT_PNM;
-#endif
-#if CXIMAGE_SUPPORT_JBG
- if (_tcsnicmp(ext,_T("jbg"),3)==0 ) return CXIMAGE_FORMAT_JBG;
-#endif
-#if CXIMAGE_SUPPORT_MNG
- if (_tcsnicmp(ext,_T("mng"),3)==0 ||
- _tcsnicmp(ext,_T("jng"),3)==0 ) return CXIMAGE_FORMAT_MNG;
-#endif
-#if CXIMAGE_SUPPORT_SKA
- if (_tcsnicmp(ext,_T("ska"),3)==0 ) return CXIMAGE_FORMAT_SKA;
-#endif
-#if CXIMAGE_SUPPORT_PSD
- if (_tcsnicmp(ext,_T("psd"),3)==0 ) return CXIMAGE_FORMAT_PSD;
-#endif
-#if CXIMAGE_SUPPORT_RAW
- if (_tcsnicmp(ext,_T("nef"),3)==0 ||
- _tcsnicmp(ext,_T("crw"),3)==0 ||
- _tcsnicmp(ext,_T("cr2"),3)==0 ||
- _tcsnicmp(ext,_T("dng"),3)==0 ||
- _tcsnicmp(ext,_T("arw"),3)==0 ||
- _tcsnicmp(ext,_T("erf"),3)==0 ||
- _tcsnicmp(ext,_T("3fr"),3)==0 ||
- _tcsnicmp(ext,_T("dcr"),3)==0 ||
- _tcsnicmp(ext,_T("raw"),3)==0 ||
- _tcsnicmp(ext,_T("x3f"),3)==0 ||
- _tcsnicmp(ext,_T("mef"),3)==0 ||
- _tcsnicmp(ext,_T("raf"),3)==0 ||
- _tcsnicmp(ext,_T("mrw"),3)==0 ||
- _tcsnicmp(ext,_T("pef"),3)==0 ||
- _tcsnicmp(ext,_T("sr2"),3)==0 ||
- _tcsnicmp(ext,_T("orf"),3)==0 ) return CXIMAGE_FORMAT_RAW;
-#endif
-
- return CXIMAGE_FORMAT_UNKNOWN;
-}
-////////////////////////////////////////////////////////////////////////////////
-uint32_t CxImage::GetTypeIdFromIndex(const uint32_t index)
-{
- uint32_t n;
-
- n=0; if (index == n) return CXIMAGE_FORMAT_UNKNOWN;
-#if CXIMAGE_SUPPORT_BMP
- n++; if (index == n) return CXIMAGE_FORMAT_BMP;
-#endif
-#if CXIMAGE_SUPPORT_GIF
- n++; if (index == n) return CXIMAGE_FORMAT_GIF;
-#endif
-#if CXIMAGE_SUPPORT_JPG
- n++; if (index == n) return CXIMAGE_FORMAT_JPG;
-#endif
-#if CXIMAGE_SUPPORT_PNG
- n++; if (index == n) return CXIMAGE_FORMAT_PNG;
-#endif
-#if CXIMAGE_SUPPORT_ICO
- n++; if (index == n) return CXIMAGE_FORMAT_ICO;
-#endif
-#if CXIMAGE_SUPPORT_TIF
- n++; if (index == n) return CXIMAGE_FORMAT_TIF;
-#endif
-#if CXIMAGE_SUPPORT_TGA
- n++; if (index == n) return CXIMAGE_FORMAT_TGA;
-#endif
-#if CXIMAGE_SUPPORT_PCX
- n++; if (index == n) return CXIMAGE_FORMAT_PCX;
-#endif
-#if CXIMAGE_SUPPORT_WBMP
- n++; if (index == n) return CXIMAGE_FORMAT_WBMP;
-#endif
-#if CXIMAGE_SUPPORT_WMF
- n++; if (index == n) return CXIMAGE_FORMAT_WMF;
-#endif
-#if CXIMAGE_SUPPORT_JP2
- n++; if (index == n) return CXIMAGE_FORMAT_JP2;
-#endif
-#if CXIMAGE_SUPPORT_JPC
- n++; if (index == n) return CXIMAGE_FORMAT_JPC;
-#endif
-#if CXIMAGE_SUPPORT_PGX
- n++; if (index == n) return CXIMAGE_FORMAT_PGX;
-#endif
-#if CXIMAGE_SUPPORT_PNM
- n++; if (index == n) return CXIMAGE_FORMAT_PNM;
-#endif
-#if CXIMAGE_SUPPORT_RAS
- n++; if (index == n) return CXIMAGE_FORMAT_RAS;
-#endif
-#if CXIMAGE_SUPPORT_JBG
- n++; if (index == n) return CXIMAGE_FORMAT_JBG;
-#endif
-#if CXIMAGE_SUPPORT_MNG
- n++; if (index == n) return CXIMAGE_FORMAT_MNG;
-#endif
-#if CXIMAGE_SUPPORT_SKA
- n++; if (index == n) return CXIMAGE_FORMAT_SKA;
-#endif
-#if CXIMAGE_SUPPORT_RAW
- n++; if (index == n) return CXIMAGE_FORMAT_RAW;
-#endif
-#if CXIMAGE_SUPPORT_PSD
- n++; if (index == n) return CXIMAGE_FORMAT_PSD;
-#endif
-
- return CXIMAGE_FORMAT_UNKNOWN;
-}
-////////////////////////////////////////////////////////////////////////////////
-uint32_t CxImage::GetTypeIndexFromId(const uint32_t id)
-{
- uint32_t n;
-
- n=0; if (id == CXIMAGE_FORMAT_UNKNOWN) return n;
-#if CXIMAGE_SUPPORT_BMP
- n++; if (id == CXIMAGE_FORMAT_BMP) return n;
-#endif
-#if CXIMAGE_SUPPORT_GIF
- n++; if (id == CXIMAGE_FORMAT_GIF) return n;
-#endif
-#if CXIMAGE_SUPPORT_JPG
- n++; if (id == CXIMAGE_FORMAT_JPG) return n;
-#endif
-#if CXIMAGE_SUPPORT_PNG
- n++; if (id == CXIMAGE_FORMAT_PNG) return n;
-#endif
-#if CXIMAGE_SUPPORT_ICO
- n++; if (id == CXIMAGE_FORMAT_ICO) return n;
-#endif
-#if CXIMAGE_SUPPORT_TIF
- n++; if (id == CXIMAGE_FORMAT_TIF) return n;
-#endif
-#if CXIMAGE_SUPPORT_TGA
- n++; if (id == CXIMAGE_FORMAT_TGA) return n;
-#endif
-#if CXIMAGE_SUPPORT_PCX
- n++; if (id == CXIMAGE_FORMAT_PCX) return n;
-#endif
-#if CXIMAGE_SUPPORT_WBMP
- n++; if (id == CXIMAGE_FORMAT_WBMP) return n;
-#endif
-#if CXIMAGE_SUPPORT_WMF
- n++; if (id == CXIMAGE_FORMAT_WMF) return n;
-#endif
-#if CXIMAGE_SUPPORT_JP2
- n++; if (id == CXIMAGE_FORMAT_JP2) return n;
-#endif
-#if CXIMAGE_SUPPORT_JPC
- n++; if (id == CXIMAGE_FORMAT_JPC) return n;
-#endif
-#if CXIMAGE_SUPPORT_PGX
- n++; if (id == CXIMAGE_FORMAT_PGX) return n;
-#endif
-#if CXIMAGE_SUPPORT_PNM
- n++; if (id == CXIMAGE_FORMAT_PNM) return n;
-#endif
-#if CXIMAGE_SUPPORT_RAS
- n++; if (id == CXIMAGE_FORMAT_RAS) return n;
-#endif
-#if CXIMAGE_SUPPORT_JBG
- n++; if (id == CXIMAGE_FORMAT_JBG) return n;
-#endif
-#if CXIMAGE_SUPPORT_MNG
- n++; if (id == CXIMAGE_FORMAT_MNG) return n;
-#endif
-#if CXIMAGE_SUPPORT_SKA
- n++; if (id == CXIMAGE_FORMAT_SKA) return n;
-#endif
-#if CXIMAGE_SUPPORT_RAW
- n++; if (id == CXIMAGE_FORMAT_RAW) return n;
-#endif
-#if CXIMAGE_SUPPORT_PSD
- n++; if (id == CXIMAGE_FORMAT_PSD) return n;
-#endif
-
- return 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return current frame delay in milliseconds. Only for GIF and MNG formats.
- */
-uint32_t CxImage::GetFrameDelay() const
-{
- return info.dwFrameDelay;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets current frame delay. Only for GIF format.
- * \param d = delay in milliseconds
- */
-void CxImage::SetFrameDelay(uint32_t d)
-{
- info.dwFrameDelay=d;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::GetOffset(int32_t *x,int32_t *y)
-{
- *x=info.xOffset;
- *y=info.yOffset;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::SetOffset(int32_t x,int32_t y)
-{
- info.xOffset=x;
- info.yOffset=y;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \sa SetJpegQuality, GetJpegQualityF
- * \author [DP]; changes [Stefan Schürmans]
- */
-uint8_t CxImage::GetJpegQuality() const
-{
- return (uint8_t)(info.fQuality + 0.5f);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \sa SetJpegQuality, GetJpegQuality
- * \author [Stefan Schürmans]
- */
-float CxImage::GetJpegQualityF() const
-{
- return info.fQuality;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * quality level for JPEG and JPEG2000
- * \param q: can be from 0 to 100
- * \author [DP]; changes [Stefan Schürmans]
- */
-void CxImage::SetJpegQuality(uint8_t q){
- info.fQuality = (float)q;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * quality level for JPEG and JPEG2000
- * necessary for JPEG2000 when quality is between 0.0 and 1.0
- * \param q: can be from 0.0 to 100.0
- * \author [Stefan Schürmans]
- */
-void CxImage::SetJpegQualityF(float q){
- if (q>0) info.fQuality = q;
- else info.fQuality = 0.0f;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \sa SetJpegScale
- */
-uint8_t CxImage::GetJpegScale() const
-{
- return info.nJpegScale;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * scaling down during JPEG decoding valid numbers are 1, 2, 4, 8
- * \author [ignacio]
- */
-void CxImage::SetJpegScale(uint8_t q){
- info.nJpegScale = q;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Used to monitor the slow loops.
- * \return value is from 0 to 100.
- * \sa SetProgress
- */
-int32_t CxImage::GetProgress() const
-{
- return info.nProgress;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return the escape code.
- * \sa SetEscape
- */
-int32_t CxImage::GetEscape() const
-{
- return info.nEscape;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Forces the value of the internal progress variable.
- * \param p should be from 0 to 100.
- * \sa GetProgress
- */
-void CxImage::SetProgress(int32_t p)
-{
- info.nProgress = p;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Used to quit the slow loops or the codecs.
- * - SetEscape(-1) before Decode forces the function to exit, right after
- * the image width and height are available ( for bmp, jpg, gif, tif )
- */
-void CxImage::SetEscape(int32_t i)
-{
- info.nEscape = i;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks if the image is correctly initializated.
- */
-bool CxImage::IsValid() const
-{
- return pDib!=0;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * True if the image is enabled for painting.
- */
-bool CxImage::IsEnabled() const
-{
- return info.bEnabled;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Enables/disables the image.
- */
-void CxImage::Enable(bool enable)
-{
- info.bEnabled=enable;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * This function must be used after a Decode() / Load() call.
- * Use the sequence SetFrame(-1); Load(...); GetNumFrames();
- * to get the number of images without loading the first image.
- * \return the number of images in the file.
- */
-int32_t CxImage::GetNumFrames() const
-{
- return info.nNumFrames;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return the current selected image (zero-based index).
- */
-int32_t CxImage::GetFrame() const
-{
- return info.nFrame;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets the image number that the next Decode() / Load() call will load
- */
-void CxImage::SetFrame(int32_t nFrame){
- info.nFrame=nFrame;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets the method for drawing the frame related to others
- * \sa GetDisposalMethod
- */
-void CxImage::SetDisposalMethod(uint8_t dm)
-{ info.dispmeth=dm; }
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the method for drawing the frame related to others
- * Values : 0 - No disposal specified. The decoder is
- * not required to take any action.
- * 1 - Do not dispose. The graphic is to be left
- * in place.
- * 2 - Restore to background color. The area used by the
- * graphic must be restored to the background color.
- * 3 - Restore to previous. The decoder is required to
- * restore the area overwritten by the graphic with
- * what was there prior to rendering the graphic.
- * 4-7 - To be defined.
- */
-uint8_t CxImage::GetDisposalMethod() const
-{ return info.dispmeth; }
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::GetRetreiveAllFrames() const
-{ return info.bGetAllFrames; }
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::SetRetreiveAllFrames(bool flag)
-{ info.bGetAllFrames = flag; }
-////////////////////////////////////////////////////////////////////////////////
-CxImage * CxImage::GetFrame(int32_t nFrame) const
-{
- if ( ppFrames == NULL) return NULL;
- if ( info.nNumFrames == 0) return NULL;
- if ( nFrame >= info.nNumFrames ) return NULL;
- if ( nFrame < 0) nFrame = info.nNumFrames - 1;
- return ppFrames[nFrame];
-}
-////////////////////////////////////////////////////////////////////////////////
-int16_t CxImage::m_ntohs(const int16_t word)
-{
- if (info.bLittleEndianHost) return word;
- return ( (word & 0xff) << 8 ) | ( (word >> 8) & 0xff );
-}
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImage::m_ntohl(const int32_t dword)
-{
- if (info.bLittleEndianHost) return dword;
- return ((dword & 0xff) << 24 ) | ((dword & 0xff00) << 8 ) |
- ((dword >> 8) & 0xff00) | ((dword >> 24) & 0xff);
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::bihtoh(BITMAPINFOHEADER* bih)
-{
- bih->biSize = m_ntohl(bih->biSize);
- bih->biWidth = m_ntohl(bih->biWidth);
- bih->biHeight = m_ntohl(bih->biHeight);
- bih->biPlanes = m_ntohs(bih->biPlanes);
- bih->biBitCount = m_ntohs(bih->biBitCount);
- bih->biCompression = m_ntohl(bih->biCompression);
- bih->biSizeImage = m_ntohl(bih->biSizeImage);
- bih->biXPelsPerMeter = m_ntohl(bih->biXPelsPerMeter);
- bih->biYPelsPerMeter = m_ntohl(bih->biYPelsPerMeter);
- bih->biClrUsed = m_ntohl(bih->biClrUsed);
- bih->biClrImportant = m_ntohl(bih->biClrImportant);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns the last reported error.
- */
-const char* CxImage::GetLastError()
-{
- return info.szLastError;
-}
-////////////////////////////////////////////////////////////////////////////////
-uint32_t CxImage::DumpSize()
-{
- uint32_t n;
- n = sizeof(BITMAPINFOHEADER) + sizeof(CXIMAGEINFO) + GetSize();
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (pAlpha){
- n += 1 + head.biWidth * head.biHeight;
- } else n++;
-#endif
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (pSelection){
- n += 1 + head.biWidth * head.biHeight;
- } else n++;
-#endif
-
-#if CXIMAGE_SUPPORT_LAYERS
- if (ppLayers){
- for (int32_t m=0; m<GetNumLayers(); m++){
- if (GetLayer(m)){
- n += 1 + GetLayer(m)->DumpSize();
- }
- }
- } else n++;
-#endif
-
- if (ppFrames){
- for (int32_t m=0; m<GetNumFrames(); m++){
- if (GetFrame(m)){
- n += 1 + GetFrame(m)->DumpSize();
- }
- }
- } else n++;
-
- return n;
-}
-////////////////////////////////////////////////////////////////////////////////
-uint32_t CxImage::Dump(uint8_t * dst)
-{
- if (!dst) return 0;
-
- memcpy(dst,&head,sizeof(BITMAPINFOHEADER));
- dst += sizeof(BITMAPINFOHEADER);
-
- memcpy(dst,&info,sizeof(CXIMAGEINFO));
- dst += sizeof(CXIMAGEINFO);
-
- memcpy(dst,pDib,GetSize());
- dst += GetSize();
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (pAlpha){
- memset(dst++, 1, 1);
- memcpy(dst,pAlpha,head.biWidth * head.biHeight);
- dst += head.biWidth * head.biHeight;
- } else {
- memset(dst++, 0, 1);
- }
-#endif
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (pSelection){
- memset(dst++, 1, 1);
- memcpy(dst,pSelection,head.biWidth * head.biHeight);
- dst += head.biWidth * head.biHeight;
- } else {
- memset(dst++, 0, 1);
- }
-#endif
-
-#if CXIMAGE_SUPPORT_LAYERS
- if (ppLayers){
- memset(dst++, 1, 1);
- for (int32_t m=0; m<GetNumLayers(); m++){
- if (GetLayer(m)){
- dst += GetLayer(m)->Dump(dst);
- }
- }
- } else {
- memset(dst++, 0, 1);
- }
-#endif
-
- if (ppFrames){
- memset(dst++, 1, 1);
- for (int32_t m=0; m<GetNumFrames(); m++){
- if (GetFrame(m)){
- dst += GetFrame(m)->Dump(dst);
- }
- }
- } else {
- memset(dst++, 0, 1);
- }
-
- return DumpSize();
-}
-////////////////////////////////////////////////////////////////////////////////
-uint32_t CxImage::UnDump(const uint8_t * src)
-{
- if (!src)
- return 0;
- if (!Destroy())
- return 0;
- if (!DestroyFrames())
- return 0;
-
- uint32_t n = 0;
-
- memcpy(&head,src,sizeof(BITMAPINFOHEADER));
- n += sizeof(BITMAPINFOHEADER);
-
- memcpy(&info,&src[n],sizeof(CXIMAGEINFO));
- n += sizeof(CXIMAGEINFO);
-
- if (!Create(head.biWidth, head.biHeight, head.biBitCount, info.dwType))
- return 0;
-
- memcpy(pDib,&src[n],GetSize());
- n += GetSize();
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (src[n++]){
- if (AlphaCreate()){
- memcpy(pAlpha, &src[n], head.biWidth * head.biHeight);
- }
- n += head.biWidth * head.biHeight;
- }
-#endif
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (src[n++]){
- RECT box = info.rSelectionBox;
- if (SelectionCreate()){
- info.rSelectionBox = box;
- memcpy(pSelection, &src[n], head.biWidth * head.biHeight);
- }
- n += head.biWidth * head.biHeight;
- }
-#endif
-
-#if CXIMAGE_SUPPORT_LAYERS
- if (src[n++]){
- ppLayers = new CxImage*[info.nNumLayers];
- for (int32_t m=0; m<GetNumLayers(); m++){
- ppLayers[m] = new CxImage();
- n += ppLayers[m]->UnDump(&src[n]);
- }
- }
-#endif
-
- if (src[n++]){
- ppFrames = new CxImage*[info.nNumFrames];
- for (int32_t m=0; m<GetNumFrames(); m++){
- ppFrames[m] = new CxImage();
- n += ppFrames[m]->UnDump(&src[n]);
- }
- }
-
- return n;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \return A.BBCCCDDDD
- * - A = main version
- * - BB = main revision
- * - CCC = minor revision (letter)
- * - DDDD = experimental revision
- */
-const float CxImage::GetVersionNumber()
-{
- return 7.000000000f;
-}
-////////////////////////////////////////////////////////////////////////////////
-const TCHAR* CxImage::GetVersion()
-{
- static const TCHAR CxImageVersion[] = _T("CxImage 7.0.0");
- return (CxImageVersion);
-}
-////////////////////////////////////////////////////////////////////////////////
diff --git a/smelt/sdl/CxImage/ximaint.cpp b/smelt/sdl/CxImage/ximaint.cpp deleted file mode 100644 index 5f93038..0000000 --- a/smelt/sdl/CxImage/ximaint.cpp +++ /dev/null @@ -1,1046 +0,0 @@ -// xImaInt.cpp : interpolation functions
-/* 02/2004 - Branko Brevensek
- * CxImage version 7.0.0 31/Dec/2010 - Davide Pizzolato - www.xdp.it
- */
-
-#include "ximage.h"
-#include "ximath.h"
-
-#if CXIMAGE_SUPPORT_INTERPOLATION
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Recalculates coordinates according to specified overflow method.
- * If pixel (x,y) lies within image, nothing changes.
- *
- * \param x, y - coordinates of pixel
- * \param ofMethod - overflow method
- *
- * \return x, y - new coordinates (pixel (x,y) now lies inside image)
- *
- * \author ***bd*** 2.2004
- */
-void CxImage::OverflowCoordinates(int32_t &x, int32_t &y, OverflowMethod const ofMethod)
-{
- if (IsInside(x,y)) return; //if pixel is within bounds, no change
- switch (ofMethod) {
- case OM_REPEAT:
- //clip coordinates
- x=max(x,0); x=min(x, head.biWidth-1);
- y=max(y,0); y=min(y, head.biHeight-1);
- break;
- case OM_WRAP:
- //wrap coordinates
- x = x % head.biWidth;
- y = y % head.biHeight;
- if (x<0) x = head.biWidth + x;
- if (y<0) y = head.biHeight + y;
- break;
- case OM_MIRROR:
- //mirror pixels near border
- if (x<0) x=((-x) % head.biWidth);
- else if (x>=head.biWidth) x=head.biWidth-(x % head.biWidth + 1);
- if (y<0) y=((-y) % head.biHeight);
- else if (y>=head.biHeight) y=head.biHeight-(y % head.biHeight + 1);
- break;
- default:
- return;
- }//switch
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * See OverflowCoordinates for integer version
- * \author ***bd*** 2.2004
- */
-void CxImage::OverflowCoordinates(float &x, float &y, OverflowMethod const ofMethod)
-{
- if (x>=0 && x<head.biWidth && y>=0 && y<head.biHeight) return; //if pixel is within bounds, no change
- switch (ofMethod) {
- case OM_REPEAT:
- //clip coordinates
- x=max(x,0); x=min(x, head.biWidth-1);
- y=max(y,0); y=min(y, head.biHeight-1);
- break;
- case OM_WRAP:
- //wrap coordinates
- x = (float)fmod(x, (float) head.biWidth);
- y = (float)fmod(y, (float) head.biHeight);
- if (x<0) x = head.biWidth + x;
- if (y<0) y = head.biHeight + y;
- break;
- case OM_MIRROR:
- //mirror pixels near border
- if (x<0) x=(float)fmod(-x, (float) head.biWidth);
- else if (x>=head.biWidth) x=head.biWidth-((float)fmod(x, (float) head.biWidth) + 1);
- if (y<0) y=(float)fmod(-y, (float) head.biHeight);
- else if (y>=head.biHeight) y=head.biHeight-((float)fmod(y, (float) head.biHeight) + 1);
- break;
- default:
- return;
- }//switch
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Method return pixel color. Different methods are implemented for out of bounds pixels.
- * If an image has alpha channel, alpha value is returned in .RGBReserved.
- *
- * \param x,y : pixel coordinates
- * \param ofMethod : out-of-bounds method:
- * - OF_WRAP - wrap over to pixels on other side of the image
- * - OF_REPEAT - repeat last pixel on the edge
- * - OF_COLOR - return input value of color
- * - OF_BACKGROUND - return background color (if not set, return input color)
- * - OF_TRANSPARENT - return transparent pixel
- *
- * \param rplColor : input color (returned for out-of-bound coordinates in OF_COLOR mode and if other mode is not applicable)
- *
- * \return color : color of pixel
- * \author ***bd*** 2.2004
- */
-RGBQUAD CxImage::GetPixelColorWithOverflow(int32_t x, int32_t y, OverflowMethod const ofMethod, RGBQUAD* const rplColor)
-{
- RGBQUAD color; //color to return
- if ((!IsInside(x,y)) || pDib==NULL) { //is pixel within bouns?:
- //pixel is out of bounds or no DIB
- if (rplColor!=NULL)
- color=*rplColor;
- else {
- color.rgbRed=color.rgbGreen=color.rgbBlue=255; color.rgbReserved=0; //default replacement colour: white transparent
- }//if
- if (pDib==NULL) return color;
- //pixel is out of bounds:
- switch (ofMethod) {
- case OM_TRANSPARENT:
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) {
- //alpha transparency is supported and image has alpha layer
- color.rgbReserved=0;
- } else {
-#endif //CXIMAGE_SUPPORT_ALPHA
- //no alpha transparency
- if (GetTransIndex()>=0) {
- color=GetTransColor(); //single color transparency enabled (return transparent color)
- }//if
-#if CXIMAGE_SUPPORT_ALPHA
- }//if
-#endif //CXIMAGE_SUPPORT_ALPHA
- return color;
- case OM_BACKGROUND:
- //return background color (if it exists, otherwise input value)
- if (info.nBkgndIndex >= 0) {
- if (head.biBitCount<24) color = GetPaletteColor((uint8_t)info.nBkgndIndex);
- else color = info.nBkgndColor;
- }//if
- return color;
- case OM_REPEAT:
- case OM_WRAP:
- case OM_MIRROR:
- OverflowCoordinates(x,y,ofMethod);
- break;
- default:
- //simply return replacement color (OM_COLOR and others)
- return color;
- }//switch
- }//if
- //just return specified pixel (it's within bounds)
- return BlindGetPixelColor(x,y);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * This method reconstructs image according to chosen interpolation method and then returns pixel (x,y).
- * (x,y) can lie between actual image pixels. If (x,y) lies outside of image, method returns value
- * according to overflow method.
- * This method is very useful for geometrical image transformations, where destination pixel
- * can often assume color value lying between source pixels.
- *
- * \param (x,y) - coordinates of pixel to return
- * GPCI method recreates "analogue" image back from digital data, so x and y
- * are float values and color value of point (1.1,1) will generally not be same
- * as (1,1). Center of first pixel is at (0,0) and center of pixel right to it is (1,0).
- * (0.5,0) is half way between these two pixels.
- * \param inMethod - interpolation (reconstruction) method (kernel) to use:
- * - IM_NEAREST_NEIGHBOUR - returns colour of nearest lying pixel (causes stairy look of
- * processed images)
- * - IM_BILINEAR - interpolates colour from four neighbouring pixels (softens image a bit)
- * - IM_BICUBIC - interpolates from 16 neighbouring pixels (can produce "halo" artifacts)
- * - IM_BICUBIC2 - interpolates from 16 neighbouring pixels (perhaps a bit less halo artifacts
- than IM_BICUBIC)
- * - IM_BSPLINE - interpolates from 16 neighbouring pixels (softens image, washes colours)
- * (As far as I know, image should be prefiltered for this method to give
- * good results... some other time :) )
- * This method uses bicubic interpolation kernel from CXImage 5.99a and older
- * versions.
- * - IM_LANCZOS - interpolates from 12*12 pixels (slow, ringing artifacts)
- *
- * \param ofMethod - overflow method (see comments at GetPixelColorWithOverflow)
- * \param rplColor - pointer to color used for out of borders pixels in OM_COLOR mode
- * (and other modes if colour can't calculated in a specified way)
- *
- * \return interpolated color value (including interpolated alpha value, if image has alpha layer)
- *
- * \author ***bd*** 2.2004
- */
-RGBQUAD CxImage::GetPixelColorInterpolated(
- float x,float y,
- InterpolationMethod const inMethod,
- OverflowMethod const ofMethod,
- RGBQUAD* const rplColor)
-{
- //calculate nearest pixel
- int32_t xi=(int32_t)(x); if (x<0) xi--; //these replace (incredibly slow) floor (Visual c++ 2003, AMD Athlon)
- int32_t yi=(int32_t)(y); if (y<0) yi--;
- RGBQUAD color; //calculated colour
-
- switch (inMethod) {
- case IM_NEAREST_NEIGHBOUR:
- return GetPixelColorWithOverflow((int32_t)(x+0.5f), (int32_t)(y+0.5f), ofMethod, rplColor);
- default: {
- //IM_BILINEAR: bilinear interpolation
- if (xi<-1 || xi>=head.biWidth || yi<-1 || yi>=head.biHeight) { //all 4 points are outside bounds?:
- switch (ofMethod) {
- case OM_COLOR: case OM_TRANSPARENT: case OM_BACKGROUND:
- //we don't need to interpolate anything with all points outside in this case
- return GetPixelColorWithOverflow(-999, -999, ofMethod, rplColor);
- default:
- //recalculate coordinates and use faster method later on
- OverflowCoordinates(x,y,ofMethod);
- xi=(int32_t)(x); if (x<0) xi--; //x and/or y have changed ... recalculate xi and yi
- yi=(int32_t)(y); if (y<0) yi--;
- }//switch
- }//if
- //get four neighbouring pixels
- if ((xi+1)<head.biWidth && xi>=0 && (yi+1)<head.biHeight && yi>=0 && head.biClrUsed==0) {
- //all pixels are inside RGB24 image... optimize reading (and use fixed point arithmetic)
- uint16_t wt1=(uint16_t)((x-xi)*256.0f), wt2=(uint16_t)((y-yi)*256.0f);
- uint16_t wd=wt1*wt2>>8;
- uint16_t wb=wt1-wd;
- uint16_t wc=wt2-wd;
- uint16_t wa=256-wt1-wc;
- uint16_t wrr,wgg,wbb;
- uint8_t *pxptr=(uint8_t*)info.pImage+yi*info.dwEffWidth+xi*3;
- wbb=wa*(*pxptr++); wgg=wa*(*pxptr++); wrr=wa*(*pxptr++);
- wbb+=wb*(*pxptr++); wgg+=wb*(*pxptr++); wrr+=wb*(*pxptr);
- pxptr+=(info.dwEffWidth-5); //move to next row
- wbb+=wc*(*pxptr++); wgg+=wc*(*pxptr++); wrr+=wc*(*pxptr++);
- wbb+=wd*(*pxptr++); wgg+=wd*(*pxptr++); wrr+=wd*(*pxptr);
- color.rgbRed=(uint8_t) (wrr>>8); color.rgbGreen=(uint8_t) (wgg>>8); color.rgbBlue=(uint8_t) (wbb>>8);
-#if CXIMAGE_SUPPORT_ALPHA
- if (pAlpha) {
- uint16_t waa;
- //image has alpha layer... we have to do the same for alpha data
- pxptr=AlphaGetPointer(xi,yi); //pointer to first byte
- waa=wa*(*pxptr++); waa+=wb*(*pxptr); //first two pixels
- pxptr+=(head.biWidth-1); //move to next row
- waa+=wc*(*pxptr++); waa+=wd*(*pxptr); //and second row pixels
- color.rgbReserved=(uint8_t) (waa>>8);
- } else
-#endif
- { //Alpha not supported or no alpha at all
- color.rgbReserved = 0;
- }
- return color;
- } else {
- //default (slower) way to get pixels (not RGB24 or some pixels out of borders)
- float t1=x-xi, t2=y-yi;
- float d=t1*t2;
- float b=t1-d;
- float c=t2-d;
- float a=1-t1-c;
- RGBQUAD rgb11,rgb21,rgb12,rgb22;
- rgb11=GetPixelColorWithOverflow(xi, yi, ofMethod, rplColor);
- rgb21=GetPixelColorWithOverflow(xi+1, yi, ofMethod, rplColor);
- rgb12=GetPixelColorWithOverflow(xi, yi+1, ofMethod, rplColor);
- rgb22=GetPixelColorWithOverflow(xi+1, yi+1, ofMethod, rplColor);
- //calculate linear interpolation
- color.rgbRed=(uint8_t) (a*rgb11.rgbRed+b*rgb21.rgbRed+c*rgb12.rgbRed+d*rgb22.rgbRed);
- color.rgbGreen=(uint8_t) (a*rgb11.rgbGreen+b*rgb21.rgbGreen+c*rgb12.rgbGreen+d*rgb22.rgbGreen);
- color.rgbBlue=(uint8_t) (a*rgb11.rgbBlue+b*rgb21.rgbBlue+c*rgb12.rgbBlue+d*rgb22.rgbBlue);
-#if CXIMAGE_SUPPORT_ALPHA
- color.rgbReserved=(uint8_t) (a*rgb11.rgbReserved+b*rgb21.rgbReserved+c*rgb12.rgbReserved+d*rgb22.rgbReserved);
-#else
- color.rgbReserved = 0;
-#endif
- return color;
- }//if
- }//default
- case IM_BICUBIC:
- case IM_BICUBIC2:
- case IM_BSPLINE:
- case IM_BOX:
- case IM_HERMITE:
- case IM_HAMMING:
- case IM_SINC:
- case IM_BLACKMAN:
- case IM_BESSEL:
- case IM_GAUSSIAN:
- case IM_QUADRATIC:
- case IM_MITCHELL:
- case IM_CATROM:
- case IM_HANNING:
- case IM_POWER:
- //bicubic interpolation(s)
- if (((xi+2)<0) || ((xi-1)>=head.biWidth) || ((yi+2)<0) || ((yi-1)>=head.biHeight)) { //all points are outside bounds?:
- switch (ofMethod) {
- case OM_COLOR: case OM_TRANSPARENT: case OM_BACKGROUND:
- //we don't need to interpolate anything with all points outside in this case
- return GetPixelColorWithOverflow(-999, -999, ofMethod, rplColor);
- break;
- default:
- //recalculate coordinates and use faster method later on
- OverflowCoordinates(x,y,ofMethod);
- xi=(int32_t)(x); if (x<0) xi--; //x and/or y have changed ... recalculate xi and yi
- yi=(int32_t)(y); if (y<0) yi--;
- }//switch
- }//if
-
- //some variables needed from here on
- int32_t xii,yii; //x any y integer indexes for loops
- float kernel, kernelyc; //kernel cache
- float kernelx[12], kernely[4]; //precalculated kernel values
- float rr,gg,bb,aa; //accumulated color values
- //calculate multiplication factors for all pixels
- int32_t i;
- switch (inMethod) {
- case IM_BICUBIC:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelCubic((float)(xi+i-1-x));
- kernely[i]=KernelCubic((float)(yi+i-1-y));
- }//for i
- break;
- case IM_BICUBIC2:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelGeneralizedCubic((float)(xi+i-1-x), -0.5);
- kernely[i]=KernelGeneralizedCubic((float)(yi+i-1-y), -0.5);
- }//for i
- break;
- case IM_BSPLINE:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelBSpline((float)(xi+i-1-x));
- kernely[i]=KernelBSpline((float)(yi+i-1-y));
- }//for i
- break;
- case IM_BOX:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelBox((float)(xi+i-1-x));
- kernely[i]=KernelBox((float)(yi+i-1-y));
- }//for i
- break;
- case IM_HERMITE:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelHermite((float)(xi+i-1-x));
- kernely[i]=KernelHermite((float)(yi+i-1-y));
- }//for i
- break;
- case IM_HAMMING:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelHamming((float)(xi+i-1-x));
- kernely[i]=KernelHamming((float)(yi+i-1-y));
- }//for i
- break;
- case IM_SINC:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelSinc((float)(xi+i-1-x));
- kernely[i]=KernelSinc((float)(yi+i-1-y));
- }//for i
- break;
- case IM_BLACKMAN:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelBlackman((float)(xi+i-1-x));
- kernely[i]=KernelBlackman((float)(yi+i-1-y));
- }//for i
- break;
- case IM_BESSEL:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelBessel((float)(xi+i-1-x));
- kernely[i]=KernelBessel((float)(yi+i-1-y));
- }//for i
- break;
- case IM_GAUSSIAN:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelGaussian((float)(xi+i-1-x));
- kernely[i]=KernelGaussian((float)(yi+i-1-y));
- }//for i
- break;
- case IM_QUADRATIC:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelQuadratic((float)(xi+i-1-x));
- kernely[i]=KernelQuadratic((float)(yi+i-1-y));
- }//for i
- break;
- case IM_MITCHELL:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelMitchell((float)(xi+i-1-x));
- kernely[i]=KernelMitchell((float)(yi+i-1-y));
- }//for i
- break;
- case IM_CATROM:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelCatrom((float)(xi+i-1-x));
- kernely[i]=KernelCatrom((float)(yi+i-1-y));
- }//for i
- break;
- case IM_HANNING:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelHanning((float)(xi+i-1-x));
- kernely[i]=KernelHanning((float)(yi+i-1-y));
- }//for i
- break;
- case IM_POWER:
- for (i=0; i<4; i++) {
- kernelx[i]=KernelPower((float)(xi+i-1-x));
- kernely[i]=KernelPower((float)(yi+i-1-y));
- }//for i
- break; - default:break;
- }//switch
- rr=gg=bb=aa=0;
- if (((xi+2)<head.biWidth) && xi>=1 && ((yi+2)<head.biHeight) && (yi>=1) && !IsIndexed()) {
- //optimized interpolation (faster pixel reads) for RGB24 images with all pixels inside bounds
- for (yii=yi-1; yii<yi+3; yii++) {
- uint8_t *pxptr=(uint8_t *)BlindGetPixelPointer(xi-1, yii); //calculate pointer to first byte in row
- kernelyc=kernely[yii-(yi-1)];
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) {
- //alpha is supported and valid (optimized bicubic int32_t. for image with alpha)
- uint8_t *pxptra=AlphaGetPointer(xi-1, yii);
- kernel=kernelyc*kernelx[0];
- bb+=kernel*(*pxptr++); gg+=kernel*(*pxptr++); rr+=kernel*(*pxptr++); aa+=kernel*(*pxptra++);
- kernel=kernelyc*kernelx[1];
- bb+=kernel*(*pxptr++); gg+=kernel*(*pxptr++); rr+=kernel*(*pxptr++); aa+=kernel*(*pxptra++);
- kernel=kernelyc*kernelx[2];
- bb+=kernel*(*pxptr++); gg+=kernel*(*pxptr++); rr+=kernel*(*pxptr++); aa+=kernel*(*pxptra++);
- kernel=kernelyc*kernelx[3];
- bb+=kernel*(*pxptr++); gg+=kernel*(*pxptr++); rr+=kernel*(*pxptr); aa+=kernel*(*pxptra);
- } else
-#endif
- //alpha not supported or valid (optimized bicubic int32_t. for no alpha channel)
- {
- kernel=kernelyc*kernelx[0];
- bb+=kernel*(*pxptr++); gg+=kernel*(*pxptr++); rr+=kernel*(*pxptr++);
- kernel=kernelyc*kernelx[1];
- bb+=kernel*(*pxptr++); gg+=kernel*(*pxptr++); rr+=kernel*(*pxptr++);
- kernel=kernelyc*kernelx[2];
- bb+=kernel*(*pxptr++); gg+=kernel*(*pxptr++); rr+=kernel*(*pxptr++);
- kernel=kernelyc*kernelx[3];
- bb+=kernel*(*pxptr++); gg+=kernel*(*pxptr++); rr+=kernel*(*pxptr);
- }
- }//yii
- } else {
- //slower more flexible interpolation for border pixels and paletted images
- RGBQUAD rgbs;
- for (yii=yi-1; yii<yi+3; yii++) {
- kernelyc=kernely[yii-(yi-1)];
- for (xii=xi-1; xii<xi+3; xii++) {
- kernel=kernelyc*kernelx[xii-(xi-1)];
- rgbs=GetPixelColorWithOverflow(xii, yii, ofMethod, rplColor);
- rr+=kernel*rgbs.rgbRed;
- gg+=kernel*rgbs.rgbGreen;
- bb+=kernel*rgbs.rgbBlue;
-#if CXIMAGE_SUPPORT_ALPHA
- aa+=kernel*rgbs.rgbReserved;
-#endif
- }//xii
- }//yii
- }//if
- //for all colors, clip to 0..255 and assign to RGBQUAD
- if (rr>255) rr=255; if (rr<0) rr=0; color.rgbRed=(uint8_t) rr;
- if (gg>255) gg=255; if (gg<0) gg=0; color.rgbGreen=(uint8_t) gg;
- if (bb>255) bb=255; if (bb<0) bb=0; color.rgbBlue=(uint8_t) bb;
-#if CXIMAGE_SUPPORT_ALPHA
- if (aa>255) aa=255; if (aa<0) aa=0; color.rgbReserved=(uint8_t) aa;
-#else
- color.rgbReserved = 0;
-#endif
- return color;
- case IM_LANCZOS:
- //lanczos window (16*16) sinc interpolation
- if (((xi+6)<0) || ((xi-5)>=head.biWidth) || ((yi+6)<0) || ((yi-5)>=head.biHeight)) {
- //all points are outside bounds
- switch (ofMethod) {
- case OM_COLOR: case OM_TRANSPARENT: case OM_BACKGROUND:
- //we don't need to interpolate anything with all points outside in this case
- return GetPixelColorWithOverflow(-999, -999, ofMethod, rplColor);
- break;
- default:
- //recalculate coordinates and use faster method later on
- OverflowCoordinates(x,y,ofMethod);
- xi=(int32_t)(x); if (x<0) xi--; //x and/or y have changed ... recalculate xi and yi
- yi=(int32_t)(y); if (y<0) yi--;
- }//switch
- }//if
-
- for (xii=xi-5; xii<xi+7; xii++) kernelx[xii-(xi-5)]=KernelLanczosSinc((float)(xii-x), 6.0f);
- rr=gg=bb=aa=0;
-
- if (((xi+6)<head.biWidth) && ((xi-5)>=0) && ((yi+6)<head.biHeight) && ((yi-5)>=0) && !IsIndexed()) {
- //optimized interpolation (faster pixel reads) for RGB24 images with all pixels inside bounds
- for (yii=yi-5; yii<yi+7; yii++) {
- uint8_t *pxptr=(uint8_t *)BlindGetPixelPointer(xi-5, yii); //calculate pointer to first byte in row
- kernelyc=KernelLanczosSinc((float)(yii-y),6.0f);
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) {
- //alpha is supported and valid
- uint8_t *pxptra=AlphaGetPointer(xi-1, yii);
- for (xii=0; xii<12; xii++) {
- kernel=kernelyc*kernelx[xii];
- bb+=kernel*(*pxptr++); gg+=kernel*(*pxptr++); rr+=kernel*(*pxptr++); aa+=kernel*(*pxptra++);
- }//for xii
- } else
-#endif
- //alpha not supported or valid
- {
- for (xii=0; xii<12; xii++) {
- kernel=kernelyc*kernelx[xii];
- bb+=kernel*(*pxptr++); gg+=kernel*(*pxptr++); rr+=kernel*(*pxptr++);
- }//for xii
- }
- }//yii
- } else {
- //slower more flexible interpolation for border pixels and paletted images
- RGBQUAD rgbs;
- for (yii=yi-5; yii<yi+7; yii++) {
- kernelyc=KernelLanczosSinc((float)(yii-y),6.0f);
- for (xii=xi-5; xii<xi+7; xii++) {
- kernel=kernelyc*kernelx[xii-(xi-5)];
- rgbs=GetPixelColorWithOverflow(xii, yii, ofMethod, rplColor);
- rr+=kernel*rgbs.rgbRed;
- gg+=kernel*rgbs.rgbGreen;
- bb+=kernel*rgbs.rgbBlue;
-#if CXIMAGE_SUPPORT_ALPHA
- aa+=kernel*rgbs.rgbReserved;
-#endif
- }//xii
- }//yii
- }//if
- //for all colors, clip to 0..255 and assign to RGBQUAD
- if (rr>255) rr=255; if (rr<0) rr=0; color.rgbRed=(uint8_t) rr;
- if (gg>255) gg=255; if (gg<0) gg=0; color.rgbGreen=(uint8_t) gg;
- if (bb>255) bb=255; if (bb<0) bb=0; color.rgbBlue=(uint8_t) bb;
-#if CXIMAGE_SUPPORT_ALPHA
- if (aa>255) aa=255; if (aa<0) aa=0; color.rgbReserved=(uint8_t) aa;
-#else
- color.rgbReserved = 0;
-#endif
- return color;
- }//switch
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Helper function for GetAreaColorInterpolated.
- * Adds 'surf' portion of image pixel with color 'color' to (rr,gg,bb,aa).
- */
-void CxImage::AddAveragingCont(RGBQUAD const &color, float const surf, float &rr, float &gg, float &bb, float &aa)
-{
- rr+=color.rgbRed*surf;
- gg+=color.rgbGreen*surf;
- bb+=color.rgbBlue*surf;
-#if CXIMAGE_SUPPORT_ALPHA
- aa+=color.rgbReserved*surf;
-#endif
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * This method is similar to GetPixelColorInterpolated, but this method also properly handles
- * subsampling.
- * If you need to sample original image with interval of more than 1 pixel (as when shrinking an image),
- * you should use this method instead of GetPixelColorInterpolated or aliasing will occur.
- * When area width and height are both less than pixel, this method gets pixel color by interpolating
- * color of frame center with selected (inMethod) interpolation by calling GetPixelColorInterpolated.
- * If width and height are more than 1, method calculates color by averaging color of pixels within area.
- * Interpolation method is not used in this case. Pixel color is interpolated by averaging instead.
- * If only one of both is more than 1, method uses combination of interpolation and averaging.
- * Chosen interpolation method is used, but since it is averaged later on, there is little difference
- * between IM_BILINEAR (perhaps best for this case) and better methods. IM_NEAREST_NEIGHBOUR again
- * leads to aliasing artifacts.
- * This method is a bit slower than GetPixelColorInterpolated and when aliasing is not a problem, you should
- * simply use the later.
- *
- * \param xc, yc - center of (rectangular) area
- * \param w, h - width and height of area
- * \param inMethod - interpolation method that is used, when interpolation is used (see above)
- * \param ofMethod - overflow method used when retrieving individual pixel colors
- * \param rplColor - replacement colour to use, in OM_COLOR
- *
- * \author ***bd*** 2.2004
- */
-RGBQUAD CxImage::GetAreaColorInterpolated(
- float const xc, float const yc, float const w, float const h,
- InterpolationMethod const inMethod,
- OverflowMethod const ofMethod,
- RGBQUAD* const rplColor)
-{
- RGBQUAD color; //calculated colour
-
- if (h<=1 && w<=1) {
- //both width and height are less than one... we will use interpolation of center point
- return GetPixelColorInterpolated(xc, yc, inMethod, ofMethod, rplColor);
- } else {
- //area is wider and/or taller than one pixel:
- CxRect2 area(xc-w/2.0f, yc-h/2.0f, xc+w/2.0f, yc+h/2.0f); //area
- int32_t xi1=(int32_t)(area.botLeft.x+0.49999999f); //low x
- int32_t yi1=(int32_t)(area.botLeft.y+0.49999999f); //low y
-
-
- int32_t xi2=(int32_t)(area.topRight.x+0.5f); //top x
- int32_t yi2=(int32_t)(area.topRight.y+0.5f); //top y (for loops)
-
- float rr,gg,bb,aa; //red, green, blue and alpha components
- rr=gg=bb=aa=0;
- int32_t x,y; //loop counters
- float s=0; //surface of all pixels
- float cps; //surface of current crosssection
- if (h>1 && w>1) {
- //width and height of area are greater than one pixel, so we can employ "ordinary" averaging
- CxRect2 intBL, intTR; //bottom left and top right intersection
- intBL=area.CrossSection(CxRect2(((float)xi1)-0.5f, ((float)yi1)-0.5f, ((float)xi1)+0.5f, ((float)yi1)+0.5f));
- intTR=area.CrossSection(CxRect2(((float)xi2)-0.5f, ((float)yi2)-0.5f, ((float)xi2)+0.5f, ((float)yi2)+0.5f));
- float wBL, wTR, hBL, hTR;
- wBL=intBL.Width(); //width of bottom left pixel-area intersection
- hBL=intBL.Height(); //height of bottom left...
- wTR=intTR.Width(); //width of top right...
- hTR=intTR.Height(); //height of top right...
-
- AddAveragingCont(GetPixelColorWithOverflow(xi1,yi1,ofMethod,rplColor), wBL*hBL, rr, gg, bb, aa); //bottom left pixel
- AddAveragingCont(GetPixelColorWithOverflow(xi2,yi1,ofMethod,rplColor), wTR*hBL, rr, gg, bb, aa); //bottom right pixel
- AddAveragingCont(GetPixelColorWithOverflow(xi1,yi2,ofMethod,rplColor), wBL*hTR, rr, gg, bb, aa); //top left pixel
- AddAveragingCont(GetPixelColorWithOverflow(xi2,yi2,ofMethod,rplColor), wTR*hTR, rr, gg, bb, aa); //top right pixel
- //bottom and top row
- for (x=xi1+1; x<xi2; x++) {
- AddAveragingCont(GetPixelColorWithOverflow(x,yi1,ofMethod,rplColor), hBL, rr, gg, bb, aa); //bottom row
- AddAveragingCont(GetPixelColorWithOverflow(x,yi2,ofMethod,rplColor), hTR, rr, gg, bb, aa); //top row
- }
- //leftmost and rightmost column
- for (y=yi1+1; y<yi2; y++) {
- AddAveragingCont(GetPixelColorWithOverflow(xi1,y,ofMethod,rplColor), wBL, rr, gg, bb, aa); //left column
- AddAveragingCont(GetPixelColorWithOverflow(xi2,y,ofMethod,rplColor), wTR, rr, gg, bb, aa); //right column
- }
- for (y=yi1+1; y<yi2; y++) {
- for (x=xi1+1; x<xi2; x++) {
- color=GetPixelColorWithOverflow(x,y,ofMethod,rplColor);
- rr+=color.rgbRed;
- gg+=color.rgbGreen;
- bb+=color.rgbBlue;
-#if CXIMAGE_SUPPORT_ALPHA
- aa+=color.rgbReserved;
-#endif
- }//for x
- }//for y
- } else {
- //width or height greater than one:
- CxRect2 intersect; //intersection with current pixel
- CxPoint2 center;
- for (y=yi1; y<=yi2; y++) {
- for (x=xi1; x<=xi2; x++) {
- intersect=area.CrossSection(CxRect2(((float)x)-0.5f, ((float)y)-0.5f, ((float)x)+0.5f, ((float)y)+0.5f));
- center=intersect.Center();
- color=GetPixelColorInterpolated(center.x, center.y, inMethod, ofMethod, rplColor);
- cps=intersect.Surface();
- rr+=color.rgbRed*cps;
- gg+=color.rgbGreen*cps;
- bb+=color.rgbBlue*cps;
-#if CXIMAGE_SUPPORT_ALPHA
- aa+=color.rgbReserved*cps;
-#endif
- }//for x
- }//for y
- }//if
-
- s=area.Surface();
- rr/=s; gg/=s; bb/=s; aa/=s;
- if (rr>255) rr=255; if (rr<0) rr=0; color.rgbRed=(uint8_t) rr;
- if (gg>255) gg=255; if (gg<0) gg=0; color.rgbGreen=(uint8_t) gg;
- if (bb>255) bb=255; if (bb<0) bb=0; color.rgbBlue=(uint8_t) bb;
-#if CXIMAGE_SUPPORT_ALPHA
- if (aa>255) aa=255; if (aa<0) aa=0; color.rgbReserved=(uint8_t) aa;
-#else
- color.rgbReserved = 0;
-#endif
- }//if
- return color;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelBSpline(const float x)
-{
- if (x>2.0f) return 0.0f;
- // thanks to Kristian Kratzenstein
- float a, b, c, d;
- float xm1 = x - 1.0f; // Was calculatet anyway cause the "if((x-1.0f) < 0)"
- float xp1 = x + 1.0f;
- float xp2 = x + 2.0f;
-
- if ((xp2) <= 0.0f) a = 0.0f; else a = xp2*xp2*xp2; // Only float, not float -> double -> float
- if ((xp1) <= 0.0f) b = 0.0f; else b = xp1*xp1*xp1;
- if (x <= 0) c = 0.0f; else c = x*x*x;
- if ((xm1) <= 0.0f) d = 0.0f; else d = xm1*xm1*xm1;
-
- return (0.16666666666666666667f * (a - (4.0f * b) + (6.0f * c) - (4.0f * d)));
-
- /* equivalent <Vladimír Kloucek>
- if (x < -2.0)
- return(0.0f);
- if (x < -1.0)
- return((2.0f+x)*(2.0f+x)*(2.0f+x)*0.16666666666666666667f);
- if (x < 0.0)
- return((4.0f+x*x*(-6.0f-3.0f*x))*0.16666666666666666667f);
- if (x < 1.0)
- return((4.0f+x*x*(-6.0f+3.0f*x))*0.16666666666666666667f);
- if (x < 2.0)
- return((2.0f-x)*(2.0f-x)*(2.0f-x)*0.16666666666666666667f);
- return(0.0f);
- */
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Bilinear interpolation kernel:
- \verbatim
- /
- | 1-t , if 0 <= t <= 1
- h(t) = | t+1 , if -1 <= t < 0
- | 0 , otherwise
- \
- \endverbatim
- * ***bd*** 2.2004
- */
-float CxImage::KernelLinear(const float t)
-{
-// if (0<=t && t<=1) return 1-t;
-// if (-1<=t && t<0) return 1+t;
-// return 0;
-
- //<Vladimír Kloucek>
- if (t < -1.0f)
- return 0.0f;
- if (t < 0.0f)
- return 1.0f+t;
- if (t < 1.0f)
- return 1.0f-t;
- return 0.0f;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Bicubic interpolation kernel (a=-1):
- \verbatim
- /
- | 1-2|t|**2+|t|**3 , if |t| < 1
- h(t) = | 4-8|t|+5|t|**2-|t|**3 , if 1<=|t|<2
- | 0 , otherwise
- \
- \endverbatim
- * ***bd*** 2.2004
- */
-float CxImage::KernelCubic(const float t)
-{
- float abs_t = (float)fabs(t);
- float abs_t_sq = abs_t * abs_t;
- if (abs_t<1) return 1-2*abs_t_sq+abs_t_sq*abs_t;
- if (abs_t<2) return 4 - 8*abs_t +5*abs_t_sq - abs_t_sq*abs_t;
- return 0;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Bicubic kernel (for a=-1 it is the same as BicubicKernel):
- \verbatim
- /
- | (a+2)|t|**3 - (a+3)|t|**2 + 1 , |t| <= 1
- h(t) = | a|t|**3 - 5a|t|**2 + 8a|t| - 4a , 1 < |t| <= 2
- | 0 , otherwise
- \
- \endverbatim
- * Often used values for a are -1 and -1/2.
- */
-float CxImage::KernelGeneralizedCubic(const float t, const float a)
-{
- float abs_t = (float)fabs(t);
- float abs_t_sq = abs_t * abs_t;
- if (abs_t<1) return (a+2)*abs_t_sq*abs_t - (a+3)*abs_t_sq + 1;
- if (abs_t<2) return a*abs_t_sq*abs_t - 5*a*abs_t_sq + 8*a*abs_t - 4*a;
- return 0;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Lanczos windowed sinc interpolation kernel with radius r.
- \verbatim
- /
- h(t) = | sinc(t)*sinc(t/r) , if |t|<r
- | 0 , otherwise
- \
- \endverbatim
- * ***bd*** 2.2004
- */
-float CxImage::KernelLanczosSinc(const float t, const float r)
-{
- if (fabs(t) > r) return 0;
- if (t==0) return 1;
- float pit=PI*t;
- float pitd=pit/r;
- return (float)((sin(pit)/pit) * (sin(pitd)/pitd));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelBox(const float x)
-{
- if (x < -0.5f)
- return 0.0f;
- if (x < 0.5f)
- return 1.0f;
- return 0.0f;
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelHermite(const float x)
-{
- if (x < -1.0f)
- return 0.0f;
- if (x < 0.0f)
- return (-2.0f*x-3.0f)*x*x+1.0f;
- if (x < 1.0f)
- return (2.0f*x-3.0f)*x*x+1.0f;
- return 0.0f;
-// if (fabs(x)>1) return 0.0f;
-// return(0.5f+0.5f*(float)cos(PI*x));
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelHanning(const float x)
-{
- if (fabs(x)>1) return 0.0f;
- return (0.5f+0.5f*(float)cos(PI*x))*((float)sin(PI*x)/(PI*x));
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelHamming(const float x)
-{
- if (x < -1.0f)
- return 0.0f;
- if (x < 0.0f)
- return 0.92f*(-2.0f*x-3.0f)*x*x+1.0f;
- if (x < 1.0f)
- return 0.92f*(2.0f*x-3.0f)*x*x+1.0f;
- return 0.0f;
-// if (fabs(x)>1) return 0.0f;
-// return(0.54f+0.46f*(float)cos(PI*x));
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelSinc(const float x)
-{
- if (x == 0.0)
- return(1.0);
- return((float)sin(PI*x)/(PI*x));
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelBlackman(const float x)
-{
- //if (fabs(x)>1) return 0.0f;
- return (0.42f+0.5f*(float)cos(PI*x)+0.08f*(float)cos(2.0f*PI*x));
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelBessel_J1(const float x)
-{
- double p, q;
-
- register int32_t i;
-
- static const double
- Pone[] =
- {
- 0.581199354001606143928050809e+21,
- -0.6672106568924916298020941484e+20,
- 0.2316433580634002297931815435e+19,
- -0.3588817569910106050743641413e+17,
- 0.2908795263834775409737601689e+15,
- -0.1322983480332126453125473247e+13,
- 0.3413234182301700539091292655e+10,
- -0.4695753530642995859767162166e+7,
- 0.270112271089232341485679099e+4
- },
- Qone[] =
- {
- 0.11623987080032122878585294e+22,
- 0.1185770712190320999837113348e+20,
- 0.6092061398917521746105196863e+17,
- 0.2081661221307607351240184229e+15,
- 0.5243710262167649715406728642e+12,
- 0.1013863514358673989967045588e+10,
- 0.1501793594998585505921097578e+7,
- 0.1606931573481487801970916749e+4,
- 0.1e+1
- };
-
- p = Pone[8];
- q = Qone[8];
- for (i=7; i >= 0; i--)
- {
- p = p*x*x+Pone[i];
- q = q*x*x+Qone[i];
- }
- return (float)(p/q);
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelBessel_P1(const float x)
-{
- double p, q;
-
- register int32_t i;
-
- static const double
- Pone[] =
- {
- 0.352246649133679798341724373e+5,
- 0.62758845247161281269005675e+5,
- 0.313539631109159574238669888e+5,
- 0.49854832060594338434500455e+4,
- 0.2111529182853962382105718e+3,
- 0.12571716929145341558495e+1
- },
- Qone[] =
- {
- 0.352246649133679798068390431e+5,
- 0.626943469593560511888833731e+5,
- 0.312404063819041039923015703e+5,
- 0.4930396490181088979386097e+4,
- 0.2030775189134759322293574e+3,
- 0.1e+1
- };
-
- p = Pone[5];
- q = Qone[5];
- for (i=4; i >= 0; i--)
- {
- p = p*(8.0/x)*(8.0/x)+Pone[i];
- q = q*(8.0/x)*(8.0/x)+Qone[i];
- }
- return (float)(p/q);
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelBessel_Q1(const float x)
-{
- double p, q;
-
- register int32_t i;
-
- static const double
- Pone[] =
- {
- 0.3511751914303552822533318e+3,
- 0.7210391804904475039280863e+3,
- 0.4259873011654442389886993e+3,
- 0.831898957673850827325226e+2,
- 0.45681716295512267064405e+1,
- 0.3532840052740123642735e-1
- },
- Qone[] =
- {
- 0.74917374171809127714519505e+4,
- 0.154141773392650970499848051e+5,
- 0.91522317015169922705904727e+4,
- 0.18111867005523513506724158e+4,
- 0.1038187585462133728776636e+3,
- 0.1e+1
- };
-
- p = Pone[5];
- q = Qone[5];
- for (i=4; i >= 0; i--)
- {
- p = p*(8.0/x)*(8.0/x)+Pone[i];
- q = q*(8.0/x)*(8.0/x)+Qone[i];
- }
- return (float)(p/q);
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelBessel_Order1(float x)
-{
- float p, q;
-
- if (x == 0.0)
- return (0.0f);
- p = x;
- if (x < 0.0)
- x=(-x);
- if (x < 8.0)
- return(p*KernelBessel_J1(x));
- q = (float)sqrt(2.0f/(PI*x))*(float)(KernelBessel_P1(x)*(1.0f/sqrt(2.0f)*(sin(x)-cos(x)))-8.0f/x*KernelBessel_Q1(x)*
- (-1.0f/sqrt(2.0f)*(sin(x)+cos(x))));
- if (p < 0.0f)
- q = (-q);
- return (q);
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelBessel(const float x)
-{
- if (x == 0.0f)
- return(PI/4.0f);
- return(KernelBessel_Order1(PI*x)/(2.0f*x));
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelGaussian(const float x)
-{
- return (float)(exp(-2.0f*x*x)*0.79788456080287f/*sqrt(2.0f/PI)*/);
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelQuadratic(const float x)
-{
- if (x < -1.5f)
- return(0.0f);
- if (x < -0.5f)
- return(0.5f*(x+1.5f)*(x+1.5f));
- if (x < 0.5f)
- return(0.75f-x*x);
- if (x < 1.5f)
- return(0.5f*(x-1.5f)*(x-1.5f));
- return(0.0f);
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelMitchell(const float x)
-{
-#define KM_B (1.0f/3.0f)
-#define KM_C (1.0f/3.0f)
-#define KM_P0 (( 6.0f - 2.0f * KM_B ) / 6.0f)
-#define KM_P2 ((-18.0f + 12.0f * KM_B + 6.0f * KM_C) / 6.0f)
-#define KM_P3 (( 12.0f - 9.0f * KM_B - 6.0f * KM_C) / 6.0f)
-#define KM_Q0 (( 8.0f * KM_B + 24.0f * KM_C) / 6.0f)
-#define KM_Q1 ((-12.0f * KM_B - 48.0f * KM_C) / 6.0f)
-#define KM_Q2 (( 6.0f * KM_B + 30.0f * KM_C) / 6.0f)
-#define KM_Q3 (( -1.0f * KM_B - 6.0f * KM_C) / 6.0f)
-
- if (x < -2.0)
- return(0.0f);
- if (x < -1.0)
- return(KM_Q0-x*(KM_Q1-x*(KM_Q2-x*KM_Q3)));
- if (x < 0.0f)
- return(KM_P0+x*x*(KM_P2-x*KM_P3));
- if (x < 1.0f)
- return(KM_P0+x*x*(KM_P2+x*KM_P3));
- if (x < 2.0f)
- return(KM_Q0+x*(KM_Q1+x*(KM_Q2+x*KM_Q3)));
- return(0.0f);
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelCatrom(const float x)
-{
- if (x < -2.0)
- return(0.0f);
- if (x < -1.0)
- return(0.5f*(4.0f+x*(8.0f+x*(5.0f+x))));
- if (x < 0.0)
- return(0.5f*(2.0f+x*x*(-5.0f-3.0f*x)));
- if (x < 1.0)
- return(0.5f*(2.0f+x*x*(-5.0f+3.0f*x)));
- if (x < 2.0)
- return(0.5f*(4.0f+x*(-8.0f+x*(5.0f-x))));
- return(0.0f);
-}
-////////////////////////////////////////////////////////////////////////////////
-float CxImage::KernelPower(const float x, const float a)
-{
- if (fabs(x)>1) return 0.0f;
- return (1.0f - (float)fabs(pow(x,a)));
-}
-////////////////////////////////////////////////////////////////////////////////
-
-#endif
diff --git a/smelt/sdl/CxImage/ximaiter.h b/smelt/sdl/CxImage/ximaiter.h deleted file mode 100644 index 2371d28..0000000 --- a/smelt/sdl/CxImage/ximaiter.h +++ /dev/null @@ -1,253 +0,0 @@ -/*
- * File: ImaIter.h
- * Purpose: Declaration of the Platform Independent Image Base Class
- * Author: Alejandro Aguilar Sierra
- * Created: 1995
- * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra(at)servidor(dot)unam(dot)mx>
- *
- * 07/08/2001 Davide Pizzolato - www.xdp.it
- * - removed slow loops
- * - added safe checks
- *
- * Permission is given by the author to freely redistribute and include
- * this code in any program as int32_t as this credit is given where due.
- *
- * COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
- * OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
- * THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
- * OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
- * CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
- * THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
- * SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
- * PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
- * THIS DISCLAIMER.
- *
- * Use at your own risk!
- * ==========================================================
- */
-
-#if !defined(__ImaIter_h)
-#define __ImaIter_h
-
-#include "ximage.h"
-#include "ximadef.h"
-
-class CImageIterator
-{
-friend class CxImage;
-protected:
- int32_t Itx, Ity; // Counters
- int32_t Stepx, Stepy;
- uint8_t* IterImage; // Image pointer
- CxImage *ima;
-public:
- // Constructors
- CImageIterator ( void );
- CImageIterator ( CxImage *image );
- operator CxImage* ();
-
- // Iterators
- BOOL ItOK ();
- void Reset ();
- void Upset ();
- void SetRow(uint8_t *buf, int32_t n);
- void GetRow(uint8_t *buf, int32_t n);
- uint8_t GetByte( ) { return IterImage[Itx]; }
- void SetByte(uint8_t b) { IterImage[Itx] = b; }
- uint8_t* GetRow(void);
- uint8_t* GetRow(int32_t n);
- BOOL NextRow();
- BOOL PrevRow();
- BOOL NextByte();
- BOOL PrevByte();
-
- void SetSteps(int32_t x, int32_t y=0) { Stepx = x; Stepy = y; }
- void GetSteps(int32_t *x, int32_t *y) { *x = Stepx; *y = Stepy; }
- BOOL NextStep();
- BOOL PrevStep();
-
- void SetY(int32_t y); /* AD - for interlace */
- int32_t GetY() {return Ity;}
- BOOL GetCol(uint8_t* pCol, uint32_t x);
- BOOL SetCol(uint8_t* pCol, uint32_t x);
-};
-
-/////////////////////////////////////////////////////////////////////
-inline
-CImageIterator::CImageIterator(void)
-{
- ima = 0;
- IterImage = 0;
- Itx = Ity = 0;
- Stepx = Stepy = 0;
-}
-/////////////////////////////////////////////////////////////////////
-inline
-CImageIterator::CImageIterator(CxImage *imageImpl): ima(imageImpl)
-{
- if (ima) IterImage = ima->GetBits();
- Itx = Ity = 0;
- Stepx = Stepy = 0;
-}
-/////////////////////////////////////////////////////////////////////
-inline
-CImageIterator::operator CxImage* ()
-{
- return ima;
-}
-/////////////////////////////////////////////////////////////////////
-inline BOOL CImageIterator::ItOK ()
-{
- if (ima) return ima->IsInside(Itx, Ity);
- else return FALSE;
-}
-/////////////////////////////////////////////////////////////////////
-inline void CImageIterator::Reset()
-{
- if (ima) IterImage = ima->GetBits();
- else IterImage=0;
- Itx = Ity = 0;
-}
-/////////////////////////////////////////////////////////////////////
-inline void CImageIterator::Upset()
-{
- Itx = 0;
- Ity = ima->GetHeight()-1;
- IterImage = ima->GetBits() + ima->GetEffWidth()*(ima->GetHeight()-1);
-}
-/////////////////////////////////////////////////////////////////////
-inline BOOL CImageIterator::NextRow()
-{
- if (++Ity >= (int32_t)ima->GetHeight()) return 0;
- IterImage += ima->GetEffWidth();
- return 1;
-}
-/////////////////////////////////////////////////////////////////////
-inline BOOL CImageIterator::PrevRow()
-{
- if (--Ity < 0) return 0;
- IterImage -= ima->GetEffWidth();
- return 1;
-}
-/* AD - for interlace */
-inline void CImageIterator::SetY(int32_t y)
-{
- if ((y < 0) || (y > (int32_t)ima->GetHeight())) return;
- Ity = y;
- IterImage = ima->GetBits() + ima->GetEffWidth()*y;
-}
-/////////////////////////////////////////////////////////////////////
-inline void CImageIterator::SetRow(uint8_t *buf, int32_t n)
-{
- if (n<0) n = (int32_t)ima->GetEffWidth();
- else n = min(n,(int32_t)ima->GetEffWidth());
-
- if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0)) memcpy(IterImage,buf,n);
-}
-/////////////////////////////////////////////////////////////////////
-inline void CImageIterator::GetRow(uint8_t *buf, int32_t n)
-{
- if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0))
- memcpy(buf,IterImage,min(n,(int32_t)ima->GetEffWidth()));
-}
-/////////////////////////////////////////////////////////////////////
-inline uint8_t* CImageIterator::GetRow()
-{
- return IterImage;
-}
-/////////////////////////////////////////////////////////////////////
-inline uint8_t* CImageIterator::GetRow(int32_t n)
-{
- SetY(n);
- return IterImage;
-}
-/////////////////////////////////////////////////////////////////////
-inline BOOL CImageIterator::NextByte()
-{
- if (++Itx < (int32_t)ima->GetEffWidth()) return 1;
- else
- if (++Ity < (int32_t)ima->GetHeight()){
- IterImage += ima->GetEffWidth();
- Itx = 0;
- return 1;
- } else
- return 0;
-}
-/////////////////////////////////////////////////////////////////////
-inline BOOL CImageIterator::PrevByte()
-{
- if (--Itx >= 0) return 1;
- else
- if (--Ity >= 0){
- IterImage -= ima->GetEffWidth();
- Itx = 0;
- return 1;
- } else
- return 0;
-}
-/////////////////////////////////////////////////////////////////////
-inline BOOL CImageIterator::NextStep()
-{
- Itx += Stepx;
- if (Itx < (int32_t)ima->GetEffWidth()) return 1;
- else {
- Ity += Stepy;
- if (Ity < (int32_t)ima->GetHeight()){
- IterImage += ima->GetEffWidth();
- Itx = 0;
- return 1;
- } else
- return 0;
- }
-}
-/////////////////////////////////////////////////////////////////////
-inline BOOL CImageIterator::PrevStep()
-{
- Itx -= Stepx;
- if (Itx >= 0) return 1;
- else {
- Ity -= Stepy;
- if (Ity >= 0 && Ity < (int32_t)ima->GetHeight()) {
- IterImage -= ima->GetEffWidth();
- Itx = 0;
- return 1;
- } else
- return 0;
- }
-}
-/////////////////////////////////////////////////////////////////////
-inline BOOL CImageIterator::GetCol(uint8_t* pCol, uint32_t x)
-{
- if ((pCol==0)||(ima->GetBpp()<8)||(x>=ima->GetWidth()))
- return 0;
- uint32_t h = ima->GetHeight();
- //uint32_t line = ima->GetEffWidth();
- uint8_t bytes = (uint8_t)(ima->GetBpp()>>3);
- uint8_t* pSrc;
- for (uint32_t y=0;y<h;y++){
- pSrc = ima->GetBits(y) + x*bytes;
- for (uint8_t w=0;w<bytes;w++){
- *pCol++=*pSrc++;
- }
- }
- return 1;
-}
-/////////////////////////////////////////////////////////////////////
-inline BOOL CImageIterator::SetCol(uint8_t* pCol, uint32_t x)
-{
- if ((pCol==0)||(ima->GetBpp()<8)||(x>=ima->GetWidth()))
- return 0;
- uint32_t h = ima->GetHeight();
- //uint32_t line = ima->GetEffWidth();
- uint8_t bytes = (uint8_t)(ima->GetBpp()>>3);
- uint8_t* pSrc;
- for (uint32_t y=0;y<h;y++){
- pSrc = ima->GetBits(y) + x*bytes;
- for (uint8_t w=0;w<bytes;w++){
- *pSrc++=*pCol++;
- }
- }
- return 1;
-}
-/////////////////////////////////////////////////////////////////////
-#endif
diff --git a/smelt/sdl/CxImage/ximajas.cpp b/smelt/sdl/CxImage/ximajas.cpp deleted file mode 100644 index 788e204..0000000 --- a/smelt/sdl/CxImage/ximajas.cpp +++ /dev/null @@ -1,325 +0,0 @@ -/*
- * File: ximajas.cpp
- * Purpose: Platform Independent JasPer Image Class Loader and Writer
- * 12/Apr/2003 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximajas.h"
-
-#if CXIMAGE_SUPPORT_JASPER
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageJAS::Decode(CxFile *hFile, uint32_t imagetype)
-{
- if (hFile == NULL) return false;
-
- jas_image_t *image=0;
- jas_stream_t *in=0;
- jas_matrix_t **bufs=0;
- int32_t i,error=0;
- int32_t fmt;
- //jas_setdbglevel(0);
-
- cx_try
- {
- if (jas_init())
- cx_throw("cannot initialize jasper");
-
- in = jas_stream_fdopen(0, "rb");
- if (!in)
- cx_throw("error: cannot open standard input");
-
- CxFileJas src(hFile,in);
-
- fmt = jas_image_getfmt(in);
- if (fmt<0)
- cx_throw("error: unknowm format");
-
- image = jas_image_decode(in, fmt, 0);
- if (!image){
- fmt = -1;
- cx_throw("error: cannot load image data");
- }
-
- char szfmt[4];
- *szfmt = '\0';
- strncpy(szfmt,jas_image_fmttostr(fmt),3);
- szfmt[3] = '\0';
-
- fmt = -1;
-#if CXIMAGE_SUPPORT_JP2
- if (strcmp(szfmt,"jp2")==0) fmt = CXIMAGE_FORMAT_JP2;
-#endif
-#if CXIMAGE_SUPPORT_JPC
- if (strcmp(szfmt,"jpc")==0) fmt = CXIMAGE_FORMAT_JPC;
-#endif
-#if CXIMAGE_SUPPORT_RAS
- if (strcmp(szfmt,"ras")==0) fmt = CXIMAGE_FORMAT_RAS;
-#endif
-#if CXIMAGE_SUPPORT_PNM
- if (strcmp(szfmt,"pnm")==0) fmt = CXIMAGE_FORMAT_PNM;
-#endif
-#if CXIMAGE_SUPPORT_PGX
- if (strcmp(szfmt,"pgx")==0) fmt = CXIMAGE_FORMAT_PGX;
-#endif
-
- //if (fmt<0)
- // cx_throw("error: unknowm format");
-
- int32_t x,y,w,h,depth,cmptno;
-
- w = jas_image_cmptwidth(image,0);
- h = jas_image_cmptheight(image,0);
- depth = jas_image_cmptprec(image,0);
-
- if (info.nEscape == -1){
- head.biWidth = w;
- head.biHeight= h;
- info.dwType = fmt<0 ? 0 : fmt;
- cx_throw("output dimensions returned");
- }
-
- if (image->numcmpts_ > 64 || image->numcmpts_ < 0)
- cx_throw("error: too many components");
-
- // <LD> 01/Jan/2005: Always force conversion to sRGB. Seems to be required for many types of JPEG2000 file.
- // if (depth!=1 && depth!=4 && depth!=8)
- if (image->numcmpts_>=3 && depth <=8)
- {
- jas_image_t *newimage;
- jas_cmprof_t *outprof;
- //jas_eprintf("forcing conversion to sRGB\n");
- outprof = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB);
- if (!outprof) {
- cx_throw("cannot create sRGB profile");
- }
- newimage = jas_image_chclrspc(image, outprof, JAS_CMXFORM_INTENT_PER);
- if (!newimage) {
- jas_cmprof_destroy(outprof); // <LD> 01/Jan/2005: Destroy color profile on error.
- cx_throw("cannot convert to sRGB");
- }
- jas_image_destroy(image);
- jas_cmprof_destroy(outprof);
- image = newimage;
- }
-
- bufs = (jas_matrix_t **)calloc(image->numcmpts_, sizeof(jas_matrix_t**));
- for (i = 0; i < image->numcmpts_; ++i) {
- bufs[i] = jas_matrix_create(1, w);
- if (!bufs[i]) {
- cx_throw("error: cannot allocate memory");
- }
- }
-
- int32_t nshift = (depth>8) ? (depth-8) : 0;
-
- if (image->numcmpts_==3 &&
- image->cmpts_[0]->width_ == image->cmpts_[1]->width_ &&
- image->cmpts_[1]->width_ == image->cmpts_[2]->width_ &&
- image->cmpts_[0]->height_ == image->cmpts_[1]->height_ &&
- image->cmpts_[1]->height_ == image->cmpts_[2]->height_ &&
- image->cmpts_[0]->prec_ == image->cmpts_[1]->prec_ &&
- image->cmpts_[1]->prec_ == image->cmpts_[2]->prec_ )
- {
-
- if(!Create(w,h,24,fmt))
- cx_throw("");
-
- RGBQUAD c;
- for (y=0; y<h; y++) {
- for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {
- jas_image_readcmpt(image, cmptno, 0, y, w, 1, bufs[cmptno]);
- }
-
- for (x=0; x<w; x++){
- c.rgbRed = (uint8_t)((jas_matrix_getv(bufs[0], x)>>nshift));
- c.rgbGreen = (uint8_t)((jas_matrix_getv(bufs[1], x)>>nshift));
- c.rgbBlue = (uint8_t)((jas_matrix_getv(bufs[2], x)>>nshift));
- SetPixelColor(x,h-1-y,c);
- }
- }
- } else {
- info.nNumFrames = image->numcmpts_;
- if ((info.nFrame<0)||(info.nFrame>=info.nNumFrames)){
- cx_throw("wrong frame!");
- }
- for (cmptno=0; cmptno<=info.nFrame; cmptno++) {
- w = jas_image_cmptwidth(image,cmptno);
- h = jas_image_cmptheight(image,cmptno);
- depth = jas_image_cmptprec(image,cmptno);
- if (depth>8) depth=8;
- if(!Create(w,h,depth,imagetype))
- cx_throw("");
- SetGrayPalette();
- for (y=0; y<h; y++) {
- jas_image_readcmpt(image, cmptno, 0, y, w, 1, bufs[0]);
- for (x=0; x<w; x++){
- SetPixelIndex(x,h-1-y,(uint8_t)((jas_matrix_getv(bufs[0], x)>>nshift)));
- }
- }
- }
- }
-
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- if (info.nEscape == -1 && fmt>0){
- error = 0;
- } else {
- error = 1;
- }
- }
-
- if (bufs) {
- for (i = 0; i < image->numcmpts_; ++i){ if (bufs[i]) jas_matrix_destroy(bufs[i]);}
- free(bufs);
- }
- jas_cleanup();
- if (image) jas_image_destroy(image);
- if (in) jas_stream_close(in);
- return (error==0);
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageJAS::Encode(CxFile * hFile, uint32_t imagetype)
-{
- if (EncodeSafeCheck(hFile)) return false;
-
- if (head.biClrUsed!=0 && !IsGrayScale()){
- strcpy(info.szLastError,"JasPer can save only RGB or GrayScale images");
- return false;
- }
-
- jas_image_t *image=0;
- jas_stream_t *out=0;
- jas_matrix_t *cmpts[3];
- int32_t x,y,yflip,error=0;
- uint_fast16_t cmptno, numcmpts=0;
- jas_image_cmptparm_t cmptparms[3], *cmptparm;
-
- cx_try {
-
- if (jas_init())
- cx_throw("cannot initialize jasper");
-
- out = jas_stream_fdopen(0, "wb");
- if (!out)
- cx_throw("error: cannot open standard output");
-
- CxFileJas src(hFile,out);
-
- numcmpts = head.biClrUsed==0 ? 3 : 1;
-
- for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno, ++cmptparm) {
- cmptparm->tlx = 0;
- cmptparm->tly = 0;
- cmptparm->hstep = 1;
- cmptparm->vstep = 1;
- cmptparm->width = head.biWidth;
- cmptparm->height = head.biHeight;
- cmptparm->prec = 8;
- cmptparm->sgnd = false;
- }
-
- /* Create image object. */
- image = jas_image_create(numcmpts, cmptparms, JAS_CLRSPC_UNKNOWN);
- if (!image)
- cx_throw("error : jas_image_create");
-
- if (numcmpts == 3) {
- jas_image_setclrspc(image, JAS_CLRSPC_SRGB);
- jas_image_setcmpttype(image, 0,
- JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
- jas_image_setcmpttype(image, 1,
- JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
- jas_image_setcmpttype(image, 2,
- JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
- } else {
- jas_image_setclrspc(image, JAS_CLRSPC_SGRAY);
- jas_image_setcmpttype(image, 0,
- JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y));
- }
-
-
- for (x = 0; x < numcmpts; ++x) { cmpts[x] = 0; }
- /* Create temporary matrices to hold component data. */
- for (x = 0; x < numcmpts; ++x) {
- cmpts[x] = jas_matrix_create(1, head.biWidth);
- if (!cmpts[x]) {
- cx_throw("error : can't allocate memory");
- }
- }
-
- RGBQUAD c;
- for (y = 0; y < head.biHeight; ++y) {
- for (x = 0; x < head.biWidth; ++x) {
- if (head.biClrUsed==0){
- c = GetPixelColor(x,y);
- jas_matrix_setv(cmpts[0], x, c.rgbRed);
- jas_matrix_setv(cmpts[1], x, c.rgbGreen);
- jas_matrix_setv(cmpts[2], x, c.rgbBlue);
- } else {
- jas_matrix_setv(cmpts[0], x, GetPixelIndex(x,y));
- }
- }
- yflip = head.biHeight - 1 - y;
- for (cmptno = 0; cmptno < numcmpts; ++cmptno) {
- if (jas_image_writecmpt(image, cmptno, 0, yflip, head.biWidth, 1, cmpts[cmptno])) {
- cx_throw("error : jas_image_writecmpt");
- }
- }
- }
-
- char szfmt[4];
- *szfmt = '\0';
-#if CXIMAGE_SUPPORT_JP2
- if (imagetype == CXIMAGE_FORMAT_JP2) strcpy(szfmt,"jp2");
-#endif
-#if CXIMAGE_SUPPORT_JPC
- if (imagetype == CXIMAGE_FORMAT_JPC) strcpy(szfmt,"jpc");
-#endif
-#if CXIMAGE_SUPPORT_RAS
- if (imagetype == CXIMAGE_FORMAT_RAS) strcpy(szfmt,"ras");
-#endif
-#if CXIMAGE_SUPPORT_PNM
- if (imagetype == CXIMAGE_FORMAT_PNM) strcpy(szfmt,"pnm");
-#endif
-#if CXIMAGE_SUPPORT_PGX
- if (imagetype == CXIMAGE_FORMAT_PGX){
- strcpy(szfmt,"pgx");
- if (head.biClrUsed==0) cx_throw("PGX can save only GrayScale images");
- }
-#endif
- int32_t outfmt = jas_image_strtofmt(szfmt);
-
- char szoutopts[32];
- sprintf(szoutopts,"rate=%.3f", info.fQuality/100.0f);
-
- if (jas_image_encode(image, out, outfmt, szoutopts)) {
- cx_throw("error: cannot encode image");
- }
- jas_stream_flush(out);
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- error = 1;
- }
-
- for (x = 0; x < numcmpts; ++x) { if (cmpts[x]) { jas_matrix_destroy(cmpts[x]); } }
- jas_cleanup();
- if (image) jas_image_destroy(image);
- if (out) jas_stream_close(out);
-
- return (error==0);
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_JASPER
-
diff --git a/smelt/sdl/CxImage/ximajas.h b/smelt/sdl/CxImage/ximajas.h deleted file mode 100644 index da76dfc..0000000 --- a/smelt/sdl/CxImage/ximajas.h +++ /dev/null @@ -1,88 +0,0 @@ -/*
- * File: ximajas.h
- * Purpose: Jasper Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImageJAS (c) 12/Apr/2003 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- *
- * based on JasPer Copyright (c) 2001-2003 Michael David Adams - All rights reserved.
- * ==========================================================
- */
-#if !defined(__ximaJAS_h)
-#define __ximaJAS_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_JASPER
-
-#ifdef _LINUX
- #include <jasper/jasper.h>
-#else
- #include "../jasper/include/jasper/jasper.h"
-#endif
-
-class CxImageJAS: public CxImage
-{
-public:
- CxImageJAS(): CxImage((uint32_t)0) {} // <vho> cast to uint32_t
-
-// bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,0);}
-// bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,0);}
- bool Decode(CxFile * hFile, uint32_t imagetype = 0);
- bool Decode(FILE *hFile, uint32_t imagetype = 0) { CxIOFile file(hFile); return Decode(&file,imagetype); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile, uint32_t imagetype = 0);
- bool Encode(FILE *hFile, uint32_t imagetype = 0) { CxIOFile file(hFile); return Encode(&file,imagetype); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-protected:
-
- class CxFileJas
- {
- public:
- CxFileJas(CxFile* pFile,jas_stream_t *stream)
- {
- if (stream->obj_) jas_free(stream->obj_);
- stream->obj_ = pFile;
-
- // <vho> - cannot set the stream->ops_->functions here,
- // because this overwrites a static structure in the Jasper library.
- // This structure is used by Jasper for internal operations too, e.g. tempfile.
- // However the ops_ pointer in the stream can be overwritten.
-
- //stream->ops_->close_ = JasClose;
- //stream->ops_->read_ = JasRead;
- //stream->ops_->seek_ = JasSeek;
- //stream->ops_->write_ = JasWrite;
-
- jas_stream_CxFile.close_ = JasClose;
- jas_stream_CxFile.read_ = JasRead;
- jas_stream_CxFile.seek_ = JasSeek;
- jas_stream_CxFile.write_ = JasWrite;
-
- stream->ops_ = &jas_stream_CxFile;
-
- // <vho> - end
- }
- static int32_t JasRead(jas_stream_obj_t *obj, char *buf, int32_t cnt)
- { return ((CxFile*)obj)->Read(buf,1,cnt); }
- static int32_t JasWrite(jas_stream_obj_t *obj, char *buf, int32_t cnt)
- { return ((CxFile*)obj)->Write(buf,1,cnt); }
- static long JasSeek(jas_stream_obj_t *obj, long offset, int32_t origin)
- { return ((CxFile*)obj)->Seek(offset,origin); }
- static int32_t JasClose(jas_stream_obj_t * /*obj*/)
- { return 1; }
-
- // <vho>
-private:
- jas_stream_ops_t jas_stream_CxFile;
- // <vho> - end
-
- };
-
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximajbg.cpp b/smelt/sdl/CxImage/ximajbg.cpp deleted file mode 100644 index ee7bc10..0000000 --- a/smelt/sdl/CxImage/ximajbg.cpp +++ /dev/null @@ -1,174 +0,0 @@ -/*
- * File: ximajbg.cpp
- * Purpose: Platform Independent JBG Image Class Loader and Writer
- * 18/Aug/2002 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximajbg.h"
-
-#if CXIMAGE_SUPPORT_JBG
-
-#include "ximaiter.h"
-
-#define JBIG_BUFSIZE 8192
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageJBG::Decode(CxFile *hFile)
-{
- if (hFile == NULL) return false;
-
- struct jbg_dec_state jbig_state;
- uint32_t xmax = 4294967295UL, ymax = 4294967295UL;
- uint32_t len, cnt;
- uint8_t *buffer=0,*p;
- int32_t result;
-
- cx_try
- {
- jbg_dec_init(&jbig_state);
- jbg_dec_maxsize(&jbig_state, xmax, ymax);
-
- buffer = (uint8_t*)malloc(JBIG_BUFSIZE);
- if (!buffer) cx_throw("Sorry, not enough memory available!");
-
- result = JBG_EAGAIN;
- do {
- len = hFile->Read(buffer, 1, JBIG_BUFSIZE);
- if (!len) break;
- cnt = 0;
- p = buffer;
- while (len > 0 && (result == JBG_EAGAIN || result == JBG_EOK)) {
- result = jbg_dec_in(&jbig_state, p, len, &cnt);
- p += cnt;
- len -= cnt;
- }
- } while (result == JBG_EAGAIN || result == JBG_EOK);
-
- if (hFile->Error())
- cx_throw("Problem while reading input file");
- if (result != JBG_EOK && result != JBG_EOK_INTR)
- cx_throw("Problem with input file");
-
- int32_t w, h, bpp, planes, ew;
-
- w = jbg_dec_getwidth(&jbig_state);
- h = jbg_dec_getheight(&jbig_state);
- planes = jbg_dec_getplanes(&jbig_state);
- bpp = (planes+7)>>3;
- ew = (w + 7)>>3;
-
- if (info.nEscape == -1){
- head.biWidth = w;
- head.biHeight= h;
- info.dwType = CXIMAGE_FORMAT_JBG;
- cx_throw("output dimensions returned");
- }
-
- switch (planes){
- case 1:
- {
- uint8_t* binary_image = jbg_dec_getimage(&jbig_state, 0);
-
- if (!Create(w,h,1,CXIMAGE_FORMAT_JBG))
- cx_throw("");
-
- SetPaletteColor(0,255,255,255);
- SetPaletteColor(1,0,0,0);
-
- CImageIterator iter(this);
- iter.Upset();
- for (int32_t i=0;i<h;i++){
- iter.SetRow(binary_image+i*ew,ew);
- iter.PrevRow();
- }
-
- break;
- }
- default:
- cx_throw("cannot decode images with more than 1 plane");
- }
-
- jbg_dec_free(&jbig_state);
- free(buffer);
-
- } cx_catch {
- jbg_dec_free(&jbig_state);
- if (buffer) free(buffer);
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- if (info.nEscape == -1 && info.dwType == CXIMAGE_FORMAT_JBG) return true;
- return false;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageJBG::Encode(CxFile * hFile)
-{
- if (EncodeSafeCheck(hFile)) return false;
-
- if (head.biBitCount != 1){
- strcpy(info.szLastError,"JBG can save only 1-bpp images");
- return false;
- }
-
- int32_t w, h, bpp, planes, ew, i, j, x, y;
-
- w = head.biWidth;
- h = head.biHeight;
- planes = 1;
- bpp = (planes+7)>>3;
- ew = (w + 7)>>3;
-
- uint8_t mask;
- RGBQUAD *rgb = GetPalette();
- if (CompareColors(&rgb[0],&rgb[1])<0) mask=255; else mask=0;
-
- uint8_t *buffer = (uint8_t*)malloc(ew*h*2);
- if (!buffer) {
- strcpy(info.szLastError,"Sorry, not enough memory available!");
- return false;
- }
-
- for (y=0; y<h; y++){
- i= y*ew;
- j= (h-y-1)*info.dwEffWidth;
- for (x=0; x<ew; x++){
- buffer[i + x]=info.pImage[j + x]^mask;
- }
- }
-
- struct jbg_enc_state jbig_state;
- jbg_enc_init(&jbig_state, w, h, planes, &buffer, jbig_data_out, hFile);
-
- //jbg_enc_layers(&jbig_state, 2);
- //jbg_enc_lrlmax(&jbig_state, 800, 600);
-
- // Specify a few other options (each is ignored if negative)
- int32_t dl = -1, dh = -1, d = -1, l0 = -1, mx = -1;
- int32_t options = JBG_TPDON | JBG_TPBON | JBG_DPON;
- int32_t order = JBG_ILEAVE | JBG_SMID;
- jbg_enc_lrange(&jbig_state, dl, dh);
- jbg_enc_options(&jbig_state, order, options, l0, mx, -1);
-
- // now encode everything and send it to data_out()
- jbg_enc_out(&jbig_state);
-
- // give encoder a chance to free its temporary data structures
- jbg_enc_free(&jbig_state);
-
- free(buffer);
-
- if (hFile->Error()){
- strcpy(info.szLastError,"Problem while writing JBG file");
- return false;
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_JBG
-
diff --git a/smelt/sdl/CxImage/ximajbg.h b/smelt/sdl/CxImage/ximajbg.h deleted file mode 100644 index 1cf4965..0000000 --- a/smelt/sdl/CxImage/ximajbg.h +++ /dev/null @@ -1,44 +0,0 @@ -/*
- * File: ximajbg.h
- * Purpose: JBG Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImageJBG (c) 18/Aug/2002 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- *
- * based on LIBJBG Copyright (c) 2002, Markus Kuhn - All rights reserved.
- * ==========================================================
- */
-#if !defined(__ximaJBG_h)
-#define __ximaJBG_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_JBG
-
-extern "C" {
-#include "../jbig/jbig.h"
-};
-
-class CxImageJBG: public CxImage
-{
-public:
- CxImageJBG(): CxImage(CXIMAGE_FORMAT_JBG) {}
-
-// bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_JBG);}
-// bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_JBG);}
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-protected:
- static void jbig_data_out(uint8_t *buffer, uint32_t len, void *file)
- {((CxFile*)file)->Write(buffer,len,1);}
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximajpg.cpp b/smelt/sdl/CxImage/ximajpg.cpp deleted file mode 100644 index b66bf97..0000000 --- a/smelt/sdl/CxImage/ximajpg.cpp +++ /dev/null @@ -1,538 +0,0 @@ -/*
- * File: ximajpg.cpp
- * Purpose: Platform Independent JPEG Image Class Loader and Writer
- * 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximajpg.h"
-
-#if CXIMAGE_SUPPORT_JPG
-
-#ifdef _LINUX
- #include <jmorecfg.h>
-#else
- #include "../jpeg/jmorecfg.h"
-#endif
-
-#include "ximaiter.h"
-
-#include <setjmp.h>
-
-struct jpg_error_mgr {
- struct jpeg_error_mgr pub; /* "public" fields */
- jmp_buf setjmp_buffer; /* for return to caller */
- char* buffer; /* error message <CSC>*/
-};
-typedef jpg_error_mgr *jpg_error_ptr;
-
-////////////////////////////////////////////////////////////////////////////////
-// Here's the routine that will replace the standard error_exit method:
-////////////////////////////////////////////////////////////////////////////////
-static void
-ima_jpeg_error_exit (j_common_ptr cinfo)
-{
- /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
- jpg_error_ptr myerr = (jpg_error_ptr) cinfo->err;
- /* Create the message */
- myerr->pub.format_message (cinfo, myerr->buffer);
- /* Send it to stderr, adding a newline */
- /* Return control to the setjmp point */
- longjmp(myerr->setjmp_buffer, 1);
-}
-////////////////////////////////////////////////////////////////////////////////
-CxImageJPG::CxImageJPG(): CxImage(CXIMAGE_FORMAT_JPG)
-{
-#if CXIMAGEJPG_SUPPORT_EXIF
- m_exif = NULL;
- memset(&info.ExifInfo, 0, sizeof(EXIFINFO));
-#endif
-}
-////////////////////////////////////////////////////////////////////////////////
-CxImageJPG::~CxImageJPG()
-{
-#if CXIMAGEJPG_SUPPORT_EXIF
- if (m_exif) delete m_exif;
-#endif
-}
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGEJPG_SUPPORT_EXIF
-bool CxImageJPG::DecodeExif(CxFile * hFile)
-{
- m_exif = new CxExifInfo(&info.ExifInfo);
- if (m_exif){
- int32_t pos=hFile->Tell();
- m_exif->DecodeExif(hFile);
- hFile->Seek(pos,SEEK_SET);
- return m_exif->m_exifinfo->IsExif;
- } else {
- return false;
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageJPG::GetExifThumbnail(const TCHAR *filename, const TCHAR *outname, int32_t type)
-{
- CxIOFile file;
- if (!file.Open(filename, _T("rb"))) return false;
- CxExifInfo exif(&info.ExifInfo);
- exif.DecodeExif(&file);
- if (info.ExifInfo.IsExif && info.ExifInfo.ThumbnailPointer && info.ExifInfo.ThumbnailSize > 0)
- { // have a thumbnail - check whether it needs rotating or resizing
- // TODO: Write a fast routine to read the jpeg header to get the width and height
- CxImage image(info.ExifInfo.ThumbnailPointer, info.ExifInfo.ThumbnailSize, CXIMAGE_FORMAT_JPG);
- if (image.IsValid())
- {
- if (image.GetWidth() > 256 || image.GetHeight() > 256)
- { // resize the image
-// float amount = 256.0f / max(image.GetWidth(), image.GetHeight());
-// image.Resample((int32_t)(image.GetWidth() * amount), (int32_t)(image.GetHeight() * amount), 0);
- }
- if (info.ExifInfo.Orientation != 1)
- image.RotateExif(info.ExifInfo.Orientation);
- return image.Save(outname, CXIMAGE_FORMAT_JPG);
- }
- // nice and fast, but we can't resize :(
- /*
- FILE *hFileWrite;
- if ((hFileWrite=fopen(outname, "wb")) != NULL)
- {
- fwrite(m_exifinfo.ThumbnailPointer, m_exifinfo.ThumbnailSize, 1, hFileWrite);
- fclose(hFileWrite);
- return true;
- }*/
- }
- return false;
-}
-#endif //CXIMAGEJPG_SUPPORT_EXIF
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageJPG::Decode(CxFile * hFile)
-{
-
- bool is_exif = false;
-#if CXIMAGEJPG_SUPPORT_EXIF
- is_exif = DecodeExif(hFile);
-#endif
-
- CImageIterator iter(this);
- /* This struct contains the JPEG decompression parameters and pointers to
- * working space (which is allocated as needed by the JPEG library).
- */
- struct jpeg_decompress_struct cinfo;
- /* We use our private extension JPEG error handler. <CSC> */
- struct jpg_error_mgr jerr;
- jerr.buffer=info.szLastError;
- /* More stuff */
- JSAMPARRAY buffer; /* Output row buffer */
- int32_t row_stride; /* physical row width in output buffer */
-
- /* In this example we want to open the input file before doing anything else,
- * so that the setjmp() error recovery below can assume the file is open.
- * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
- * requires it in order to read binary files.
- */
-
- /* Step 1: allocate and initialize JPEG decompression object */
- /* We set up the normal JPEG error routines, then override error_exit. */
- cinfo.err = jpeg_std_error(&jerr.pub);
- jerr.pub.error_exit = ima_jpeg_error_exit;
-
- CxFileJpg src(hFile);
-
- /* Establish the setjmp return context for my_error_exit to use. */
- if (setjmp(jerr.setjmp_buffer)) {
- /* If we get here, the JPEG code has signaled an error.
- * We need to clean up the JPEG object, close the input file, and return.
- */
- jpeg_destroy_decompress(&cinfo);
- return 0;
- }
- /* Now we can initialize the JPEG decompression object. */
- jpeg_create_decompress(&cinfo);
-
- /* Step 2: specify data source (eg, a file) */
- //jpeg_stdio_src(&cinfo, infile);
- cinfo.src = &src;
-
- /* Step 3: read file parameters with jpeg_read_header() */
- (void) jpeg_read_header(&cinfo, TRUE);
-
- /* Step 4 <chupeev> handle decoder options*/
- uint32_t dwCodecOptions = GetCodecOption(CXIMAGE_FORMAT_JPG); //[nm_114]
- if ((dwCodecOptions & DECODE_GRAYSCALE) != 0)
- cinfo.out_color_space = JCS_GRAYSCALE;
- if ((dwCodecOptions & DECODE_QUANTIZE) != 0) {
- cinfo.quantize_colors = TRUE;
- cinfo.desired_number_of_colors = GetJpegQuality();
- }
- if ((dwCodecOptions & DECODE_DITHER) != 0)
- cinfo.dither_mode = m_nDither;
- if ((dwCodecOptions & DECODE_ONEPASS) != 0)
- cinfo.two_pass_quantize = FALSE;
- if ((dwCodecOptions & DECODE_NOSMOOTH) != 0)
- cinfo.do_fancy_upsampling = FALSE;
-
-//<DP>: Load true color images as RGB (no quantize)
-/* Step 4: set parameters for decompression */
-/* if (cinfo.jpeg_color_space!=JCS_GRAYSCALE) {
- * cinfo.quantize_colors = TRUE;
- * cinfo.desired_number_of_colors = 128;
- *}
- */ //</DP>
-
- cinfo.scale_num = 1;
- // Set the scale <ignacio>
- cinfo.scale_denom = GetJpegScale();
-
- // Borrowed the idea from GIF implementation <ignacio>
- if (info.nEscape == -1) {
- // Return output dimensions only
- jpeg_calc_output_dimensions(&cinfo);
- head.biWidth = cinfo.output_width;
- head.biHeight = cinfo.output_height;
- info.dwType = CXIMAGE_FORMAT_JPG;
- jpeg_destroy_decompress(&cinfo);
- return true;
- }
-
- /* Step 5: Start decompressor */
- jpeg_start_decompress(&cinfo);
-
- /* We may need to do some setup of our own at this point before reading
- * the data. After jpeg_start_decompress() we have the correct scaled
- * output image dimensions available, as well as the output colormap
- * if we asked for color quantization.
- */
- //Create the image using output dimensions <ignacio>
- //Create(cinfo.image_width, cinfo.image_height, 8*cinfo.output_components, CXIMAGE_FORMAT_JPG);
- Create(cinfo.output_width, cinfo.output_height, 8*cinfo.output_components, CXIMAGE_FORMAT_JPG);
-
- if (!pDib) longjmp(jerr.setjmp_buffer, 1); //<DP> check if the image has been created
-
- if (is_exif){
-#if CXIMAGEJPG_SUPPORT_EXIF
- if ((info.ExifInfo.Xresolution != 0.0) && (info.ExifInfo.ResolutionUnit != 0))
- SetXDPI((int32_t)(info.ExifInfo.Xresolution/info.ExifInfo.ResolutionUnit));
- if ((info.ExifInfo.Yresolution != 0.0) && (info.ExifInfo.ResolutionUnit != 0))
- SetYDPI((int32_t)(info.ExifInfo.Yresolution/info.ExifInfo.ResolutionUnit));
-#endif
- } else {
- switch (cinfo.density_unit) {
- case 0: // [andy] fix for aspect ratio...
- if((cinfo.Y_density > 0) && (cinfo.X_density > 0)){
- SetYDPI((int32_t)(GetXDPI()*(float(cinfo.Y_density)/float(cinfo.X_density))));
- }
- break;
- case 2: // [andy] fix: cinfo.X/Y_density is pixels per centimeter
- SetXDPI((int32_t)floor(cinfo.X_density * 2.54 + 0.5));
- SetYDPI((int32_t)floor(cinfo.Y_density * 2.54 + 0.5));
- break;
- default:
- SetXDPI(cinfo.X_density);
- SetYDPI(cinfo.Y_density);
- }
- }
-
- if (cinfo.out_color_space==JCS_GRAYSCALE){
- SetGrayPalette();
- head.biClrUsed =256;
- } else {
- if (cinfo.quantize_colors){
- SetPalette(cinfo.actual_number_of_colors, cinfo.colormap[0], cinfo.colormap[1], cinfo.colormap[2]);
- head.biClrUsed=cinfo.actual_number_of_colors;
- } else {
- head.biClrUsed=0;
- }
- }
-
- /* JSAMPLEs per row in output buffer */
- row_stride = cinfo.output_width * cinfo.output_components;
-
- /* Make a one-row-high sample array that will go away when done with image */
- buffer = (*cinfo.mem->alloc_sarray)
- ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
-
- /* Step 6: while (scan lines remain to be read) */
- /* jpeg_read_scanlines(...); */
- /* Here we use the library's state variable cinfo.output_scanline as the
- * loop counter, so that we don't have to keep track ourselves.
- */
- iter.Upset();
- while (cinfo.output_scanline < cinfo.output_height) {
-
- if (info.nEscape) longjmp(jerr.setjmp_buffer, 1); // <vho> - cancel decoding
-
- (void) jpeg_read_scanlines(&cinfo, buffer, 1);
- // info.nProgress = (int32_t)(100*cinfo.output_scanline/cinfo.output_height);
- //<DP> Step 6a: CMYK->RGB */
- if ((cinfo.num_components==4)&&(cinfo.quantize_colors==FALSE)){
- uint8_t k,*dst,*src;
- dst=iter.GetRow();
- src=buffer[0];
- for(int32_t x3=0,x4=0; x3<(int32_t)info.dwEffWidth && x4<row_stride; x3+=3, x4+=4){
- k=src[x4+3];
- dst[x3] =(uint8_t)((k * src[x4+2])/255);
- dst[x3+1]=(uint8_t)((k * src[x4+1])/255);
- dst[x3+2]=(uint8_t)((k * src[x4+0])/255);
- }
- } else {
- /* Assume put_scanline_someplace wants a pointer and sample count. */
- iter.SetRow(buffer[0], row_stride);
- }
- iter.PrevRow();
- }
-
- /* Step 7: Finish decompression */
- (void) jpeg_finish_decompress(&cinfo);
- /* We can ignore the return value since suspension is not possible
- * with the stdio data source.
- */
-
- //<DP> Step 7A: Swap red and blue components
- // not necessary if swapped red and blue definition in jmorecfg.h;ln322 <W. Morrison>
- if ((cinfo.num_components==3)&&(cinfo.quantize_colors==FALSE)){
- uint8_t* r0=GetBits();
- for(int32_t y=0;y<head.biHeight;y++){
- if (info.nEscape) longjmp(jerr.setjmp_buffer, 1); // <vho> - cancel decoding
- RGBtoBGR(r0,3*head.biWidth);
- r0+=info.dwEffWidth;
- }
- }
-
- /* Step 8: Release JPEG decompression object */
- /* This is an important step since it will release a good deal of memory. */
- jpeg_destroy_decompress(&cinfo);
-
- /* At this point you may want to check to see whether any corrupt-data
- * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
- */
-
- /* And we're done! */
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageJPG::Encode(CxFile * hFile)
-{
- if (EncodeSafeCheck(hFile)) return false;
-
- if (head.biClrUsed!=0 && !IsGrayScale()){
- strcpy(info.szLastError,"JPEG can save only RGB or GreyScale images");
- return false;
- }
-
- // necessary for EXIF, and for roll backs
- int32_t pos=hFile->Tell();
-
- /* This struct contains the JPEG compression parameters and pointers to
- * working space (which is allocated as needed by the JPEG library).
- * It is possible to have several such structures, representing multiple
- * compression/decompression processes, in existence at once. We refer
- * to any one struct (and its associated working data) as a "JPEG object".
- */
- struct jpeg_compress_struct cinfo;
- /* This struct represents a JPEG error handler. It is declared separately
- * because applications often want to supply a specialized error handler
- * (see the second half of this file for an example). But here we just
- * take the easy way out and use the standard error handler, which will
- * print a message on stderr and call exit() if compression fails.
- * Note that this struct must live as int32_t as the main JPEG parameter
- * struct, to avoid dangling-pointer problems.
- */
- //struct jpeg_error_mgr jerr;
- /* We use our private extension JPEG error handler. <CSC> */
- struct jpg_error_mgr jerr;
- jerr.buffer=info.szLastError;
- /* More stuff */
- int32_t row_stride; /* physical row width in image buffer */
- JSAMPARRAY buffer; /* Output row buffer */
-
- /* Step 1: allocate and initialize JPEG compression object */
- /* We have to set up the error handler first, in case the initialization
- * step fails. (Unlikely, but it could happen if you are out of memory.)
- * This routine fills in the contents of struct jerr, and returns jerr's
- * address which we place into the link field in cinfo.
- */
- //cinfo.err = jpeg_std_error(&jerr); <CSC>
- /* We set up the normal JPEG error routines, then override error_exit. */
- cinfo.err = jpeg_std_error(&jerr.pub);
- jerr.pub.error_exit = ima_jpeg_error_exit;
-
- /* Establish the setjmp return context for my_error_exit to use. */
- if (setjmp(jerr.setjmp_buffer)) {
- /* If we get here, the JPEG code has signaled an error.
- * We need to clean up the JPEG object, close the input file, and return.
- */
- strcpy(info.szLastError, jerr.buffer); //<CSC>
- jpeg_destroy_compress(&cinfo);
- return 0;
- }
-
- /* Now we can initialize the JPEG compression object. */
- jpeg_create_compress(&cinfo);
- /* Step 2: specify data destination (eg, a file) */
- /* Note: steps 2 and 3 can be done in either order. */
- /* Here we use the library-supplied code to send compressed data to a
- * stdio stream. You can also write your own code to do something else.
- * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
- * requires it in order to write binary files.
- */
-
- //jpeg_stdio_dest(&cinfo, outfile);
- CxFileJpg dest(hFile);
- cinfo.dest = &dest;
-
- /* Step 3: set parameters for compression */
- /* First we supply a description of the input image.
- * Four fields of the cinfo struct must be filled in:
- */
- cinfo.image_width = GetWidth(); // image width and height, in pixels
- cinfo.image_height = GetHeight();
-
- if (IsGrayScale()){
- cinfo.input_components = 1; // # of color components per pixel
- cinfo.in_color_space = JCS_GRAYSCALE; /* colorspace of input image */
- } else {
- cinfo.input_components = 3; // # of color components per pixel
- cinfo.in_color_space = JCS_RGB; /* colorspace of input image */
- }
-
- /* Now use the library's routine to set default compression parameters.
- * (You must set at least cinfo.in_color_space before calling this,
- * since the defaults depend on the source color space.)
- */
- jpeg_set_defaults(&cinfo);
- /* Now you can set any non-default parameters you wish to.
- * Here we just illustrate the use of quality (quantization table) scaling:
- */
-
- uint32_t dwCodecOptions = GetCodecOption(CXIMAGE_FORMAT_JPG); //[nm_114]
-//#ifdef C_ARITH_CODING_SUPPORTED
- if ((dwCodecOptions & ENCODE_ARITHMETIC) != 0)
- cinfo.arith_code = TRUE;
-//#endif
-
-//#ifdef ENTROPY_OPT_SUPPORTED
- if ((dwCodecOptions & ENCODE_OPTIMIZE) != 0)
- cinfo.optimize_coding = TRUE;
-//#endif
-
- if ((dwCodecOptions & ENCODE_GRAYSCALE) != 0)
- jpeg_set_colorspace(&cinfo, JCS_GRAYSCALE);
-
- if ((dwCodecOptions & ENCODE_SMOOTHING) != 0)
- cinfo.smoothing_factor = m_nSmoothing;
-
- jpeg_set_quality(&cinfo, GetJpegQuality(), (dwCodecOptions & ENCODE_BASELINE) != 0);
-
-//#ifdef C_PROGRESSIVE_SUPPORTED
- if ((dwCodecOptions & ENCODE_PROGRESSIVE) != 0)
- jpeg_simple_progression(&cinfo);
-//#endif
-
-#ifdef C_LOSSLESS_SUPPORTED
- if ((dwCodecOptions & ENCODE_LOSSLESS) != 0)
- jpeg_simple_lossless(&cinfo, m_nPredictor, m_nPointTransform);
-#endif
-
- //SetCodecOption(ENCODE_SUBSAMPLE_444 | GetCodecOption(CXIMAGE_FORMAT_JPG),CXIMAGE_FORMAT_JPG);
-
- // 2x2, 1x1, 1x1 (4:1:1) : High (default sub sampling)
- cinfo.comp_info[0].h_samp_factor = 2;
- cinfo.comp_info[0].v_samp_factor = 2;
- cinfo.comp_info[1].h_samp_factor = 1;
- cinfo.comp_info[1].v_samp_factor = 1;
- cinfo.comp_info[2].h_samp_factor = 1;
- cinfo.comp_info[2].v_samp_factor = 1;
-
- if ((dwCodecOptions & ENCODE_SUBSAMPLE_422) != 0){
- // 2x1, 1x1, 1x1 (4:2:2) : Medium
- cinfo.comp_info[0].h_samp_factor = 2;
- cinfo.comp_info[0].v_samp_factor = 1;
- cinfo.comp_info[1].h_samp_factor = 1;
- cinfo.comp_info[1].v_samp_factor = 1;
- cinfo.comp_info[2].h_samp_factor = 1;
- cinfo.comp_info[2].v_samp_factor = 1;
- }
-
- if ((dwCodecOptions & ENCODE_SUBSAMPLE_444) != 0){
- // 1x1 1x1 1x1 (4:4:4) : None
- cinfo.comp_info[0].h_samp_factor = 1;
- cinfo.comp_info[0].v_samp_factor = 1;
- cinfo.comp_info[1].h_samp_factor = 1;
- cinfo.comp_info[1].v_samp_factor = 1;
- cinfo.comp_info[2].h_samp_factor = 1;
- cinfo.comp_info[2].v_samp_factor = 1;
- }
-
- cinfo.density_unit=1;
- cinfo.X_density=(uint16_t)GetXDPI();
- cinfo.Y_density=(uint16_t)GetYDPI();
-
- /* Step 4: Start compressor */
- /* TRUE ensures that we will write a complete interchange-JPEG file.
- * Pass TRUE unless you are very sure of what you're doing.
- */
- jpeg_start_compress(&cinfo, TRUE);
-
- /* Step 5: while (scan lines remain to be written) */
- /* jpeg_write_scanlines(...); */
- /* Here we use the library's state variable cinfo.next_scanline as the
- * loop counter, so that we don't have to keep track ourselves.
- * To keep things simple, we pass one scanline per call; you can pass
- * more if you wish, though.
- */
- row_stride = info.dwEffWidth; /* JSAMPLEs per row in image_buffer */
-
- //<DP> "8+row_stride" fix heap deallocation problem during debug???
- buffer = (*cinfo.mem->alloc_sarray)
- ((j_common_ptr) &cinfo, JPOOL_IMAGE, 8+row_stride, 1);
-
- CImageIterator iter(this);
-
- iter.Upset();
- while (cinfo.next_scanline < cinfo.image_height) {
- // info.nProgress = (int32_t)(100*cinfo.next_scanline/cinfo.image_height);
- iter.GetRow(buffer[0], row_stride);
- // not necessary if swapped red and blue definition in jmorecfg.h;ln322 <W. Morrison>
- if (head.biClrUsed==0){ // swap R & B for RGB images
- RGBtoBGR(buffer[0], row_stride); // Lance : 1998/09/01 : Bug ID: EXP-2.1.1-9
- }
- iter.PrevRow();
- (void) jpeg_write_scanlines(&cinfo, buffer, 1);
- }
-
- /* Step 6: Finish compression */
- jpeg_finish_compress(&cinfo);
-
- /* Step 7: release JPEG compression object */
- /* This is an important step since it will release a good deal of memory. */
- jpeg_destroy_compress(&cinfo);
-
-
-#if CXIMAGEJPG_SUPPORT_EXIF
- if (m_exif && m_exif->m_exifinfo->IsExif){
- // discard useless sections (if any) read from original image
- m_exif->DiscardAllButExif();
- // read new created image, to split the sections
- hFile->Seek(pos,SEEK_SET);
- m_exif->DecodeExif(hFile,EXIF_READ_IMAGE);
- // save back the image, adding EXIF section
- hFile->Seek(pos,SEEK_SET);
- m_exif->EncodeExif(hFile);
- }
-#endif
-
-
- /* And we're done! */
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_JPG
-
diff --git a/smelt/sdl/CxImage/ximajpg.h b/smelt/sdl/CxImage/ximajpg.h deleted file mode 100644 index 023bf61..0000000 --- a/smelt/sdl/CxImage/ximajpg.h +++ /dev/null @@ -1,283 +0,0 @@ -/*
- * File: ximajpg.h
- * Purpose: JPG Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImageJPG (c) 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- *
- * Special thanks to Troels Knakkergaard for new features, enhancements and bugfixes
- *
- * Special thanks to Chris Shearer Cooper for CxFileJpg tips & code
- *
- * EXIF support based on jhead-1.8 by Matthias Wandel <mwandel(at)rim(dot)net>
- *
- * original CImageJPG and CImageIterator implementation are:
- * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra(at)servidor(dot)unam(dot)mx>
- *
- * This software is based in part on the work of the Independent JPEG Group.
- * Copyright (C) 1991-1998, Thomas G. Lane.
- * ==========================================================
- */
-#if !defined(__ximaJPEG_h)
-#define __ximaJPEG_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_JPG
-
-#define CXIMAGEJPG_SUPPORT_EXIF CXIMAGE_SUPPORT_EXIF
-
-extern "C" {
-#ifdef _LINUX
- #include <jpeglib.h>
- #include <jerror.h>
-#else
- #include "jpeg/jpeglib.h"
- #include "jpeg/jerror.h"
-#endif
-}
-
-class DLL_EXP CxImageJPG: public CxImage
-{
-public:
- CxImageJPG();
- ~CxImageJPG();
-
-// bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_JPG);}
-// bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_JPG);}
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-
-/*
- * EXIF support based on jhead-1.8 by Matthias Wandel <mwandel(at)rim(dot)net>
- */
-
-#if CXIMAGEJPG_SUPPORT_EXIF
-
-//--------------------------------------------------------------------------
-// JPEG markers consist of one or more 0xFF bytes, followed by a marker
-// code byte (which is not an FF). Here are the marker codes of interest
-// in this program. (See jdmarker.c for a more complete list.)
-//--------------------------------------------------------------------------
-
-#define M_SOF0 0xC0 // Start Of Frame N
-#define M_SOF1 0xC1 // N indicates which compression process
-#define M_SOF2 0xC2 // Only SOF0-SOF2 are now in common use
-#define M_SOF3 0xC3
-#define M_SOF5 0xC5 // NB: codes C4 and CC are NOT SOF markers
-#define M_SOF6 0xC6
-#define M_SOF7 0xC7
-#define M_SOF9 0xC9
-#define M_SOF10 0xCA
-#define M_SOF11 0xCB
-#define M_SOF13 0xCD
-#define M_SOF14 0xCE
-#define M_SOF15 0xCF
-#define M_SOI 0xD8 // Start Of Image (beginning of datastream)
-#define M_EOI 0xD9 // End Of Image (end of datastream)
-#define M_SOS 0xDA // Start Of Scan (begins compressed data)
-#define M_JFIF 0xE0 // Jfif marker
-#define M_EXIF 0xE1 // Exif marker
-#define M_COM 0xFE // COMment
-
-#define PSEUDO_IMAGE_MARKER 0x123; // Extra value.
-
-#define EXIF_READ_EXIF 0x01
-#define EXIF_READ_IMAGE 0x02
-#define EXIF_READ_ALL 0x03
-
-class DLL_EXP CxExifInfo
-{
-
-typedef struct tag_Section_t{
- uint8_t* Data;
- int32_t Type;
- unsigned Size;
-} Section_t;
-
-public:
- EXIFINFO* m_exifinfo;
- char m_szLastError[256];
- CxExifInfo(EXIFINFO* info = NULL);
- ~CxExifInfo();
- bool DecodeExif(CxFile * hFile, int32_t nReadMode = EXIF_READ_EXIF);
- bool EncodeExif(CxFile * hFile);
- void DiscardAllButExif();
-protected:
- bool process_EXIF(uint8_t * CharBuf, uint32_t length);
- void process_COM (const uint8_t * Data, int32_t length);
- void process_SOFn (const uint8_t * Data, int32_t marker);
- int32_t Get16u(void * Short);
- int32_t Get16m(void * Short);
- int32_t Get32s(void * Long);
- uint32_t Get32u(void * Long);
- double ConvertAnyFormat(void * ValuePtr, int32_t Format);
- void* FindSection(int32_t SectionType);
- bool ProcessExifDir(uint8_t * DirStart, uint8_t * OffsetBase, unsigned ExifLength,
- EXIFINFO * const pInfo, uint8_t ** const LastExifRefdP, int32_t NestingLevel=0);
- int32_t ExifImageWidth;
- int32_t MotorolaOrder;
- Section_t Sections[MAX_SECTIONS];
- int32_t SectionsRead;
- bool freeinfo;
-};
-
- CxExifInfo* m_exif;
- bool DecodeExif(CxFile * hFile);
- bool DecodeExif(FILE * hFile) { CxIOFile file(hFile); return DecodeExif(&file); }
- bool GetExifThumbnail(const TCHAR *filename, const TCHAR *outname, int32_t type);
-
-#endif //CXIMAGEJPG_SUPPORT_EXIF
-
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////// C x F i l e J p g ////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-
-// thanks to Chris Shearer Cooper <cscooper(at)frii(dot)com>
-class CxFileJpg : public jpeg_destination_mgr, public jpeg_source_mgr
- {
-public:
- enum { eBufSize = 4096 };
-
- CxFileJpg(CxFile* pFile)
- {
- m_pFile = pFile;
-
- init_destination = InitDestination;
- empty_output_buffer = EmptyOutputBuffer;
- term_destination = TermDestination;
-
- init_source = InitSource;
- fill_input_buffer = FillInputBuffer;
- skip_input_data = SkipInputData;
- resync_to_restart = jpeg_resync_to_restart; // use default method
- term_source = TermSource;
- next_input_byte = NULL; //* => next byte to read from buffer
- bytes_in_buffer = 0; //* # of bytes remaining in buffer
-
- m_pBuffer = new uint8_t[eBufSize];
- }
- ~CxFileJpg()
- {
- delete [] m_pBuffer;
- }
-
- static void InitDestination(j_compress_ptr cinfo)
- {
- CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;
- pDest->next_output_byte = pDest->m_pBuffer;
- pDest->free_in_buffer = eBufSize;
- }
-
- static boolean EmptyOutputBuffer(j_compress_ptr cinfo)
- {
- CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;
- if (pDest->m_pFile->Write(pDest->m_pBuffer,1,eBufSize)!=(size_t)eBufSize)
- ERREXIT(cinfo, JERR_FILE_WRITE);
- pDest->next_output_byte = pDest->m_pBuffer;
- pDest->free_in_buffer = eBufSize;
- return TRUE;
- }
-
- static void TermDestination(j_compress_ptr cinfo)
- {
- CxFileJpg* pDest = (CxFileJpg*)cinfo->dest;
- size_t datacount = eBufSize - pDest->free_in_buffer;
- /* Write any data remaining in the buffer */
- if (datacount > 0) {
- if (!pDest->m_pFile->Write(pDest->m_pBuffer,1,datacount))
- ERREXIT(cinfo, JERR_FILE_WRITE);
- }
- pDest->m_pFile->Flush();
- /* Make sure we wrote the output file OK */
- if (pDest->m_pFile->Error()) ERREXIT(cinfo, JERR_FILE_WRITE);
- return;
- }
-
- static void InitSource(j_decompress_ptr cinfo)
- {
- CxFileJpg* pSource = (CxFileJpg*)cinfo->src;
- pSource->m_bStartOfFile = TRUE;
- }
-
- static boolean FillInputBuffer(j_decompress_ptr cinfo)
- {
- size_t nbytes;
- CxFileJpg* pSource = (CxFileJpg*)cinfo->src;
- nbytes = pSource->m_pFile->Read(pSource->m_pBuffer,1,eBufSize);
- if (nbytes <= 0){
- if (pSource->m_bStartOfFile) //* Treat empty input file as fatal error
- ERREXIT(cinfo, JERR_INPUT_EMPTY);
- WARNMS(cinfo, JWRN_JPEG_EOF);
- // Insert a fake EOI marker
- pSource->m_pBuffer[0] = (JOCTET) 0xFF;
- pSource->m_pBuffer[1] = (JOCTET) JPEG_EOI;
- nbytes = 2;
- }
- pSource->next_input_byte = pSource->m_pBuffer;
- pSource->bytes_in_buffer = nbytes;
- pSource->m_bStartOfFile = FALSE;
- return TRUE;
- }
-
- static void SkipInputData(j_decompress_ptr cinfo, long num_bytes)
- {
- CxFileJpg* pSource = (CxFileJpg*)cinfo->src;
- if (num_bytes > 0){
- while (num_bytes > (int32_t)pSource->bytes_in_buffer){
- num_bytes -= (int32_t)pSource->bytes_in_buffer;
- FillInputBuffer(cinfo);
- // note we assume that fill_input_buffer will never return FALSE,
- // so suspension need not be handled.
- }
- pSource->next_input_byte += (size_t) num_bytes;
- pSource->bytes_in_buffer -= (size_t) num_bytes;
- }
- }
-
- static void TermSource(j_decompress_ptr /*cinfo*/)
- {
- return;
- }
-protected:
- CxFile *m_pFile;
- uint8_t *m_pBuffer;
- bool m_bStartOfFile;
-};
-
-public:
- enum CODEC_OPTION
- {
- ENCODE_BASELINE = 0x1,
- ENCODE_ARITHMETIC = 0x2,
- ENCODE_GRAYSCALE = 0x4,
- ENCODE_OPTIMIZE = 0x8,
- ENCODE_PROGRESSIVE = 0x10,
- ENCODE_LOSSLESS = 0x20,
- ENCODE_SMOOTHING = 0x40,
- DECODE_GRAYSCALE = 0x80,
- DECODE_QUANTIZE = 0x100,
- DECODE_DITHER = 0x200,
- DECODE_ONEPASS = 0x400,
- DECODE_NOSMOOTH = 0x800,
- ENCODE_SUBSAMPLE_422 = 0x1000,
- ENCODE_SUBSAMPLE_444 = 0x2000
- };
-
- int32_t m_nPredictor;
- int32_t m_nPointTransform;
- int32_t m_nSmoothing;
- int32_t m_nQuantize;
- J_DITHER_MODE m_nDither;
-
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximalpha.cpp b/smelt/sdl/CxImage/ximalpha.cpp deleted file mode 100644 index 2932068..0000000 --- a/smelt/sdl/CxImage/ximalpha.cpp +++ /dev/null @@ -1,367 +0,0 @@ -// xImalpha.cpp : Alpha channel functions
-/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_ALPHA
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \sa AlphaSetMax
- */
-uint8_t CxImage::AlphaGetMax() const
-{
- return info.nAlphaMax;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets global Alpha (opacity) value applied to the whole image,
- * valid only for painting functions.
- * \param nAlphaMax: can be from 0 to 255
- */
-void CxImage::AlphaSetMax(uint8_t nAlphaMax)
-{
- info.nAlphaMax=nAlphaMax;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks if the image has a valid alpha channel.
- */
-bool CxImage::AlphaIsValid()
-{
- return pAlpha!=0;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Enables the alpha palette, so the Draw() function changes its behavior.
- */
-void CxImage::AlphaPaletteEnable(bool enable)
-{
- info.bAlphaPaletteEnabled=enable;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * True if the alpha palette is enabled for painting.
- */
-bool CxImage::AlphaPaletteIsEnabled()
-{
- return info.bAlphaPaletteEnabled;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets the alpha channel to full transparent. AlphaSet(0) has the same effect
- */
-void CxImage::AlphaClear()
-{
- if (pAlpha) memset(pAlpha,0,head.biWidth * head.biHeight);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets the alpha level for the whole image.
- * \param level : from 0 (transparent) to 255 (opaque)
- */
-void CxImage::AlphaSet(uint8_t level)
-{
- if (pAlpha) memset(pAlpha,level,head.biWidth * head.biHeight);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Allocates an empty (opaque) alpha channel.
- */
-bool CxImage::AlphaCreate()
-{
- if (pAlpha==NULL) {
- pAlpha = (uint8_t*)malloc(head.biWidth * head.biHeight);
- if (pAlpha) memset(pAlpha,255,head.biWidth * head.biHeight);
- }
- return (pAlpha!=0);
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::AlphaDelete()
-{
- if (pAlpha) { free(pAlpha); pAlpha=0; }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::AlphaInvert()
-{
- if (pAlpha) {
- uint8_t *iSrc=pAlpha;
- int32_t n=head.biHeight*head.biWidth;
- for(int32_t i=0; i < n; i++){
- *iSrc=(uint8_t)~(*(iSrc));
- iSrc++;
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Imports an existing alpa channel from another image with the same width and height.
- */
-bool CxImage::AlphaCopy(CxImage &from)
-{
- if (from.pAlpha == NULL || head.biWidth != from.head.biWidth || head.biHeight != from.head.biHeight) return false;
- if (pAlpha==NULL) pAlpha = (uint8_t*)malloc(head.biWidth * head.biHeight);
- if (pAlpha==NULL) return false;
- memcpy(pAlpha,from.pAlpha,head.biWidth * head.biHeight);
- info.nAlphaMax=from.info.nAlphaMax;
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Creates the alpha channel from a gray scale image.
- */
-bool CxImage::AlphaSet(CxImage &from)
-{
- if (!from.IsGrayScale() || head.biWidth != from.head.biWidth || head.biHeight != from.head.biHeight) return false;
- if (pAlpha==NULL) pAlpha = (uint8_t*)malloc(head.biWidth * head.biHeight);
- uint8_t* src = from.info.pImage;
- uint8_t* dst = pAlpha;
- if (src==NULL || dst==NULL) return false;
- for (int32_t y=0; y<head.biHeight; y++){
- memcpy(dst,src,head.biWidth);
- dst += head.biWidth;
- src += from.info.dwEffWidth;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets the alpha level for a single pixel
- */
-void CxImage::AlphaSet(const int32_t x,const int32_t y,const uint8_t level)
-{
- if (pAlpha && IsInside(x,y)) pAlpha[x+y*head.biWidth]=level;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the alpha level for a single pixel
- */
-uint8_t CxImage::AlphaGet(const int32_t x,const int32_t y)
-{
- if (pAlpha && IsInside(x,y)) return pAlpha[x+y*head.biWidth];
- return 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns pointer to alpha data for pixel (x,y).
- *
- * \author ***bd*** 2.2004
- */
-uint8_t* CxImage::AlphaGetPointer(const int32_t x,const int32_t y)
-{
- if (pAlpha && IsInside(x,y)) return pAlpha+x+y*head.biWidth;
- return 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Get alpha value without boundscheck (a bit faster). Pixel must be inside the image.
- *
- * \author ***bd*** 2.2004
- */
-uint8_t CxImage::BlindAlphaGet(const int32_t x,const int32_t y)
-{
-#ifdef _DEBUG
- if (!IsInside(x,y) || (pAlpha==0))
- #if CXIMAGE_SUPPORT_EXCEPTION_HANDLING
- throw 0;
- #else
- return 0;
- #endif
-#endif
- return pAlpha[x+y*head.biWidth];
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Resets the alpha palette
- */
-void CxImage::AlphaPaletteClear()
-{
- RGBQUAD c;
- for(uint16_t ip=0; ip<head.biClrUsed;ip++){
- c=GetPaletteColor((uint8_t)ip);
- c.rgbReserved=0;
- SetPaletteColor((uint8_t)ip,c);
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks if the image has a valid alpha palette.
- */
-bool CxImage::AlphaPaletteIsValid()
-{
- RGBQUAD c;
- for(uint16_t ip=0; ip<head.biClrUsed;ip++){
- c=GetPaletteColor((uint8_t)ip);
- if (c.rgbReserved != 0) return true;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Blends the alpha channel and the alpha palette with the pixels. The result is a 24 bit image.
- * The background color can be selected using SetTransColor().
- */
-void CxImage::AlphaStrip()
-{
- bool bAlphaPaletteIsValid = AlphaPaletteIsValid();
- bool bAlphaIsValid = AlphaIsValid();
- if (!(bAlphaIsValid || bAlphaPaletteIsValid)) return;
- RGBQUAD c;
- int32_t a, a1;
- if (head.biBitCount==24){
- for(int32_t y=0; y<head.biHeight; y++){
- for(int32_t x=0; x<head.biWidth; x++){
- c = BlindGetPixelColor(x,y);
- if (bAlphaIsValid) a=(BlindAlphaGet(x,y)*info.nAlphaMax)/255; else a=info.nAlphaMax;
- a1 = 256-a;
- c.rgbBlue = (uint8_t)((c.rgbBlue * a + a1 * info.nBkgndColor.rgbBlue)>>8);
- c.rgbGreen = (uint8_t)((c.rgbGreen * a + a1 * info.nBkgndColor.rgbGreen)>>8);
- c.rgbRed = (uint8_t)((c.rgbRed * a + a1 * info.nBkgndColor.rgbRed)>>8);
- BlindSetPixelColor(x,y,c);
- }
- }
- AlphaDelete();
- } else {
- CxImage tmp(head.biWidth,head.biHeight,24);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return;
- }
-
- for(int32_t y=0; y<head.biHeight; y++){
- for(int32_t x=0; x<head.biWidth; x++){
- c = BlindGetPixelColor(x,y);
- if (bAlphaIsValid) a=(BlindAlphaGet(x,y)*info.nAlphaMax)/255; else a=info.nAlphaMax;
- if (bAlphaPaletteIsValid) a=(c.rgbReserved*a)/255;
- a1 = 256-a;
- c.rgbBlue = (uint8_t)((c.rgbBlue * a + a1 * info.nBkgndColor.rgbBlue)>>8);
- c.rgbGreen = (uint8_t)((c.rgbGreen * a + a1 * info.nBkgndColor.rgbGreen)>>8);
- c.rgbRed = (uint8_t)((c.rgbRed * a + a1 * info.nBkgndColor.rgbRed)>>8);
- tmp.BlindSetPixelColor(x,y,c);
- }
- }
- Transfer(tmp);
- }
- return;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::AlphaFlip()
-{
- if (!pAlpha) return false;
-
- uint8_t *buff = (uint8_t*)malloc(head.biWidth);
- if (!buff) return false;
-
- uint8_t *iSrc,*iDst;
- iSrc = pAlpha + (head.biHeight-1)*head.biWidth;
- iDst = pAlpha;
- for (int32_t i=0; i<(head.biHeight/2); ++i)
- {
- memcpy(buff, iSrc, head.biWidth);
- memcpy(iSrc, iDst, head.biWidth);
- memcpy(iDst, buff, head.biWidth);
- iSrc-=head.biWidth;
- iDst+=head.biWidth;
- }
-
- free(buff);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::AlphaMirror()
-{
- if (!pAlpha) return false;
- uint8_t* pAlpha2 = (uint8_t*)malloc(head.biWidth * head.biHeight);
- if (!pAlpha2) return false;
- uint8_t *iSrc,*iDst;
- int32_t wdt=head.biWidth-1;
- iSrc=pAlpha + wdt;
- iDst=pAlpha2;
- for(int32_t y=0; y < head.biHeight; y++){
- for(int32_t x=0; x <= wdt; x++)
- *(iDst+x)=*(iSrc-x);
- iSrc+=head.biWidth;
- iDst+=head.biWidth;
- }
- free(pAlpha);
- pAlpha=pAlpha2;
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Exports the alpha channel in a 8bpp grayscale image.
- */
-bool CxImage::AlphaSplit(CxImage *dest)
-{
- if (!pAlpha || !dest) return false;
-
- CxImage tmp(head.biWidth,head.biHeight,8);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- uint8_t* src = pAlpha;
- uint8_t* dst = tmp.info.pImage;
- for (int32_t y=0; y<head.biHeight; y++){
- memcpy(dst,src,head.biWidth);
- dst += tmp.info.dwEffWidth;
- src += head.biWidth;
- }
-
- tmp.SetGrayPalette();
- dest->Transfer(tmp);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Exports the alpha palette channel in a 8bpp grayscale image.
- */
-bool CxImage::AlphaPaletteSplit(CxImage *dest)
-{
- if (!AlphaPaletteIsValid() || !dest) return false;
-
- CxImage tmp(head.biWidth,head.biHeight,8);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- for(int32_t y=0; y<head.biHeight; y++){
- for(int32_t x=0; x<head.biWidth; x++){
- tmp.BlindSetPixelIndex(x,y,BlindGetPixelColor(x,y).rgbReserved);
- }
- }
-
- tmp.SetGrayPalette();
- dest->Transfer(tmp);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Merge in the alpha layer the transparent color mask
- * (previously set with SetTransColor or SetTransIndex)
- */
-bool CxImage::AlphaFromTransparency()
-{
- if (!IsValid() || !IsTransparent())
- return false;
-
- AlphaCreate();
-
- for(int32_t y=0; y<head.biHeight; y++){
- for(int32_t x=0; x<head.biWidth; x++){
- if (IsTransparent(x,y)){
- AlphaSet(x,y,0);
- }
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_ALPHA
diff --git a/smelt/sdl/CxImage/ximalyr.cpp b/smelt/sdl/CxImage/ximalyr.cpp deleted file mode 100644 index 23dc226..0000000 --- a/smelt/sdl/CxImage/ximalyr.cpp +++ /dev/null @@ -1,116 +0,0 @@ -// xImaLyr.cpp : Layers functions
-/* 21/04/2003 v1.00 - Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_LAYERS
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * If the object is an internal layer, GetParent return its parent in the hierarchy.
- */
-CxImage* CxImage::GetParent() const
-{
- return info.pParent;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Number of layers allocated directly by the object.
- */
-int32_t CxImage::GetNumLayers() const
-{
- return info.nNumLayers;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Creates an empty layer. If position is less than 0, the new layer will be placed in the last position
- */
-bool CxImage::LayerCreate(int32_t position)
-{
- if ( position < 0 || position > info.nNumLayers ) position = info.nNumLayers;
-
- CxImage** ptmp = new CxImage*[info.nNumLayers + 1];
- if (ptmp==0) return false;
-
- int32_t i=0;
- for (int32_t n=0; n<info.nNumLayers; n++){
- if (position == n){
- ptmp[n] = new CxImage();
- i=1;
- }
- ptmp[n+i]=ppLayers[n];
- }
- if (i==0) ptmp[info.nNumLayers] = new CxImage();
-
- if (ptmp[position]){
- ptmp[position]->info.pParent = this;
- } else {
- free(ptmp);
- return false;
- }
-
- info.nNumLayers++;
- delete [] ppLayers;
- ppLayers = ptmp;
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Deletes a layer. If position is less than 0, the last layer will be deleted
- */
-bool CxImage::LayerDelete(int32_t position)
-{
- if ( position >= info.nNumLayers ) return false;
- if ( position < 0) position = info.nNumLayers - 1;
- if ( position < 0) return false;
-
- if (info.nNumLayers>1){
-
- CxImage** ptmp = new CxImage*[info.nNumLayers - 1];
- if (ptmp==0) return false;
-
- int32_t i=0;
- for (int32_t n=0; n<info.nNumLayers; n++){
- if (position == n){
- delete ppLayers[n];
- i=1;
- }
- ptmp[n]=ppLayers[n+i];
- }
-
- info.nNumLayers--;
- delete [] ppLayers;
- ppLayers = ptmp;
-
- } else {
- delete ppLayers[0];
- delete [] ppLayers;
- ppLayers = 0;
- info.nNumLayers = 0;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::LayerDeleteAll()
-{
- if (ppLayers) {
- for(int32_t n=0; n<info.nNumLayers;n++){ delete ppLayers[n]; }
- delete [] ppLayers; ppLayers=0; info.nNumLayers = 0;
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns a pointer to a layer. If position is less than 0, the last layer will be returned
- */
-CxImage* CxImage::GetLayer(int32_t position)
-{
- if ( ppLayers == NULL) return NULL;
- if ( info.nNumLayers == 0) return NULL;
- if ( position >= info.nNumLayers ) return NULL;
- if ( position < 0) position = info.nNumLayers - 1;
- return ppLayers[position];
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_LAYERS
diff --git a/smelt/sdl/CxImage/ximamng.cpp b/smelt/sdl/CxImage/ximamng.cpp deleted file mode 100644 index d5ea82e..0000000 --- a/smelt/sdl/CxImage/ximamng.cpp +++ /dev/null @@ -1,430 +0,0 @@ -/*
- * File: ximamng.cpp
- * Purpose: Platform Independent MNG Image Class Loader and Writer
- * Author: 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximamng.h"
-
-#if CXIMAGE_SUPPORT_MNG
-
-////////////////////////////////////////////////////////////////////////////////
-// callbacks for the mng decoder:
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// memory allocation; data must be zeroed
-static mng_ptr
-mymngalloc( mng_size_t size )
-{
- return (mng_ptr)calloc(1, size);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// memory deallocation
-static void mymngfree(mng_ptr p, mng_size_t size)
-{
- free(p);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Stream open/close:
-// since the user is responsible for opening and closing the file,
-// we leave the default implementation open
-static mng_bool mymngopenstream(mng_handle mng) { return MNG_TRUE; }
-static mng_bool mymngopenstreamwrite(mng_handle mng) { return MNG_TRUE; }
-static mng_bool mymngclosestream(mng_handle mng) { return MNG_TRUE; }
-
-////////////////////////////////////////////////////////////////////////////////
-// feed data to the decoder
-static mng_bool mymngreadstream(mng_handle mng, mng_ptr buffer, mng_uint32 size, mng_uint32 *bytesread)
-{
- mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
- // read the requested amount of data from the file
- *bytesread = mymng->file->Read( buffer, sizeof(uint8_t), size);
- return MNG_TRUE;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-static mng_bool mymngwritestream (mng_handle mng, mng_ptr pBuf, mng_uint32 iSize, mng_uint32 *iWritten)
-{
- mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
- // write it
- *iWritten = mymng->file->Write (pBuf, 1, iSize);
- return MNG_TRUE;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// the header's been read. set up the display stuff
-static mng_bool mymngprocessheader( mng_handle mng, mng_uint32 width, mng_uint32 height )
-{
- // normally the image buffer is allocated here,
- // but in this module we don't know nothing about
- // the final environment.
-
- mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
-
- mymng->width = width;
- mymng->height = height;
- mymng->bpp = 24;
- mymng->effwdt = ((((width * mymng->bpp) + 31) >> 5) << 2);
-
- if (mng->bUseBKGD){
- mymng->nBkgndIndex = 0;
- mymng->nBkgndColor.rgbRed = mng->iBGred >> 8;
- mymng->nBkgndColor.rgbGreen =mng->iBGgreen >> 8;
- mymng->nBkgndColor.rgbBlue = mng->iBGblue >> 8;
- }
-
- mymng->image = (uint8_t*)malloc(height * mymng->effwdt);
-
- // tell the mng decoder about our bit-depth choice
-#if CXIMAGE_SUPPORT_ALPHA
- mng_set_canvasstyle( mng, MNG_CANVAS_RGB8_A8 );
- mymng->alpha = (uint8_t*)malloc(height * width);
-#else
- mng_set_canvasstyle( mng, MNG_CANVAS_BGR8);
- mymng->alpha = NULL;
-#endif
- return MNG_TRUE;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// return a row pointer for the decoder to fill
-static mng_ptr mymnggetcanvasline( mng_handle mng, mng_uint32 line )
-{
- mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
- return (mng_ptr)(mymng->image + (mymng->effwdt * (mymng->height - 1 - line)));
-}
-////////////////////////////////////////////////////////////////////////////////
-// return a row pointer for the decoder to fill for alpha channel
-static mng_ptr mymnggetalphaline( mng_handle mng, mng_uint32 line )
-{
- mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
- return (mng_ptr)(mymng->alpha + (mymng->width * (mymng->height - 1 - line)));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// timer
-static mng_uint32 mymnggetticks(mng_handle mng)
-{
-#ifdef WIN32
- return (mng_uint32)GetTickCount();
-#else
- return 0;
-#endif
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Refresh: actual frame need to be updated (Invalidate)
-static mng_bool mymngrefresh(mng_handle mng, mng_uint32 x, mng_uint32 y, mng_uint32 w, mng_uint32 h)
-{
-// mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
- return MNG_TRUE;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// interframe delay callback
-static mng_bool mymngsettimer(mng_handle mng, mng_uint32 msecs)
-{
- mngstuff *mymng = (mngstuff *)mng_get_userdata(mng);
- mymng->delay = msecs; // set the timer for when the decoder wants to be woken
- return MNG_TRUE;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-static mng_bool mymngerror(mng_handle mng, mng_int32 code, mng_int8 severity, mng_chunkid chunktype, mng_uint32 chunkseq, mng_int32 extra1, mng_int32 extra2, mng_pchar text)
-{
- return mng_cleanup(&mng); //<Arkadiy Olovyannikov>
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// CxImage members
-////////////////////////////////////////////////////////////////////////////////
-CxImageMNG::CxImageMNG(): CxImage(CXIMAGE_FORMAT_MNG)
-{
- hmng = NULL;
- memset(&mnginfo,0,sizeof(mngstuff));
- mnginfo.nBkgndIndex = -1;
- mnginfo.speed = 1.0f;
-}
-////////////////////////////////////////////////////////////////////////////////
-CxImageMNG::~CxImageMNG()
-{
- // cleanup and return
- if (mnginfo.thread){ //close the animation thread
- mnginfo.animation_enabled=0;
- ResumeThread(mnginfo.thread);
- WaitForSingleObject(mnginfo.thread,500);
- CloseHandle(mnginfo.thread);
- }
- // free objects
- if (mnginfo.image) free(mnginfo.image);
- if (mnginfo.alpha) free(mnginfo.alpha);
- if (hmng) mng_cleanup(&hmng); //be sure it's not needed any more. (active timers ?)
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageMNG::SetCallbacks(mng_handle mng)
-{
- // set the callbacks
- mng_setcb_errorproc(mng, mymngerror);
- mng_setcb_openstream(mng, mymngopenstream);
- mng_setcb_closestream(mng, mymngclosestream);
- mng_setcb_readdata(mng, mymngreadstream);
- mng_setcb_processheader(mng, mymngprocessheader);
- mng_setcb_getcanvasline(mng, mymnggetcanvasline);
- mng_setcb_refresh(mng, mymngrefresh);
- mng_setcb_gettickcount(mng, mymnggetticks);
- mng_setcb_settimer(mng, mymngsettimer);
- mng_setcb_refresh(mng, mymngrefresh);
- mng_setcb_getalphaline(mng, mymnggetalphaline);
-}
-////////////////////////////////////////////////////////////////////////////////
-// can't use the CxImage implementation because it looses mnginfo
-bool CxImageMNG::Load(const TCHAR * imageFileName){
- FILE* hFile; //file handle to read the image
-#ifdef WIN32
- if ((hFile=_tfopen(imageFileName,_T("rb")))==NULL) return false; // For UNICODE support
-#else
- if ((hFile=fopen(imageFileName,"rb"))==NULL) return false;
-#endif
- bool bOK = Decode(hFile);
- fclose(hFile);
- return bOK;
-}
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageMNG::Decode(CxFile *hFile)
-{
- if (hFile == NULL) return false;
-
- cx_try
- {
- // set up the mng decoder for our stream
- hmng = mng_initialize(&mnginfo, (mng_memalloc)mymngalloc, (mng_memfree)mymngfree, MNG_NULL);
- if (hmng == NULL) cx_throw("could not initialize libmng");
-
- // set the file we want to play
- mnginfo.file = hFile;
-
- // Set the colorprofile, lcms uses this:
- mng_set_srgb(hmng, MNG_TRUE );
- // Set white as background color:
- uint16_t Red,Green,Blue;
- Red = Green = Blue = (255 << 8) + 255;
- mng_set_bgcolor(hmng, Red, Green, Blue );
- // If PNG Background is available, use it:
- mng_set_usebkgd(hmng, MNG_TRUE );
-
- // No need to store chunks:
- mng_set_storechunks(hmng, MNG_FALSE);
- // No need to wait: straight reading
- mng_set_suspensionmode(hmng, MNG_FALSE);
-
- SetCallbacks(hmng);
-
- mng_datap pData = (mng_datap)hmng;
-
- // read in the image
- info.nNumFrames=0;
- int32_t retval=MNG_NOERROR;
-
- retval = mng_readdisplay(hmng);
-
- if (retval != MNG_NOERROR && retval != MNG_NEEDTIMERWAIT){
- mng_store_error(hmng,retval,0,0);
- if (hmng->zErrortext){
- cx_throw(hmng->zErrortext);
- } else {
- cx_throw("Error in MNG file");
- }
- }
-
- if (info.nEscape == -1) {
- // Return output dimensions only
- head.biWidth = hmng->iWidth;
- head.biHeight = hmng->iHeight;
- info.dwType = CXIMAGE_FORMAT_MNG;
- return true;
- }
-
- // read all
- while(pData->bReading){
- retval = mng_display_resume(hmng);
- info.nNumFrames++;
- }
-
- // single frame check:
- if (retval != MNG_NEEDTIMERWAIT){
- info.nNumFrames--;
- } else {
- mnginfo.animation=1;
- }
-
- if (info.nNumFrames<=0) info.nNumFrames=1;
-
- if (mnginfo.animation_enabled==0){
- // select the frame
- if (info.nFrame>=0 && info.nFrame<info.nNumFrames){
- for (int32_t n=0;n<info.nFrame;n++) mng_display_resume(hmng);
- } else cx_throw("Error: frame not present in MNG file");
- }
-
- if (mnginfo.nBkgndIndex >= 0){
- info.nBkgndIndex = mnginfo.nBkgndIndex;
- info.nBkgndColor.rgbRed = mnginfo.nBkgndColor.rgbRed;
- info.nBkgndColor.rgbGreen = mnginfo.nBkgndColor.rgbGreen;
- info.nBkgndColor.rgbBlue = mnginfo.nBkgndColor.rgbBlue;
- }
-
- //store the newly created image
- if (Create(mnginfo.width,mnginfo.height,mnginfo.bpp, CXIMAGE_FORMAT_MNG)){
- memcpy(GetBits(), mnginfo.image, info.dwEffWidth * head.biHeight);
-#if CXIMAGE_SUPPORT_ALPHA
- SwapRGB2BGR();
- AlphaCreate();
- if(AlphaIsValid() && mnginfo.alpha){
- memcpy(AlphaGetPointer(),mnginfo.alpha,mnginfo.width * mnginfo.height);
- }
-#endif
- } else cx_throw("CxImageMNG::Decode cannot create image");
-
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- return false;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageMNG::Encode(CxFile *hFile)
-{
- if (EncodeSafeCheck(hFile)) return false;
-
- cx_try
- {
- if (head.biClrUsed != 0) cx_throw("MNG encoder can save only RGB images");
- // set the file we want to play
- mnginfo.file = hFile;
- mnginfo.bpp = head.biBitCount;
- mnginfo.effwdt = info.dwEffWidth;
- mnginfo.height = head.biHeight;
- mnginfo.width = head.biWidth;
-
- mnginfo.image = (uint8_t*)malloc(head.biSizeImage);
- if (mnginfo.image == NULL) cx_throw("could not allocate memory for MNG");
- memcpy(mnginfo.image,info.pImage, head.biSizeImage);
-
- // set up the mng decoder for our stream
- hmng = mng_initialize(&mnginfo, (mng_memalloc)mymngalloc, (mng_memfree)mymngfree, MNG_NULL);
- if (hmng == NULL) cx_throw("could not initialize libmng");
-
- mng_setcb_openstream(hmng, mymngopenstreamwrite );
- mng_setcb_closestream(hmng, mymngclosestream);
- mng_setcb_writedata(hmng, mymngwritestream);
-
- // Write File:
- mng_create(hmng);
- // Just a single Frame (save a normal PNG):
- WritePNG(hmng, 0, 1 );
- // Now write file:
- mng_write(hmng);
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- return false;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-// Writes a single PNG datastream
-void CxImageMNG::WritePNG( mng_handle hMNG, int32_t Frame, int32_t FrameCount )
-{
- mngstuff *mymng = (mngstuff *)mng_get_userdata(hMNG);
-
- int32_t OffsetX=0,OffsetY=0,OffsetW=mymng->width,OffsetH=mymng->height;
-
- uint8_t *tmpbuffer = new uint8_t[ (mymng->effwdt+1) * mymng->height];
- if( tmpbuffer == 0 ) return;
-
- // Write DEFI chunk.
- mng_putchunk_defi( hMNG, 0, 0, 0, MNG_TRUE, OffsetX, OffsetY, MNG_FALSE, 0, 0, 0, 0 );
-
- // Write Header:
- mng_putchunk_ihdr(
- hMNG,
- OffsetW, OffsetH,
- MNG_BITDEPTH_8,
- MNG_COLORTYPE_RGB,
- MNG_COMPRESSION_DEFLATE,
- MNG_FILTER_ADAPTIVE,
- MNG_INTERLACE_NONE
- );
-
- // transfer data, add Filterbyte:
- for( int32_t Row=0; Row<OffsetH; Row++ ){
- // First Byte in each Scanline is Filterbyte: Currently 0 -> No Filter.
- tmpbuffer[Row*(mymng->effwdt+1)]=0;
- // Copy the scanline: (reverse order)
- memcpy(tmpbuffer+Row*(mymng->effwdt+1)+1,
- mymng->image+((OffsetH-1-(OffsetY+Row))*(mymng->effwdt))+OffsetX,mymng->effwdt);
- // swap red and blue components
- RGBtoBGR(tmpbuffer+Row*(mymng->effwdt+1)+1,mymng->effwdt);
- }
-
- // Compress data with ZLib (Deflate):
- uint8_t *dstbuffer = new uint8_t[(mymng->effwdt+1)*OffsetH];
- if( dstbuffer == 0 ) return;
- uint32_t dstbufferSize=(mymng->effwdt+1)*OffsetH;
-
- // Compress data:
- if(Z_OK != compress2((Bytef *)dstbuffer,(ULONG *)&dstbufferSize,(const Bytef*)tmpbuffer,
- (ULONG) (mymng->effwdt+1)*OffsetH,9 )) return;
-
- // Write Data into MNG File:
- mng_putchunk_idat( hMNG, dstbufferSize, (mng_ptr*)dstbuffer);
- mng_putchunk_iend(hMNG);
-
- // Free the stuff:
- delete [] tmpbuffer;
- delete [] dstbuffer;
-}
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImageMNG::Resume()
-{
- if (MNG_NEEDTIMERWAIT == mng_display_resume(hmng)){
- if (info.pImage==NULL){
- Create(mnginfo.width,mnginfo.height,mnginfo.bpp, CXIMAGE_FORMAT_MNG);
- }
- if (IsValid()){
- memcpy(GetBits(), mnginfo.image, info.dwEffWidth * head.biHeight);
-#if CXIMAGE_SUPPORT_ALPHA
- SwapRGB2BGR();
- AlphaCreate();
- if(AlphaIsValid() && mnginfo.alpha){
- memcpy(AlphaGetPointer(),mnginfo.alpha,mnginfo.width * mnginfo.height);
- }
-#endif
- }
- } else {
- mnginfo.animation_enabled = 0;
- }
- return mnginfo.animation_enabled;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageMNG::SetSpeed(float speed)
-{
- if (speed>10.0) mnginfo.speed = 10.0f;
- else if (speed<0.1) mnginfo.speed = 0.1f;
- else mnginfo.speed=speed;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_MNG
diff --git a/smelt/sdl/CxImage/ximamng.h b/smelt/sdl/CxImage/ximamng.h deleted file mode 100644 index 9466fc2..0000000 --- a/smelt/sdl/CxImage/ximamng.h +++ /dev/null @@ -1,88 +0,0 @@ -/*
- * File: ximamng.h
- * Purpose: Declaration of the MNG Image Class
- * Author: Davide Pizzolato - www.xdp.it
- * Created: 2001
- */
-/* ==========================================================
- * CxImageMNG (c) 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- *
- * Special thanks to Frank Haug <f.haug(at)jdm(dot)de> for suggestions and code.
- *
- * original mng.cpp code created by Nikolaus Brennig, November 14th, 2000. <virtualnik(at)nol(dot)at>
- *
- * LIBMNG Copyright (c) 2000,2001 Gerard Juyn (gerard@libmng.com)
- * ==========================================================
- */
-
-#if !defined(__ximaMNG_h)
-#define __ximaMNG_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_MNG
-
-//#define MNG_NO_CMS
-#define MNG_SUPPORT_DISPLAY
-#define MNG_SUPPORT_READ
-#define MNG_SUPPORT_WRITE
-#define MNG_ACCESS_CHUNKS
-#define MNG_STORE_CHUNKS
-
-extern "C" {
-#include "../mng/libmng.h"
-#include "../mng/libmng_data.h"
-#include "../mng/libmng_error.h"
-}
-
-//uint32_t _stdcall RunMNGThread(void *lpParam);
-
-typedef struct tagmngstuff
-{
- CxFile *file;
- uint8_t *image;
- uint8_t *alpha;
- HANDLE thread;
- mng_uint32 delay;
- mng_uint32 width;
- mng_uint32 height;
- mng_uint32 effwdt;
- mng_int16 bpp;
- mng_bool animation;
- mng_bool animation_enabled;
- float speed;
- int32_t nBkgndIndex;
- RGBQUAD nBkgndColor;
-} mngstuff;
-
-class CxImageMNG: public CxImage
-{
-public:
- CxImageMNG();
- ~CxImageMNG();
-
- bool Load(const TCHAR * imageFileName);
-
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
- bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_MNG);}
-#endif // CXIMAGE_SUPPORT_ENCODE
-
- int32_t Resume();
- void SetSpeed(float speed);
-
- mng_handle hmng;
- mngstuff mnginfo;
-protected:
- void WritePNG(mng_handle hMNG, int32_t Frame, int32_t FrameCount );
- void SetCallbacks(mng_handle mng);
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximapal.cpp b/smelt/sdl/CxImage/ximapal.cpp deleted file mode 100644 index fe0615b..0000000 --- a/smelt/sdl/CxImage/ximapal.cpp +++ /dev/null @@ -1,834 +0,0 @@ -// xImaPal.cpp : Palette and Pixel functions
-/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximage.h"
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * returns the palette dimension in byte
- */
-uint32_t CxImage::GetPaletteSize()
-{
- return (head.biClrUsed * sizeof(RGBQUAD));
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::SetPaletteColor(uint8_t idx, uint8_t r, uint8_t g, uint8_t b, uint8_t alpha)
-{
- if ((pDib)&&(head.biClrUsed)){
- uint8_t* iDst = (uint8_t*)(pDib) + sizeof(BITMAPINFOHEADER);
- if (idx<head.biClrUsed){
- int32_t ldx=idx*sizeof(RGBQUAD);
- iDst[ldx++] = (uint8_t) b;
- iDst[ldx++] = (uint8_t) g;
- iDst[ldx++] = (uint8_t) r;
- iDst[ldx] = (uint8_t) alpha;
- info.last_c_isvalid = false;
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::SetPaletteColor(uint8_t idx, RGBQUAD c)
-{
- if ((pDib)&&(head.biClrUsed)){
- uint8_t* iDst = (uint8_t*)(pDib) + sizeof(BITMAPINFOHEADER);
- if (idx<head.biClrUsed){
- int32_t ldx=idx*sizeof(RGBQUAD);
- iDst[ldx++] = (uint8_t) c.rgbBlue;
- iDst[ldx++] = (uint8_t) c.rgbGreen;
- iDst[ldx++] = (uint8_t) c.rgbRed;
- iDst[ldx] = (uint8_t) c.rgbReserved;
- info.last_c_isvalid = false;
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::SetPaletteColor(uint8_t idx, COLORREF cr)
-{
- if ((pDib)&&(head.biClrUsed)){
- uint8_t* iDst = (uint8_t*)(pDib) + sizeof(BITMAPINFOHEADER);
- if (idx<head.biClrUsed){
- int32_t ldx=idx*sizeof(RGBQUAD);
- iDst[ldx++] = (uint8_t) GetBValue(cr);
- iDst[ldx++] = (uint8_t) GetGValue(cr);
- iDst[ldx++] = (uint8_t) GetRValue(cr);
- iDst[ldx] = (uint8_t) 0;
- info.last_c_isvalid = false;
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * returns the pointer to the first palette index
- */
-RGBQUAD* CxImage::GetPalette() const
-{
- if ((pDib)&&(head.biClrUsed))
- return (RGBQUAD*)((uint8_t*)pDib + sizeof(BITMAPINFOHEADER));
- return NULL;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns the color of the specified index.
- */
-RGBQUAD CxImage::GetPaletteColor(uint8_t idx)
-{
- RGBQUAD rgb = {0,0,0,0};
- if ((pDib)&&(head.biClrUsed)){
- uint8_t* iDst = (uint8_t*)(pDib) + sizeof(BITMAPINFOHEADER);
- if (idx<head.biClrUsed){
- int32_t ldx=idx*sizeof(RGBQUAD);
- rgb.rgbBlue = iDst[ldx++];
- rgb.rgbGreen=iDst[ldx++];
- rgb.rgbRed =iDst[ldx++];
- rgb.rgbReserved = iDst[ldx];
- }
- }
- return rgb;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns the palette index of the specified pixel.
- */
-uint8_t CxImage::GetPixelIndex(int32_t x,int32_t y)
-{
- if ((pDib==NULL)||(head.biClrUsed==0)) return 0;
-
- if ((x<0)||(y<0)||(x>=head.biWidth)||(y>=head.biHeight)) {
- if (info.nBkgndIndex >= 0) return (uint8_t)info.nBkgndIndex;
- else return *info.pImage;
- }
- if (head.biBitCount==8){
- return info.pImage[y*info.dwEffWidth + x];
- } else {
- uint8_t pos;
- uint8_t iDst= info.pImage[y*info.dwEffWidth + (x*head.biBitCount >> 3)];
- if (head.biBitCount==4){
- pos = (uint8_t)(4*(1-x%2));
- iDst &= (0x0F<<pos);
- return (uint8_t)(iDst >> pos);
- } else if (head.biBitCount==1){
- pos = (uint8_t)(7-x%8);
- iDst &= (0x01<<pos);
- return (uint8_t)(iDst >> pos);
- }
- }
- return 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-uint8_t CxImage::BlindGetPixelIndex(const int32_t x,const int32_t y)
-{
-#ifdef _DEBUG
- if ((pDib==NULL) || (head.biClrUsed==0) || !IsInside(x,y))
- #if CXIMAGE_SUPPORT_EXCEPTION_HANDLING
- throw 0;
- #else
- return 0;
- #endif
-#endif
-
- if (head.biBitCount==8){
- return info.pImage[y*info.dwEffWidth + x];
- } else {
- uint8_t pos;
- uint8_t iDst= info.pImage[y*info.dwEffWidth + (x*head.biBitCount >> 3)];
- if (head.biBitCount==4){
- pos = (uint8_t)(4*(1-x%2));
- iDst &= (0x0F<<pos);
- return (uint8_t)(iDst >> pos);
- } else if (head.biBitCount==1){
- pos = (uint8_t)(7-x%8);
- iDst &= (0x01<<pos);
- return (uint8_t)(iDst >> pos);
- }
- }
- return 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-RGBQUAD CxImage::GetPixelColor(int32_t x,int32_t y, bool bGetAlpha)
-{
-// RGBQUAD rgb={0,0,0,0};
- RGBQUAD rgb=info.nBkgndColor; //<mpwolski>
- if ((pDib==NULL)||(x<0)||(y<0)||
- (x>=head.biWidth)||(y>=head.biHeight)){
- if (info.nBkgndIndex >= 0){
- if (head.biBitCount<24) return GetPaletteColor((uint8_t)info.nBkgndIndex);
- else return info.nBkgndColor;
- } else if (pDib) return GetPixelColor(0,0);
- return rgb;
- }
-
- if (head.biClrUsed){
- rgb = GetPaletteColor(BlindGetPixelIndex(x,y));
- } else {
- uint8_t* iDst = info.pImage + y*info.dwEffWidth + x*3;
- rgb.rgbBlue = *iDst++;
- rgb.rgbGreen= *iDst++;
- rgb.rgbRed = *iDst;
- }
-#if CXIMAGE_SUPPORT_ALPHA
- if (pAlpha && bGetAlpha) rgb.rgbReserved = BlindAlphaGet(x,y);
-#else
- rgb.rgbReserved = 0;
-#endif //CXIMAGE_SUPPORT_ALPHA
- return rgb;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * This is (a bit) faster version of GetPixelColor.
- * It tests bounds only in debug mode (_DEBUG defined).
- *
- * It is an error to request out-of-borders pixel with this method.
- * In DEBUG mode an exception will be thrown, and data will be violated in non-DEBUG mode.
- * \author ***bd*** 2.2004
- */
-RGBQUAD CxImage::BlindGetPixelColor(const int32_t x,const int32_t y, bool bGetAlpha)
-{
- RGBQUAD rgb;
-#ifdef _DEBUG
- if ((pDib==NULL) || !IsInside(x,y))
- #if CXIMAGE_SUPPORT_EXCEPTION_HANDLING
- throw 0;
- #else
- {rgb.rgbReserved = 0; return rgb;}
- #endif
-#endif
-
- if (head.biClrUsed){
- rgb = GetPaletteColor(BlindGetPixelIndex(x,y));
- } else {
- uint8_t* iDst = info.pImage + y*info.dwEffWidth + x*3;
- rgb.rgbBlue = *iDst++;
- rgb.rgbGreen= *iDst++;
- rgb.rgbRed = *iDst;
- rgb.rgbReserved = 0; //needed for images without alpha layer
- }
-#if CXIMAGE_SUPPORT_ALPHA
- if (pAlpha && bGetAlpha) rgb.rgbReserved = BlindAlphaGet(x,y);
-#else
- rgb.rgbReserved = 0;
-#endif //CXIMAGE_SUPPORT_ALPHA
- return rgb;
-}
-////////////////////////////////////////////////////////////////////////////////
-uint8_t CxImage::GetPixelGray(int32_t x, int32_t y)
-{
- RGBQUAD color = GetPixelColor(x,y);
- return (uint8_t)RGB2GRAY(color.rgbRed,color.rgbGreen,color.rgbBlue);
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::BlindSetPixelIndex(int32_t x,int32_t y,uint8_t i)
-{
-#ifdef _DEBUG
- if ((pDib==NULL)||(head.biClrUsed==0)||
- (x<0)||(y<0)||(x>=head.biWidth)||(y>=head.biHeight))
- #if CXIMAGE_SUPPORT_EXCEPTION_HANDLING
- throw 0;
- #else
- return;
- #endif
-#endif
-
- if (head.biBitCount==8){
- info.pImage[y*info.dwEffWidth + x]=i;
- return;
- } else {
- uint8_t pos;
- uint8_t* iDst= info.pImage + y*info.dwEffWidth + (x*head.biBitCount >> 3);
- if (head.biBitCount==4){
- pos = (uint8_t)(4*(1-x%2));
- *iDst &= ~(0x0F<<pos);
- *iDst |= ((i & 0x0F)<<pos);
- return;
- } else if (head.biBitCount==1){
- pos = (uint8_t)(7-x%8);
- *iDst &= ~(0x01<<pos);
- *iDst |= ((i & 0x01)<<pos);
- return;
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::SetPixelIndex(int32_t x,int32_t y,uint8_t i)
-{
- if ((pDib==NULL)||(head.biClrUsed==0)||
- (x<0)||(y<0)||(x>=head.biWidth)||(y>=head.biHeight)) return ;
-
- if (head.biBitCount==8){
- info.pImage[y*info.dwEffWidth + x]=i;
- return;
- } else {
- uint8_t pos;
- uint8_t* iDst= info.pImage + y*info.dwEffWidth + (x*head.biBitCount >> 3);
- if (head.biBitCount==4){
- pos = (uint8_t)(4*(1-x%2));
- *iDst &= ~(0x0F<<pos);
- *iDst |= ((i & 0x0F)<<pos);
- return;
- } else if (head.biBitCount==1){
- pos = (uint8_t)(7-x%8);
- *iDst &= ~(0x01<<pos);
- *iDst |= ((i & 0x01)<<pos);
- return;
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::SetPixelColor(int32_t x,int32_t y,COLORREF cr)
-{
- SetPixelColor(x,y,RGBtoRGBQUAD(cr));
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::BlindSetPixelColor(int32_t x,int32_t y,RGBQUAD c, bool bSetAlpha)
-{
-#ifdef _DEBUG
- if ((pDib==NULL)||(x<0)||(y<0)||
- (x>=head.biWidth)||(y>=head.biHeight))
- #if CXIMAGE_SUPPORT_EXCEPTION_HANDLING
- throw 0;
- #else
- return;
- #endif
-#endif
- if (head.biClrUsed)
- BlindSetPixelIndex(x,y,GetNearestIndex(c));
- else {
- uint8_t* iDst = info.pImage + y*info.dwEffWidth + x*3;
- *iDst++ = c.rgbBlue;
- *iDst++ = c.rgbGreen;
- *iDst = c.rgbRed;
- }
-#if CXIMAGE_SUPPORT_ALPHA
- if (bSetAlpha) AlphaSet(x,y,c.rgbReserved);
-#endif //CXIMAGE_SUPPORT_ALPHA
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::SetPixelColor(int32_t x,int32_t y,RGBQUAD c, bool bSetAlpha)
-{
- if ((pDib==NULL)||(x<0)||(y<0)||
- (x>=head.biWidth)||(y>=head.biHeight)) return;
- if (head.biClrUsed)
- BlindSetPixelIndex(x,y,GetNearestIndex(c));
- else {
- uint8_t* iDst = info.pImage + y*info.dwEffWidth + x*3;
- *iDst++ = c.rgbBlue;
- *iDst++ = c.rgbGreen;
- *iDst = c.rgbRed;
- }
-#if CXIMAGE_SUPPORT_ALPHA
- if (bSetAlpha) AlphaSet(x,y,c.rgbReserved);
-#endif //CXIMAGE_SUPPORT_ALPHA
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Blends the current pixel color with a new color.
- * \param x,y = pixel
- * \param c = new color
- * \param blend = can be from 0 (no effect) to 1 (full effect).
- * \param bSetAlpha = if true, blends also the alpha component stored in c.rgbReserved
- */
-void CxImage::BlendPixelColor(int32_t x,int32_t y,RGBQUAD c, float blend, bool bSetAlpha)
-{
- if ((pDib==NULL)||(x<0)||(y<0)||
- (x>=head.biWidth)||(y>=head.biHeight)) return;
-
- int32_t a0 = (int32_t)(256*blend);
- int32_t a1 = 256 - a0;
-
- RGBQUAD c0 = BlindGetPixelColor(x,y);
- c.rgbRed = (uint8_t)((c.rgbRed * a0 + c0.rgbRed * a1)>>8);
- c.rgbBlue = (uint8_t)((c.rgbBlue * a0 + c0.rgbBlue * a1)>>8);
- c.rgbGreen = (uint8_t)((c.rgbGreen * a0 + c0.rgbGreen * a1)>>8);
-
- if (head.biClrUsed)
- BlindSetPixelIndex(x,y,GetNearestIndex(c));
- else {
- uint8_t* iDst = info.pImage + y*info.dwEffWidth + x*3;
- *iDst++ = c.rgbBlue;
- *iDst++ = c.rgbGreen;
- *iDst = c.rgbRed;
-#if CXIMAGE_SUPPORT_ALPHA
- if (bSetAlpha) AlphaSet(x,y,c.rgbReserved);
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns the best palette index that matches a specified color.
- */
-uint8_t CxImage::GetNearestIndex(RGBQUAD c)
-{
- if ((pDib==NULL)||(head.biClrUsed==0)) return 0;
-
- // <RJ> check matching with the previous result
- if (info.last_c_isvalid && (*(int32_t*)&info.last_c == *(int32_t*)&c)) return info.last_c_index;
- info.last_c = c;
- info.last_c_isvalid = true;
-
- uint8_t* iDst = (uint8_t*)(pDib) + sizeof(BITMAPINFOHEADER);
- int32_t distance=200000;
- int32_t i,j = 0;
- int32_t k,l;
- int32_t m = (int32_t)(head.biClrImportant==0 ? head.biClrUsed : head.biClrImportant);
- for(i=0,l=0;i<m;i++,l+=sizeof(RGBQUAD)){
- k = (iDst[l]-c.rgbBlue)*(iDst[l]-c.rgbBlue)+
- (iDst[l+1]-c.rgbGreen)*(iDst[l+1]-c.rgbGreen)+
- (iDst[l+2]-c.rgbRed)*(iDst[l+2]-c.rgbRed);
-// k = abs(iDst[l]-c.rgbBlue)+abs(iDst[l+1]-c.rgbGreen)+abs(iDst[l+2]-c.rgbRed);
- if (k==0){
- j=i;
- break;
- }
- if (k<distance){
- distance=k;
- j=i;
- }
- }
- info.last_c_index = (uint8_t)j;
- return (uint8_t)j;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * swaps the blue and red components (for RGB images)
- * \param buffer : pointer to the pixels
- * \param length : number of bytes to swap. lenght may not exceed the scan line.
- */
-void CxImage::RGBtoBGR(uint8_t *buffer, int32_t length)
-{
- if (buffer && (head.biClrUsed==0)){
- uint8_t temp;
- length = min(length,(int32_t)info.dwEffWidth);
- length = min(length,(int32_t)(3*head.biWidth));
- for (int32_t i=0;i<length;i+=3){
- temp = buffer[i]; buffer[i] = buffer[i+2]; buffer[i+2] = temp;
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-RGBQUAD CxImage::RGBtoRGBQUAD(COLORREF cr)
-{
- RGBQUAD c;
- c.rgbRed = GetRValue(cr); /* get R, G, and B out of uint32_t */
- c.rgbGreen = GetGValue(cr);
- c.rgbBlue = GetBValue(cr);
- c.rgbReserved=0;
- return c;
-}
-////////////////////////////////////////////////////////////////////////////////
-COLORREF CxImage::RGBQUADtoRGB (RGBQUAD c)
-{
- return RGB(c.rgbRed,c.rgbGreen,c.rgbBlue);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns the color of the specified index.
- * \param i = palette index
- * \param r, g, b = output color channels
- */
-bool CxImage::GetPaletteColor(uint8_t i, uint8_t* r, uint8_t* g, uint8_t* b)
-{
- RGBQUAD* ppal=GetPalette();
- if (ppal) {
- *r = ppal[i].rgbRed;
- *g = ppal[i].rgbGreen;
- *b = ppal[i].rgbBlue;
- return true;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::SetPalette(uint32_t n, uint8_t *r, uint8_t *g, uint8_t *b)
-{
- if ((!r)||(pDib==NULL)||(head.biClrUsed==0)) return;
- if (!g) g = r;
- if (!b) b = g;
- RGBQUAD* ppal=GetPalette();
- uint32_t m=min(n,head.biClrUsed);
- for (uint32_t i=0; i<m;i++){
- ppal[i].rgbRed=r[i];
- ppal[i].rgbGreen=g[i];
- ppal[i].rgbBlue=b[i];
- }
- info.last_c_isvalid = false;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::SetPalette(rgb_color *rgb,uint32_t nColors)
-{
- if ((!rgb)||(pDib==NULL)||(head.biClrUsed==0)) return;
- RGBQUAD* ppal=GetPalette();
- uint32_t m=min(nColors,head.biClrUsed);
- for (uint32_t i=0; i<m;i++){
- ppal[i].rgbRed=rgb[i].r;
- ppal[i].rgbGreen=rgb[i].g;
- ppal[i].rgbBlue=rgb[i].b;
- }
- info.last_c_isvalid = false;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::SetPalette(RGBQUAD* pPal,uint32_t nColors)
-{
- if ((pPal==NULL)||(pDib==NULL)||(head.biClrUsed==0)) return;
- memcpy(GetPalette(),pPal,min(GetPaletteSize(),nColors*sizeof(RGBQUAD)));
- info.last_c_isvalid = false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets (or replaces) the palette to gray scale palette.
- * The function doesn't change the pixels; for standard
- * gray scale conversion use GrayScale().
- */
-void CxImage::SetGrayPalette()
-{
- if ((pDib==NULL)||(head.biClrUsed==0)) return;
- RGBQUAD* pal=GetPalette();
- for (uint32_t ni=0;ni<head.biClrUsed;ni++)
- pal[ni].rgbBlue=pal[ni].rgbGreen = pal[ni].rgbRed = (uint8_t)(ni*(255/(head.biClrUsed-1)));
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Colorize the palette.
- * \sa Colorize
- */
-void CxImage::BlendPalette(COLORREF cr,int32_t perc)
-{
- if ((pDib==NULL)||(head.biClrUsed==0)) return;
- uint8_t* iDst = (uint8_t*)(pDib) + sizeof(BITMAPINFOHEADER);
- uint32_t i,r,g,b;
- RGBQUAD* pPal=(RGBQUAD*)iDst;
- r = GetRValue(cr);
- g = GetGValue(cr);
- b = GetBValue(cr);
- if (perc>100) perc=100;
- for(i=0;i<head.biClrUsed;i++){
- pPal[i].rgbBlue=(uint8_t)((pPal[i].rgbBlue*(100-perc)+b*perc)/100);
- pPal[i].rgbGreen =(uint8_t)((pPal[i].rgbGreen*(100-perc)+g*perc)/100);
- pPal[i].rgbRed =(uint8_t)((pPal[i].rgbRed*(100-perc)+r*perc)/100);
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns true if the image has 256 colors and a linear grey scale palette.
- */
-bool CxImage::IsGrayScale()
-{
- RGBQUAD* ppal=GetPalette();
- if(!(pDib && ppal && head.biClrUsed)) return false;
- for(uint32_t i=0;i<head.biClrUsed;i++){
- if (ppal[i].rgbBlue!=i || ppal[i].rgbGreen!=i || ppal[i].rgbRed!=i) return false;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * swap two indexes in the image and their colors in the palette
- */
-void CxImage::SwapIndex(uint8_t idx1, uint8_t idx2)
-{
- RGBQUAD* ppal=GetPalette();
- if(!(pDib && ppal)) return;
- //swap the colors
- RGBQUAD tempRGB=GetPaletteColor(idx1);
- SetPaletteColor(idx1,GetPaletteColor(idx2));
- SetPaletteColor(idx2,tempRGB);
- //swap the pixels
- uint8_t idx;
- for(int32_t y=0; y < head.biHeight; y++){
- for(int32_t x=0; x < head.biWidth; x++){
- idx=BlindGetPixelIndex(x,y);
- if (idx==idx1) BlindSetPixelIndex(x,y,idx2);
- if (idx==idx2) BlindSetPixelIndex(x,y,idx1);
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * swap Red and Blue colors
- */
-void CxImage::SwapRGB2BGR()
-{
- if (!pDib) return;
-
- if (head.biClrUsed){
- RGBQUAD* ppal=GetPalette();
- uint8_t b;
- if(!ppal) return;
- for(uint16_t a=0;a<head.biClrUsed;a++){
- b=ppal[a].rgbBlue; ppal[a].rgbBlue=ppal[a].rgbRed; ppal[a].rgbRed=b;
- }
- } else {
- for(int32_t y=0;y<head.biHeight;y++){
- RGBtoBGR(GetBits(y),3*head.biWidth);
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::IsTransparent(int32_t x, int32_t y)
-{
- if (!pDib) return false;
-
- if (info.nBkgndIndex>=0){
- if (head.biClrUsed){
- if (GetPixelIndex(x,y) == info.nBkgndIndex) return true;
- } else {
- RGBQUAD ct = info.nBkgndColor;
- RGBQUAD c = GetPixelColor(x,y,false);
- if (*(int32_t*)&c==*(int32_t*)&ct) return true;
- }
- }
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (pAlpha) return AlphaGet(x,y)==0;
-#endif
-
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::GetTransparentMask(CxImage* iDst)
-{
- if (!pDib) return false;
-
- CxImage tmp;
- tmp.Create(head.biWidth, head.biHeight, 1, GetType());
- tmp.SetStdPalette();
- tmp.Clear(0);
-
- for(int32_t y=0; y<head.biHeight; y++){
- for(int32_t x=0; x<head.biWidth; x++){
- if (IsTransparent(x,y)){
- tmp.BlindSetPixelIndex(x,y,1);
- }
- }
- }
-
- if (iDst) iDst->Transfer(tmp);
- else Transfer(tmp);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks if image has the same palette, if any.
- * \param img = image to compare.
- * \param bCheckAlpha = check also the rgbReserved field.
- */
-bool CxImage::IsSamePalette(CxImage &img, bool bCheckAlpha)
-{
- if (head.biClrUsed != img.head.biClrUsed)
- return false;
- if (head.biClrUsed == 0)
- return false;
-
- RGBQUAD c1,c2;
- for (uint32_t n=0; n<head.biClrUsed; n++){
- c1 = GetPaletteColor((uint8_t)n);
- c2 = img.GetPaletteColor((uint8_t)n);
- if (c1.rgbRed != c2.rgbRed) return false;
- if (c1.rgbBlue != c2.rgbBlue) return false;
- if (c1.rgbGreen != c2.rgbGreen) return false;
- if (bCheckAlpha && (c1.rgbReserved != c2.rgbReserved)) return false;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \sa SetClrImportant
- */
-uint32_t CxImage::GetClrImportant() const
-{
- return head.biClrImportant;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * sets the maximum number of colors that some functions like
- * DecreaseBpp() or GetNearestIndex() will use on indexed images
- * \param ncolors should be less than 2^bpp,
- * or 0 if all the colors are important.
- */
-void CxImage::SetClrImportant(uint32_t ncolors)
-{
- if (ncolors==0 || ncolors>256) {
- head.biClrImportant = 0;
- return;
- }
-
- switch(head.biBitCount){
- case 1:
- head.biClrImportant = min(ncolors,2);
- break;
- case 4:
- head.biClrImportant = min(ncolors,16);
- break;
- case 8:
- head.biClrImportant = ncolors;
- break;
- }
- return;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns pointer to pixel. Currently implemented only for truecolor images.
- *
- * \param x,y - coordinates
- *
- * \return pointer to first byte of pixel data
- *
- * \author ***bd*** 2.2004
- */
-void* CxImage::BlindGetPixelPointer(const int32_t x, const int32_t y)
-{
-#ifdef _DEBUG
- if ((pDib==NULL) || !IsInside(x,y))
- #if CXIMAGE_SUPPORT_EXCEPTION_HANDLING
- throw 0;
- #else
- return 0;
- #endif
-#endif
- if (!IsIndexed())
- return info.pImage + y*info.dwEffWidth + x*3;
- else
- return 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::DrawLine(int32_t StartX, int32_t EndX, int32_t StartY, int32_t EndY, COLORREF cr)
-{
- DrawLine(StartX, EndX, StartY, EndY, RGBtoRGBQUAD(cr));
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImage::DrawLine(int32_t StartX, int32_t EndX, int32_t StartY, int32_t EndY, RGBQUAD color, bool bSetAlpha)
-{
- if (!pDib) return;
- //////////////////////////////////////////////////////
- // Draws a line using the Bresenham line algorithm
- // Thanks to Jordan DeLozier <JDL>
- //////////////////////////////////////////////////////
- int32_t x1 = StartX;
- int32_t y1 = StartY;
- int32_t x = x1; // Start x off at the first pixel
- int32_t y = y1; // Start y off at the first pixel
- int32_t x2 = EndX;
- int32_t y2 = EndY;
-
- int32_t xinc1,xinc2,yinc1,yinc2; // Increasing values
- int32_t den, num, numadd,numpixels;
- int32_t deltax = abs(x2 - x1); // The difference between the x's
- int32_t deltay = abs(y2 - y1); // The difference between the y's
-
- // Get Increasing Values
- if (x2 >= x1) { // The x-values are increasing
- xinc1 = 1;
- xinc2 = 1;
- } else { // The x-values are decreasing
- xinc1 = -1;
- xinc2 = -1;
- }
-
- if (y2 >= y1) { // The y-values are increasing
- yinc1 = 1;
- yinc2 = 1;
- } else { // The y-values are decreasing
- yinc1 = -1;
- yinc2 = -1;
- }
-
- // Actually draw the line
- if (deltax >= deltay) // There is at least one x-value for every y-value
- {
- xinc1 = 0; // Don't change the x when numerator >= denominator
- yinc2 = 0; // Don't change the y for every iteration
- den = deltax;
- num = deltax / 2;
- numadd = deltay;
- numpixels = deltax; // There are more x-values than y-values
- }
- else // There is at least one y-value for every x-value
- {
- xinc2 = 0; // Don't change the x for every iteration
- yinc1 = 0; // Don't change the y when numerator >= denominator
- den = deltay;
- num = deltay / 2;
- numadd = deltax;
- numpixels = deltay; // There are more y-values than x-values
- }
-
- for (int32_t curpixel = 0; curpixel <= numpixels; curpixel++)
- {
- // Draw the current pixel
- SetPixelColor(x,y,color,bSetAlpha);
-
- num += numadd; // Increase the numerator by the top of the fraction
- if (num >= den) // Check if numerator >= denominator
- {
- num -= den; // Calculate the new numerator value
- x += xinc1; // Change the x as appropriate
- y += yinc1; // Change the y as appropriate
- }
- x += xinc2; // Change the x as appropriate
- y += yinc2; // Change the y as appropriate
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets a palette with standard colors for 1, 4 and 8 bpp images.
- */
-void CxImage::SetStdPalette()
-{
- if (!pDib) return;
- switch (head.biBitCount){
- case 8:
- {
- const uint8_t pal256[1024] = {0,0,0,0,0,0,128,0,0,128,0,0,0,128,128,0,128,0,0,0,128,0,128,0,128,128,0,0,192,192,192,0,
- 192,220,192,0,240,202,166,0,212,240,255,0,177,226,255,0,142,212,255,0,107,198,255,0,
- 72,184,255,0,37,170,255,0,0,170,255,0,0,146,220,0,0,122,185,0,0,98,150,0,0,74,115,0,0,
- 50,80,0,212,227,255,0,177,199,255,0,142,171,255,0,107,143,255,0,72,115,255,0,37,87,255,0,0,
- 85,255,0,0,73,220,0,0,61,185,0,0,49,150,0,0,37,115,0,0,25,80,0,212,212,255,0,177,177,255,0,
- 142,142,255,0,107,107,255,0,72,72,255,0,37,37,255,0,0,0,254,0,0,0,220,0,0,0,185,0,0,0,150,0,
- 0,0,115,0,0,0,80,0,227,212,255,0,199,177,255,0,171,142,255,0,143,107,255,0,115,72,255,0,
- 87,37,255,0,85,0,255,0,73,0,220,0,61,0,185,0,49,0,150,0,37,0,115,0,25,0,80,0,240,212,255,0,
- 226,177,255,0,212,142,255,0,198,107,255,0,184,72,255,0,170,37,255,0,170,0,255,0,146,0,220,0,
- 122,0,185,0,98,0,150,0,74,0,115,0,50,0,80,0,255,212,255,0,255,177,255,0,255,142,255,0,255,107,255,0,
- 255,72,255,0,255,37,255,0,254,0,254,0,220,0,220,0,185,0,185,0,150,0,150,0,115,0,115,0,80,0,80,0,
- 255,212,240,0,255,177,226,0,255,142,212,0,255,107,198,0,255,72,184,0,255,37,170,0,255,0,170,0,
- 220,0,146,0,185,0,122,0,150,0,98,0,115,0,74,0,80,0,50,0,255,212,227,0,255,177,199,0,255,142,171,0,
- 255,107,143,0,255,72,115,0,255,37,87,0,255,0,85,0,220,0,73,0,185,0,61,0,150,0,49,0,115,0,37,0,
- 80,0,25,0,255,212,212,0,255,177,177,0,255,142,142,0,255,107,107,0,255,72,72,0,255,37,37,0,254,0,
- 0,0,220,0,0,0,185,0,0,0,150,0,0,0,115,0,0,0,80,0,0,0,255,227,212,0,255,199,177,0,255,171,142,0,
- 255,143,107,0,255,115,72,0,255,87,37,0,255,85,0,0,220,73,0,0,185,61,0,0,150,49,0,0,115,37,0,
- 0,80,25,0,0,255,240,212,0,255,226,177,0,255,212,142,0,255,198,107,0,255,184,72,0,255,170,37,0,
- 255,170,0,0,220,146,0,0,185,122,0,0,150,98,0,0,115,74,0,0,80,50,0,0,255,255,212,0,255,255,177,0,
- 255,255,142,0,255,255,107,0,255,255,72,0,255,255,37,0,254,254,0,0,220,220,0,0,185,185,0,0,150,150,0,
- 0,115,115,0,0,80,80,0,0,240,255,212,0,226,255,177,0,212,255,142,0,198,255,107,0,184,255,72,0,
- 170,255,37,0,170,255,0,0,146,220,0,0,122,185,0,0,98,150,0,0,74,115,0,0,50,80,0,0,227,255,212,0,
- 199,255,177,0,171,255,142,0,143,255,107,0,115,255,72,0,87,255,37,0,85,255,0,0,73,220,0,0,61,185,0,
- 0,49,150,0,0,37,115,0,0,25,80,0,0,212,255,212,0,177,255,177,0,142,255,142,0,107,255,107,0,72,255,72,0,
- 37,255,37,0,0,254,0,0,0,220,0,0,0,185,0,0,0,150,0,0,0,115,0,0,0,80,0,0,212,255,227,0,177,255,199,0,
- 142,255,171,0,107,255,143,0,72,255,115,0,37,255,87,0,0,255,85,0,0,220,73,0,0,185,61,0,0,150,49,0,0,
- 115,37,0,0,80,25,0,212,255,240,0,177,255,226,0,142,255,212,0,107,255,198,0,72,255,184,0,37,255,170,0,
- 0,255,170,0,0,220,146,0,0,185,122,0,0,150,98,0,0,115,74,0,0,80,50,0,212,255,255,0,177,255,255,0,
- 142,255,255,0,107,255,255,0,72,255,255,0,37,255,255,0,0,254,254,0,0,220,220,0,0,185,185,0,0,
- 150,150,0,0,115,115,0,0,80,80,0,242,242,242,0,230,230,230,0,218,218,218,0,206,206,206,0,194,194,194,0,
- 182,182,182,0,170,170,170,0,158,158,158,0,146,146,146,0,134,134,134,0,122,122,122,0,110,110,110,0,
- 98,98,98,0,86,86,86,0,74,74,74,0,62,62,62,0,50,50,50,0,38,38,38,0,26,26,26,0,14,14,14,0,240,251,255,0,
- 164,160,160,0,128,128,128,0,0,0,255,0,0,255,0,0,0,255,255,0,255,0,0,0,255,0,255,0,255,255,0,0,255,255,255,0};
- memcpy(GetPalette(),pal256,1024);
- break;
- }
- case 4:
- {
- const uint8_t pal16[64]={0,0,0,0,0,0,128,0,0,128,0,0,0,128,128,0,128,0,0,0,128,0,128,0,128,128,0,0,192,192,192,0,
- 128,128,128,0,0,0,255,0,0,255,0,0,0,255,255,0,255,0,0,0,255,0,255,0,255,255,0,0,255,255,255,0};
- memcpy(GetPalette(),pal16,64);
- break;
- }
- case 1:
- {
- const uint8_t pal2[8]={0,0,0,0,255,255,255,0};
- memcpy(GetPalette(),pal2,8);
- break;
- }
- }
- info.last_c_isvalid = false;
- return;
-}
-////////////////////////////////////////////////////////////////////////////////
diff --git a/smelt/sdl/CxImage/ximapcx.cpp b/smelt/sdl/CxImage/ximapcx.cpp deleted file mode 100644 index 2fa2f5d..0000000 --- a/smelt/sdl/CxImage/ximapcx.cpp +++ /dev/null @@ -1,479 +0,0 @@ -/*
- * File: ximapcx.cpp
- * Purpose: Platform Independent PCX Image Class Loader and Writer
- * 05/Jan/2002 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- *
- * based on ppmtopcx.c - convert a portable pixmap to PCX
- * Copyright (C) 1994 by Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
- * based on ppmtopcx.c by Michael Davidson
- */
-
-#include "ximapcx.h"
-
-#if CXIMAGE_SUPPORT_PCX
-
-#include "xmemfile.h"
-
-#define PCX_MAGIC 0X0A // PCX magic number
-#define PCX_256_COLORS 0X0C // magic number for 256 colors
-#define PCX_HDR_SIZE 128 // size of PCX header
-#define PCX_MAXCOLORS 256
-#define PCX_MAXPLANES 4
-#define PCX_MAXVAL 255
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImagePCX::Decode(CxFile *hFile)
-{
- if (hFile == NULL) return false;
-
- PCXHEADER pcxHeader;
- int32_t i, x, y, y2, nbytes, count, Height, Width;
- uint8_t c, ColorMap[PCX_MAXCOLORS][3];
- uint8_t *pcximage = NULL, *lpHead1 = NULL, *lpHead2 = NULL;
- uint8_t *pcxplanes, *pcxpixels;
-
- cx_try
- {
- if (hFile->Read(&pcxHeader,sizeof(PCXHEADER),1)==0) cx_throw("Can't read PCX image");
-
- PCX_toh(&pcxHeader);
-
- if (pcxHeader.Manufacturer != PCX_MAGIC) cx_throw("Error: Not a PCX file");
- // Check for PCX run length encoding
- if (pcxHeader.Encoding != 1) cx_throw("PCX file has unknown encoding scheme");
-
- Width = (pcxHeader.Xmax - pcxHeader.Xmin) + 1;
- Height = (pcxHeader.Ymax - pcxHeader.Ymin) + 1;
- info.xDPI = pcxHeader.Hres;
- info.yDPI = pcxHeader.Vres;
-
- if (info.nEscape == -1){
- head.biWidth = Width;
- head.biHeight= Height;
- info.dwType = CXIMAGE_FORMAT_PCX;
- return true;
- }
-
- // Check that we can handle this image format
- if (pcxHeader.ColorPlanes > 4)
- cx_throw("Can't handle image with more than 4 planes");
-
- // Create the image
- if (pcxHeader.ColorPlanes >= 3 && pcxHeader.BitsPerPixel == 8){
- Create (Width, Height, 24, CXIMAGE_FORMAT_PCX);
-#if CXIMAGE_SUPPORT_ALPHA
- if (pcxHeader.ColorPlanes==4) AlphaCreate();
-#endif //CXIMAGE_SUPPORT_ALPHA
- } else if (pcxHeader.ColorPlanes == 4 && pcxHeader.BitsPerPixel == 1)
- Create (Width, Height, 4, CXIMAGE_FORMAT_PCX);
- else
- Create (Width, Height, pcxHeader.BitsPerPixel, CXIMAGE_FORMAT_PCX);
-
- if (info.nEscape) cx_throw("Cancelled"); // <vho> - cancel decoding
-
- //Read the image and check if it's ok
- nbytes = pcxHeader.BytesPerLine * pcxHeader.ColorPlanes * Height;
- lpHead1 = pcximage = (uint8_t*)malloc(nbytes);
- while (nbytes > 0){
- if (hFile == NULL || hFile->Eof()) cx_throw("corrupted PCX");
-
- hFile->Read(&c,1,1);
- if ((c & 0XC0) != 0XC0){ // Repeated group
- *pcximage++ = c;
- --nbytes;
- continue;
- }
- count = c & 0X3F; // extract count
- hFile->Read(&c,1,1);
- if (count > nbytes) cx_throw("repeat count spans end of image");
-
- nbytes -= count;
- while (--count >=0) *pcximage++ = c;
- }
- pcximage = lpHead1;
-
- //store the palette
- for (i = 0; i < 16; i++){
- ColorMap[i][0] = pcxHeader.ColorMap[i][0];
- ColorMap[i][1] = pcxHeader.ColorMap[i][1];
- ColorMap[i][2] = pcxHeader.ColorMap[i][2];
- }
- if (pcxHeader.BitsPerPixel == 8 && pcxHeader.ColorPlanes == 1){
- hFile->Read(&c,1,1);
- if (c != PCX_256_COLORS) cx_throw("bad color map signature");
-
- for (i = 0; i < PCX_MAXCOLORS; i++){
- hFile->Read(&ColorMap[i][0],1,1);
- hFile->Read(&ColorMap[i][1],1,1);
- hFile->Read(&ColorMap[i][2],1,1);
- }
- }
- if (pcxHeader.BitsPerPixel == 1 && pcxHeader.ColorPlanes == 1){
- ColorMap[0][0] = ColorMap[0][1] = ColorMap[0][2] = 0;
- ColorMap[1][0] = ColorMap[1][1] = ColorMap[1][2] = 255;
- }
-
- for (uint32_t idx=0; idx<head.biClrUsed; idx++) SetPaletteColor((uint8_t)idx,ColorMap[idx][0],ColorMap[idx][1],ColorMap[idx][2]);
-
- lpHead2 = pcxpixels = (uint8_t *)malloc(Width + pcxHeader.BytesPerLine * 8);
- // Convert the image
- for (y = 0; y < Height; y++){
-
- if (info.nEscape) cx_throw("Cancelled"); // <vho> - cancel decoding
-
- y2=Height-1-y;
- pcxpixels = lpHead2;
- pcxplanes = pcximage + (y * pcxHeader.BytesPerLine * pcxHeader.ColorPlanes);
-
- if (pcxHeader.ColorPlanes == 3 && pcxHeader.BitsPerPixel == 8){
- // Deal with 24 bit color image
- for (x = 0; x < Width; x++){
- SetPixelColor(x,y2,RGB(pcxplanes[x],pcxplanes[pcxHeader.BytesPerLine + x],pcxplanes[2*pcxHeader.BytesPerLine + x]));
- }
- continue;
-#if CXIMAGE_SUPPORT_ALPHA
- } else if (pcxHeader.ColorPlanes == 4 && pcxHeader.BitsPerPixel == 8){
- for (x = 0; x < Width; x++){
- SetPixelColor(x,y2,RGB(pcxplanes[x],pcxplanes[pcxHeader.BytesPerLine + x],pcxplanes[2*pcxHeader.BytesPerLine + x]));
- AlphaSet(x,y2,pcxplanes[3*pcxHeader.BytesPerLine + x]);
- }
- continue;
-#endif //CXIMAGE_SUPPORT_ALPHA
- } else if (pcxHeader.ColorPlanes == 1) {
- if (!PCX_UnpackPixels(pcxpixels, pcxplanes, pcxHeader.BytesPerLine, pcxHeader.ColorPlanes, pcxHeader.BitsPerPixel)){
- cx_throw("PCX_UnpackPixels: Can't handle packed pixels with more than 1 plane");
- }
- } else {
- if (!PCX_PlanesToPixels(pcxpixels, pcxplanes, pcxHeader.BytesPerLine, pcxHeader.ColorPlanes, pcxHeader.BitsPerPixel)){
- cx_throw("PCX_PlanesToPixels: more than 4 planes or more than 1 bit per pixel");
- }
- }
- for (x = 0; x < Width; x++) SetPixelIndex(x,y2,pcxpixels[x]);
- }
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- if (lpHead1){ free(lpHead1); lpHead1 = NULL; }
- if (lpHead2){ free(lpHead2); lpHead2 = NULL; }
- return false;
- }
- if (lpHead1){ free(lpHead1); lpHead1 = NULL; }
- if (lpHead2){ free(lpHead2); lpHead2 = NULL; }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImagePCX::Encode(CxFile * hFile)
-{
- if (EncodeSafeCheck(hFile)) return false;
-
- cx_try
- {
- PCXHEADER pcxHeader;
- memset(&pcxHeader,0,sizeof(pcxHeader));
- pcxHeader.Manufacturer = PCX_MAGIC;
- pcxHeader.Version = 5;
- pcxHeader.Encoding = 1;
- pcxHeader.Xmin = 0;
- pcxHeader.Ymin = 0;
- pcxHeader.Xmax = (uint16_t)head.biWidth-1;
- pcxHeader.Ymax = (uint16_t)head.biHeight-1;
- pcxHeader.Hres = (uint16_t)info.xDPI;
- pcxHeader.Vres = (uint16_t)info.yDPI;
- pcxHeader.Reserved = 0;
- pcxHeader.PaletteType = head.biClrUsed==0;
-
- switch(head.biBitCount){
- case 24:
- case 8:
- {
- pcxHeader.BitsPerPixel = 8;
- pcxHeader.ColorPlanes = head.biClrUsed==0 ? 3 : 1;
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid() && head.biClrUsed==0) pcxHeader.ColorPlanes =4;
-#endif //CXIMAGE_SUPPORT_ALPHA
- pcxHeader.BytesPerLine = (uint16_t)head.biWidth;
- break;
- }
- default: //(4 1)
- pcxHeader.BitsPerPixel = 1;
- pcxHeader.ColorPlanes = head.biClrUsed==16 ? 4 : 1;
- pcxHeader.BytesPerLine = (uint16_t)((head.biWidth * pcxHeader.BitsPerPixel + 7)>>3);
- }
-
- if (pcxHeader.BitsPerPixel == 1 && pcxHeader.ColorPlanes == 1){
- pcxHeader.ColorMap[0][0] = pcxHeader.ColorMap[0][1] = pcxHeader.ColorMap[0][2] = 0;
- pcxHeader.ColorMap[1][0] = pcxHeader.ColorMap[1][1] = pcxHeader.ColorMap[1][2] = 255;
- }
- if (pcxHeader.BitsPerPixel == 1 && pcxHeader.ColorPlanes == 4){
- RGBQUAD c;
- for (int32_t i = 0; i < 16; i++){
- c=GetPaletteColor(i);
- pcxHeader.ColorMap[i][0] = c.rgbRed;
- pcxHeader.ColorMap[i][1] = c.rgbGreen;
- pcxHeader.ColorMap[i][2] = c.rgbBlue;
- }
- }
-
- pcxHeader.BytesPerLine = (pcxHeader.BytesPerLine + 1)&(~1);
-
- PCX_toh(&pcxHeader);
- if (hFile->Write(&pcxHeader, sizeof(pcxHeader), 1) == 0 )
- cx_throw("cannot write PCX header");
- PCX_toh(&pcxHeader);
-
- CxMemFile buffer;
- buffer.Open();
-
- uint8_t c,n;
- int32_t x,y;
- if (head.biClrUsed==0){
- for (y = head.biHeight-1; y >=0 ; y--){
- for (int32_t p=0; p<pcxHeader.ColorPlanes; p++){
- c=n=0;
- for (x = 0; x<head.biWidth; x++){
- if (p==0)
- PCX_PackPixels(BlindGetPixelColor(x,y).rgbRed,c,n,buffer);
- else if (p==1)
- PCX_PackPixels(BlindGetPixelColor(x,y).rgbGreen,c,n,buffer);
- else if (p==2)
- PCX_PackPixels(BlindGetPixelColor(x,y).rgbBlue,c,n,buffer);
-#if CXIMAGE_SUPPORT_ALPHA
- else if (p==3)
- PCX_PackPixels(BlindAlphaGet(x,y),c,n,buffer);
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- PCX_PackPixels(-1-(head.biWidth&0x1),c,n,buffer);
- }
- }
-
- hFile->Write(buffer.GetBuffer(false),buffer.Tell(),1);
-
- } else if (head.biBitCount==8) {
-
- for (y = head.biHeight-1; y >=0 ; y--){
- c=n=0;
- for (x = 0; x<head.biWidth; x++){
- PCX_PackPixels(GetPixelIndex(x,y),c,n,buffer);
- }
- PCX_PackPixels(-1-(head.biWidth&0x1),c,n,buffer);
- }
-
- hFile->Write(buffer.GetBuffer(false),buffer.Tell(),1);
-
- if (head.biBitCount == 8){
- hFile->PutC(0x0C);
- uint8_t* pal = (uint8_t*)malloc(768);
- RGBQUAD c;
- for (int32_t i=0;i<256;i++){
- c=GetPaletteColor(i);
- pal[3*i+0] = c.rgbRed;
- pal[3*i+1] = c.rgbGreen;
- pal[3*i+2] = c.rgbBlue;
- }
- hFile->Write(pal,768,1);
- free(pal);
- }
- } else { //(head.biBitCount==4) || (head.biBitCount==1)
-
- RGBQUAD *rgb = GetPalette();
- bool binvert = false;
- if (CompareColors(&rgb[0],&rgb[1])>0) binvert=(head.biBitCount==1);
-
- uint8_t* plane = (uint8_t*)malloc(pcxHeader.BytesPerLine);
- uint8_t* raw = (uint8_t*)malloc(head.biWidth);
-
- for(y = head.biHeight-1; y >=0 ; y--) {
-
- for( x = 0; x < head.biWidth; x++) raw[x] = (uint8_t)GetPixelIndex(x,y);
-
- if (binvert) for( x = 0; x < head.biWidth; x++) raw[x] = 1-raw[x];
-
- for( x = 0; x < pcxHeader.ColorPlanes; x++ ) {
- PCX_PixelsToPlanes(raw, head.biWidth, plane, x);
- PCX_PackPlanes(plane, pcxHeader.BytesPerLine, buffer);
- }
- }
-
- free(plane);
- free(raw);
-
- hFile->Write(buffer.GetBuffer(false),buffer.Tell(),1);
-
- }
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- return false;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-// Convert multi-plane format into 1 pixel per byte
-// from unpacked file data bitplanes[] into pixel row pixels[]
-// image Height rows, with each row having planes image planes each
-// bytesperline bytes
-bool CxImagePCX::PCX_PlanesToPixels(uint8_t * pixels, uint8_t * bitplanes, int16_t bytesperline, int16_t planes, int16_t bitsperpixel)
-{
- int32_t i, j, npixels;
- uint8_t * p;
- if (planes > 4) return false;
- if (bitsperpixel != 1) return false;
-
- // Clear the pixel buffer
- npixels = (bytesperline * 8) / bitsperpixel;
- p = pixels;
- while (--npixels >= 0) *p++ = 0;
-
- // Do the format conversion
- for (i = 0; i < planes; i++){
- int32_t pixbit, bits, mask;
- p = pixels;
- pixbit = (1 << i); // pixel bit for this plane
- for (j = 0; j < bytesperline; j++){
- bits = *bitplanes++;
- for (mask = 0X80; mask != 0; mask >>= 1, p++)
- if (bits & mask) *p |= pixbit;
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-// convert packed pixel format into 1 pixel per byte
-// from unpacked file data bitplanes[] into pixel row pixels[]
-// image Height rows, with each row having planes image planes each
-// bytesperline bytes
-bool CxImagePCX::PCX_UnpackPixels(uint8_t * pixels, uint8_t * bitplanes, int16_t bytesperline, int16_t planes, int16_t bitsperpixel)
-{
- register int32_t bits;
- if (planes != 1) return false;
-
- if (bitsperpixel == 8){ // 8 bits/pixels, no unpacking needed
- while (bytesperline-- > 0) *pixels++ = *bitplanes++;
- } else if (bitsperpixel == 4){ // 4 bits/pixel, two pixels per byte
- while (bytesperline-- > 0){
- bits = *bitplanes++;
- *pixels++ = (uint8_t)((bits >> 4) & 0X0F);
- *pixels++ = (uint8_t)((bits) & 0X0F);
- }
- } else if (bitsperpixel == 2){ // 2 bits/pixel, four pixels per byte
- while (bytesperline-- > 0){
- bits = *bitplanes++;
- *pixels++ = (uint8_t)((bits >> 6) & 0X03);
- *pixels++ = (uint8_t)((bits >> 4) & 0X03);
- *pixels++ = (uint8_t)((bits >> 2) & 0X03);
- *pixels++ = (uint8_t)((bits) & 0X03);
- }
- } else if (bitsperpixel == 1){ // 1 bits/pixel, 8 pixels per byte
- while (bytesperline-- > 0){
- bits = *bitplanes++;
- *pixels++ = ((bits & 0X80) != 0);
- *pixels++ = ((bits & 0X40) != 0);
- *pixels++ = ((bits & 0X20) != 0);
- *pixels++ = ((bits & 0X10) != 0);
- *pixels++ = ((bits & 0X08) != 0);
- *pixels++ = ((bits & 0X04) != 0);
- *pixels++ = ((bits & 0X02) != 0);
- *pixels++ = ((bits & 0X01) != 0);
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/* PCX_PackPixels(const int32_t p,uint8_t &c, uint8_t &n, int32_t &l, CxFile &f)
- * p = current pixel (-1 ends the line -2 ends odd line)
- * c = previous pixel
- * n = number of consecutive pixels
- */
-void CxImagePCX::PCX_PackPixels(const int32_t p,uint8_t &c, uint8_t &n, CxFile &f)
-{
- if (p!=c && n){
- if (n==1 && c<0xC0){
- f.PutC(c);
- } else {
- f.PutC(0xC0|n);
- f.PutC(c);
- }
- n=0;
- }
- if (n==0x3F) {
- f.PutC(0xFF);
- f.PutC(c);
- n=0;
- }
- if (p==-2) f.PutC(0);
- c=(uint8_t)p;
- n++;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImagePCX::PCX_PackPlanes(uint8_t* buff, const int32_t size, CxFile &f)
-{
- uint8_t *start,*end;
- uint8_t c, previous, count;
-
- start = buff;
- end = buff + size;
- previous = *start++;
- count = 1;
-
- while (start < end) {
- c = *start++;
- if (c == previous && count < 63) {
- ++count;
- continue;
- }
-
- if (count > 1 || (previous & 0xc0) == 0xc0) {
- f.PutC( count | 0xc0 );
- }
- f.PutC(previous);
- previous = c;
- count = 1;
- }
-
- if (count > 1 || (previous & 0xc0) == 0xc0) {
- count |= 0xc0;
- f.PutC(count);
- }
- f.PutC(previous);
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImagePCX::PCX_PixelsToPlanes(uint8_t* raw, int32_t width, uint8_t* buf, int32_t plane)
-{
- int32_t cbit, x, mask;
- uint8_t *cp = buf-1;
-
- mask = 1 << plane;
- cbit = -1;
- for( x = 0; x < width; x++ ) {
- if( cbit < 0 ) {
- cbit = 7;
- *++cp = 0;
- }
- if( raw[x] & mask )
- *cp |= (1<<cbit);
- --cbit;
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImagePCX::PCX_toh(PCXHEADER* p)
-{
- p->Xmin = m_ntohs(p->Xmin);
- p->Ymin = m_ntohs(p->Ymin);
- p->Xmax = m_ntohs(p->Xmax);
- p->Ymax = m_ntohs(p->Ymax);
- p->Hres = m_ntohs(p->Hres);
- p->Vres = m_ntohs(p->Vres);
- p->BytesPerLine = m_ntohs(p->BytesPerLine);
- p->PaletteType = m_ntohs(p->PaletteType);
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_PCX
diff --git a/smelt/sdl/CxImage/ximapcx.h b/smelt/sdl/CxImage/ximapcx.h deleted file mode 100644 index 05c5ad0..0000000 --- a/smelt/sdl/CxImage/ximapcx.h +++ /dev/null @@ -1,64 +0,0 @@ -/*
- * File: ximapcx.h
- * Purpose: PCX Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImagePCX (c) 05/Jan/2002 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- *
- * Parts of the code come from Paintlib: Copyright (c) 1996-1998 Ulrich von Zadow
- * ==========================================================
- */
-#if !defined(__ximaPCX_h)
-#define __ximaPCX_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_PCX
-
-class CxImagePCX: public CxImage
-{
-// PCX Image File
-#pragma pack(1)
-typedef struct tagPCXHEADER
-{
- char Manufacturer; // always 0X0A
- char Version; // version number
- char Encoding; // always 1
- char BitsPerPixel; // color bits
- uint16_t Xmin, Ymin; // image origin
- uint16_t Xmax, Ymax; // image dimensions
- uint16_t Hres, Vres; // resolution values
- uint8_t ColorMap[16][3]; // color palette
- char Reserved;
- char ColorPlanes; // color planes
- uint16_t BytesPerLine; // line buffer size
- uint16_t PaletteType; // grey or color palette
- char Filter[58];
-} PCXHEADER;
-#pragma pack()
-
-public:
- CxImagePCX(): CxImage(CXIMAGE_FORMAT_PCX) {}
-
-// bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_PCX);}
-// bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_PCX);}
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-protected:
- bool PCX_PlanesToPixels(uint8_t * pixels, uint8_t * bitplanes, int16_t bytesperline, int16_t planes, int16_t bitsperpixel);
- bool PCX_UnpackPixels(uint8_t * pixels, uint8_t * bitplanes, int16_t bytesperline, int16_t planes, int16_t bitsperpixel);
- void PCX_PackPixels(const int32_t p,uint8_t &c, uint8_t &n, CxFile &f);
- void PCX_PackPlanes(uint8_t* buff, const int32_t size, CxFile &f);
- void PCX_PixelsToPlanes(uint8_t* raw, int32_t width, uint8_t* buf, int32_t plane);
- void PCX_toh(PCXHEADER* p);
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximapng.cpp b/smelt/sdl/CxImage/ximapng.cpp deleted file mode 100644 index db2f636..0000000 --- a/smelt/sdl/CxImage/ximapng.cpp +++ /dev/null @@ -1,644 +0,0 @@ -/*
- * File: ximapng.cpp
- * Purpose: Platform Independent PNG Image Class Loader and Writer
- * 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximapng.h"
-
-#if CXIMAGE_SUPPORT_PNG
-
-#include "ximaiter.h"
-
-////////////////////////////////////////////////////////////////////////////////
-void CxImagePNG::ima_png_error(png_struct *png_ptr, char *message)
-{
- strcpy(info.szLastError,message);
-#if PNG_LIBPNG_VER > 10399
- longjmp(png_jmpbuf(png_ptr), 1);
-#else
- longjmp(png_ptr->jmpbuf, 1);
-#endif
-}
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-void CxImagePNG::expand2to4bpp(uint8_t* prow)
-{
- uint8_t *psrc,*pdst;
- uint8_t pos,idx;
- for(int32_t x=head.biWidth-1;x>=0;x--){
- psrc = prow + ((2*x)>>3);
- pdst = prow + ((4*x)>>3);
- pos = (uint8_t)(2*(3-x%4));
- idx = (uint8_t)((*psrc & (0x03<<pos))>>pos);
- pos = (uint8_t)(4*(1-x%2));
- *pdst &= ~(0x0F<<pos);
- *pdst |= (idx & 0x0F)<<pos;
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImagePNG::Decode(CxFile *hFile)
-{
- png_struct *png_ptr;
- png_info *info_ptr;
- uint8_t *row_pointers=NULL;
- CImageIterator iter(this);
-
- cx_try
- {
- /* Create and initialize the png_struct with the desired error handler
- * functions. If you want to use the default stderr and longjump method,
- * you can supply NULL for the last three parameters. We also supply the
- * the compiler header file version, so that we know if the application
- * was compiled with a compatible version of the library. REQUIRED */
- png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,(void *)NULL,NULL,NULL);
- if (png_ptr == NULL) cx_throw("Failed to create PNG structure");
-
- /* Allocate/initialize the memory for image information. REQUIRED. */
- info_ptr = png_create_info_struct(png_ptr);
- if (info_ptr == NULL) {
- png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
- cx_throw("Failed to initialize PNG info structure");
- }
-
- /* Set error handling if you are using the setjmp/longjmp method (this is
- * the normal method of doing things with libpng). REQUIRED unless you
- * set up your own error handlers in the png_create_read_struct() earlier. */
-#if PNG_LIBPNG_VER > 10399
- if (setjmp(png_jmpbuf(png_ptr))) {
-#else
- if (setjmp(png_ptr->jmpbuf)) {
-#endif
- /* Free all of the memory associated with the png_ptr and info_ptr */
- delete [] row_pointers;
- png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
- cx_throw("");
- }
-
- // use custom I/O functions
- png_set_read_fn(png_ptr, hFile, /*(png_rw_ptr)*/user_read_data);
- png_set_error_fn(png_ptr,info.szLastError,/*(png_error_ptr)*/user_error_fn,NULL);
-
- /* read the file information */
- png_read_info(png_ptr, info_ptr);
-
- png_uint_32 _width,_height;
- int _bit_depth,_color_type,_interlace_type,_compression_type,_filter_type;
-#if PNG_LIBPNG_VER > 10399
- png_get_IHDR(png_ptr,info_ptr,&_width,&_height,&_bit_depth,&_color_type,
- &_interlace_type,&_compression_type,&_filter_type);
-#else
- _width=info_ptr->width;
- _height=info_ptr->height;
- _bit_depth=info_ptr->bit_depth;
- _color_type=info_ptr->color_type;
- _interlace_type=info_ptr->interlace_type;
- //_compression_type=info_ptr->compression_type;
- //_filter_type=info_ptr->filter_type;
-#endif
-
- if (info.nEscape == -1){
- head.biWidth = _width;
- head.biHeight= _height;
- info.dwType = CXIMAGE_FORMAT_PNG;
-#if PNG_LIBPNG_VER > 10399
- longjmp(png_jmpbuf(png_ptr), 1);
-#else
- longjmp(png_ptr->jmpbuf, 1);
-#endif
- }
-
- /* calculate new number of channels */
- int32_t channels=0;
- switch(_color_type){
- case PNG_COLOR_TYPE_GRAY:
- case PNG_COLOR_TYPE_PALETTE:
- channels = 1;
- break;
- case PNG_COLOR_TYPE_GRAY_ALPHA:
- channels = 2;
- break;
- case PNG_COLOR_TYPE_RGB:
- channels = 3;
- break;
- case PNG_COLOR_TYPE_RGB_ALPHA:
- channels = 4;
- break;
- default:
- strcpy(info.szLastError,"unknown PNG color type");
-#if PNG_LIBPNG_VER > 10399
- longjmp(png_jmpbuf(png_ptr), 1);
-#else
- longjmp(png_ptr->jmpbuf, 1);
-#endif
- }
-
- //find the right pixel depth used for cximage
-#if PNG_LIBPNG_VER > 10399
- int pixel_depth = _bit_depth * png_get_channels(png_ptr,info_ptr);
-#else
- int pixel_depth = info_ptr->pixel_depth;
-#endif
- if (channels == 1 && pixel_depth>8) pixel_depth=8;
- if (channels == 2) pixel_depth=8;
- if (channels >= 3) pixel_depth=24;
-
- if (!Create(_width, _height, pixel_depth, CXIMAGE_FORMAT_PNG)){
-#if PNG_LIBPNG_VER > 10399
- longjmp(png_jmpbuf(png_ptr), 1);
-#else
- longjmp(png_ptr->jmpbuf, 1);
-#endif
- }
-
- /* get metrics */
- png_uint_32 _x_pixels_per_unit,_y_pixels_per_unit;
- int _phys_unit_type;
-#if PNG_LIBPNG_VER > 10399
- png_get_pHYs(png_ptr,info_ptr,&_x_pixels_per_unit,&_y_pixels_per_unit,&_phys_unit_type);
-#else
- _x_pixels_per_unit=info_ptr->x_pixels_per_unit;
- _y_pixels_per_unit=info_ptr->y_pixels_per_unit;
- _phys_unit_type=info_ptr->phys_unit_type;
-#endif
- switch (_phys_unit_type)
- {
- case PNG_RESOLUTION_UNKNOWN:
- SetXDPI(_x_pixels_per_unit);
- SetYDPI(_y_pixels_per_unit);
- break;
- case PNG_RESOLUTION_METER:
- SetXDPI((long)floor(_x_pixels_per_unit * 254.0 / 10000.0 + 0.5));
- SetYDPI((long)floor(_y_pixels_per_unit * 254.0 / 10000.0 + 0.5));
- break;
- }
-
- int _num_palette;
- png_colorp _palette;
-#if PNG_LIBPNG_VER > 10399
- png_get_PLTE(png_ptr,info_ptr,&_palette,&_num_palette);
-#else
- _num_palette=info_ptr->num_palette;
- _palette=info_ptr->palette;
-#endif
- if (_num_palette>0){
- SetPalette((rgb_color*)_palette,_num_palette);
- SetClrImportant(_num_palette);
- } else if (_bit_depth ==2) { //<DP> needed for 2 bpp grayscale PNGs
- SetPaletteColor(0,0,0,0);
- SetPaletteColor(1,85,85,85);
- SetPaletteColor(2,170,170,170);
- SetPaletteColor(3,255,255,255);
- } else SetGrayPalette(); //<DP> needed for grayscale PNGs
-
- int nshift = max(0,(_bit_depth>>3)-1)<<3;
-
- png_bytep _trans_alpha;
- int _num_trans;
- png_color_16p _trans_color;
-#if PNG_LIBPNG_VER > 10399
- png_get_tRNS(png_ptr,info_ptr,&_trans_alpha,&_num_trans,&_trans_color);
-#else
- _num_trans=info_ptr->num_trans;
-#endif
- if (_num_trans!=0){ //palette transparency
- if (_num_trans==1){
- if (_color_type == PNG_COLOR_TYPE_PALETTE){
- info.nBkgndIndex = _trans_color->index;
- } else{
- info.nBkgndIndex = _trans_color->gray>>nshift;
- }
- }
- if (_num_trans>1){
- RGBQUAD* pal=GetPalette();
- if (pal){
- uint32_t ip;
- if(_trans_alpha != 0) {
- for (ip=0;ip<min(head.biClrUsed,(unsigned long)_num_trans);ip++)
- pal[ip].rgbReserved=_trans_alpha[ip];
- }
- for (ip=_num_trans;ip<head.biClrUsed;ip++){
- pal[ip].rgbReserved=255;
- }
- info.bAlphaPaletteEnabled=true;
- }
- }
- }
-
- if (channels == 3){ //check RGB binary transparency
- /* seems unnecessary to call again, but the conditional must be important so... */
- if (png_get_tRNS(png_ptr,info_ptr,&_trans_alpha,&_num_trans,&_trans_color)){
- info.nBkgndColor.rgbRed = (uint8_t)(_trans_color->red>>nshift);
- info.nBkgndColor.rgbGreen = (uint8_t)(_trans_color->green>>nshift);
- info.nBkgndColor.rgbBlue = (uint8_t)(_trans_color->blue>>nshift);
- info.nBkgndColor.rgbReserved = 0;
- info.nBkgndIndex = 0;
- }
- }
-
- int32_t alpha_present = (channels - 1) % 2;
- if (alpha_present){
-#if CXIMAGE_SUPPORT_ALPHA // <vho>
- AlphaCreate();
-#else
- png_set_strip_alpha(png_ptr);
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
-
- // <vho> - flip the RGB pixels to BGR (or RGBA to BGRA)
- if (_color_type & PNG_COLOR_MASK_COLOR){
- png_set_bgr(png_ptr);
- }
-
- // <vho> - handle cancel
- if (info.nEscape)
-#if PNG_LIBPNG_VER > 10399
- longjmp(png_jmpbuf(png_ptr), 1);
-#else
- longjmp(png_ptr->jmpbuf, 1);
-#endif
-
- // row_bytes is the width x number of channels x (bit-depth / 8)
-#if PNG_LIBPNG_VER > 10399
- row_pointers = new uint8_t[png_get_rowbytes(png_ptr,info_ptr) + 8];
-#else
- row_pointers = new uint8_t[info_ptr->rowbytes + 8];
-#endif
-
-
- // turn on interlace handling
- int32_t number_passes = png_set_interlace_handling(png_ptr);
-
- if (number_passes>1){
- SetCodecOption( (ENCODE_INTERLACE) | GetCodecOption(CXIMAGE_FORMAT_PNG));
- } else {
- SetCodecOption(~(ENCODE_INTERLACE) & GetCodecOption(CXIMAGE_FORMAT_PNG));
- }
-
- int chan_offset = _bit_depth >> 3;
-#if PNG_LIBPNG_VER > 10399
- int pixel_offset = (_bit_depth * png_get_channels(png_ptr,info_ptr)) >> 3;
-#else
- int pixel_offset = info_ptr->pixel_depth >> 3;
-#endif
-
- for (int32_t pass=0; pass < number_passes; pass++) {
- iter.Upset();
- int32_t y=0;
- do {
-
- // <vho> - handle cancel
- if (info.nEscape)
-#if PNG_LIBPNG_VER > 10399
- longjmp(png_jmpbuf(png_ptr), 1);
-#else
- longjmp(png_ptr->jmpbuf, 1);
-#endif
-
-#if CXIMAGE_SUPPORT_ALPHA // <vho>
- if (AlphaIsValid()) {
-
- //compute the correct position of the line
- int32_t ax,ay;
- ay = head.biHeight-1-y;
- uint8_t* prow= iter.GetRow(ay);
-
- //recover data from previous scan
- if (_interlace_type && pass>0 && pass!=7){
- for(ax=0;ax<head.biWidth;ax++){
- int32_t px = ax * pixel_offset;
- if (channels == 2){
- row_pointers[px] = prow[ax];
- row_pointers[px+chan_offset]=AlphaGet(ax,ay);
- } else {
- int32_t qx = ax * 3;
- row_pointers[px] =prow[qx];
- row_pointers[px+chan_offset] =prow[qx+1];
- row_pointers[px+chan_offset*2]=prow[qx+2];
- row_pointers[px+chan_offset*3]=AlphaGet(ax,ay);
- }
- }
- }
-
- //read next row
- png_read_row(png_ptr, row_pointers, NULL);
-
- //RGBA -> RGB + A
- for(ax=0;ax<head.biWidth;ax++){
- int32_t px = ax * pixel_offset;
- if (channels == 2){
- prow[ax] = row_pointers[px];
- AlphaSet(ax,ay,row_pointers[px+chan_offset]);
- } else {
- int32_t qx = ax * 3;
- prow[qx] =row_pointers[px];
- prow[qx+1]=row_pointers[px+chan_offset];
- prow[qx+2]=row_pointers[px+chan_offset*2];
- AlphaSet(ax,ay,row_pointers[px+chan_offset*3]);
- }
- }
- } else
-#endif // CXIMAGE_SUPPORT_ALPHA // vho
- {
- //recover data from previous scan
- if (_interlace_type && pass>0){
-#if PNG_LIBPNG_VER > 10399
- iter.GetRow(row_pointers, png_get_rowbytes(png_ptr,info_ptr));
-#else
- iter.GetRow(row_pointers, info_ptr->rowbytes);
-#endif
- //re-expand buffer for images with bit depth > 8
- if (_bit_depth > 8){
- for(int32_t ax=(head.biWidth*channels-1);ax>=0;ax--)
- row_pointers[ax*chan_offset] = row_pointers[ax];
- }
- }
-
- //read next row
- png_read_row(png_ptr, row_pointers, NULL);
-
- //shrink 16 bit depth images down to 8 bits
- if (_bit_depth > 8){
- for(int32_t ax=0;ax<(head.biWidth*channels);ax++)
- row_pointers[ax] = row_pointers[ax*chan_offset];
- }
-
- //copy the pixels
-#if PNG_LIBPNG_VER > 10399
- iter.SetRow(row_pointers, png_get_rowbytes(png_ptr,info_ptr));
-#else
- iter.SetRow(row_pointers, info_ptr->rowbytes);
-#endif
- //<DP> expand 2 bpp images only in the last pass
- if (_bit_depth==2 && pass==(number_passes-1))
- expand2to4bpp(iter.GetRow());
-
- //go on
- iter.PrevRow();
- }
-
- y++;
- } while(y<head.biHeight);
- }
-
- delete [] row_pointers;
- row_pointers = NULL;
-
- /* read the rest of the file, getting any additional chunks in info_ptr - REQUIRED */
- png_read_end(png_ptr, info_ptr);
-
- /* clean up after the read, and free any memory allocated - REQUIRED */
- png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- if (info.nEscape == -1 && info.dwType == CXIMAGE_FORMAT_PNG) return true;
- return false;
- }
- /* that's it */
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImagePNG::Encode(CxFile *hFile)
-{
- if (EncodeSafeCheck(hFile)) return false;
-
- CImageIterator iter(this);
- uint8_t trans[256]; //for transparency (don't move)
- png_struct *png_ptr;
- png_info *info_ptr;
-
- cx_try
- {
- /* Create and initialize the png_struct with the desired error handler
- * functions. If you want to use the default stderr and longjump method,
- * you can supply NULL for the last three parameters. We also check that
- * the library version is compatible with the one used at compile time,
- * in case we are using dynamically linked libraries. REQUIRED.
- */
- png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,(void *)NULL,NULL,NULL);
- if (png_ptr == NULL) cx_throw("Failed to create PNG structure");
-
- /* Allocate/initialize the image information data. REQUIRED */
- info_ptr = png_create_info_struct(png_ptr);
- if (info_ptr == NULL){
- png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
- cx_throw("Failed to initialize PNG info structure");
- }
-
- /* Set error handling. REQUIRED if you aren't supplying your own
- * error hadnling functions in the png_create_write_struct() call.
- */
- if (setjmp(png_ptr->jmpbuf)){
- /* If we get here, we had a problem reading the file */
- if (info_ptr->palette) free(info_ptr->palette);
- png_destroy_write_struct(&png_ptr, (png_infopp)&info_ptr);
- cx_throw("Error saving PNG file");
- }
-
- /* set up the output control */
- //png_init_io(png_ptr, hFile);
-
- // use custom I/O functions
- png_set_write_fn(png_ptr,hFile,/*(png_rw_ptr)*/user_write_data,/*(png_flush_ptr)*/user_flush_data);
-
- /* set the file information here */
- info_ptr->width = GetWidth();
- info_ptr->height = GetHeight();
- info_ptr->pixel_depth = (uint8_t)GetBpp();
- info_ptr->channels = (GetBpp()>8) ? (uint8_t)3: (uint8_t)1;
- info_ptr->bit_depth = (uint8_t)(GetBpp()/info_ptr->channels);
- info_ptr->compression_type = info_ptr->filter_type = 0;
- info_ptr->valid = 0;
-
- // set interlace type
- DWORD codec_opt = GetCodecOption(CXIMAGE_FORMAT_PNG);
- if (codec_opt & CxImagePNG::ENCODE_INTERLACE)
- info_ptr->interlace_type = PNG_INTERLACE_ADAM7;
- else
- info_ptr->interlace_type = PNG_INTERLACE_NONE;
-
- /* set compression level */
- int32_t compress_level;
- switch (codec_opt & CxImagePNG::ENCODE_COMPRESSION_MASK)
- {
- case ENCODE_NO_COMPRESSION:
- compress_level = Z_NO_COMPRESSION;
- break;
- case ENCODE_BEST_SPEED:
- compress_level = Z_BEST_SPEED;
- break;
- case ENCODE_BEST_COMPRESSION:
- compress_level = Z_BEST_COMPRESSION;
- break;
- default:
- compress_level = Z_DEFAULT_COMPRESSION;
- break;
- }
- png_set_compression_level(png_ptr, compress_level);
-
- bool bGrayScale = IsGrayScale();
-
- if (GetNumColors()){
- if (bGrayScale){
- info_ptr->color_type = PNG_COLOR_TYPE_GRAY;
- } else {
- info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
- }
- } else {
- info_ptr->color_type = PNG_COLOR_TYPE_RGB;
- }
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()){
- info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
- info_ptr->channels++;
- info_ptr->bit_depth = 8;
- info_ptr->pixel_depth += 8;
- }
-#endif
-
- /* set background */
- png_color_16 image_background={ 0, 255, 255, 255, 0 };
- RGBQUAD tc = GetTransColor();
- if (info.nBkgndIndex>=0) {
- image_background.blue = tc.rgbBlue;
- image_background.green = tc.rgbGreen;
- image_background.red = tc.rgbRed;
- }
- png_set_bKGD(png_ptr, info_ptr, &image_background);
-
- /* set metrics */
- png_set_pHYs(png_ptr, info_ptr, head.biXPelsPerMeter, head.biYPelsPerMeter, PNG_RESOLUTION_METER);
-
- png_set_IHDR(png_ptr, info_ptr, info_ptr->width, info_ptr->height, info_ptr->bit_depth,
- info_ptr->color_type, info_ptr->interlace_type,
- PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
-
- //<DP> simple transparency
- if (info.nBkgndIndex >= 0){
- info_ptr->num_trans = 1;
- info_ptr->valid |= PNG_INFO_tRNS;
- info_ptr->trans_alpha = trans;
- info_ptr->trans_color.index = (uint8_t)info.nBkgndIndex;
- info_ptr->trans_color.red = tc.rgbRed;
- info_ptr->trans_color.green = tc.rgbGreen;
- info_ptr->trans_color.blue = tc.rgbBlue;
- info_ptr->trans_color.gray = info_ptr->trans_color.index;
-
- // the transparency indexes start from 0 for non grayscale palette
- if (!bGrayScale && head.biClrUsed && info.nBkgndIndex)
- SwapIndex(0,(uint8_t)info.nBkgndIndex);
- }
-
- /* set the palette if there is one */
- if (GetPalette()){
- if (!bGrayScale){
- info_ptr->valid |= PNG_INFO_PLTE;
- }
-
- int32_t nc = GetClrImportant();
- if (nc==0) nc = GetNumColors();
-
- if (info.bAlphaPaletteEnabled){
- for(uint16_t ip=0; ip<nc;ip++)
- trans[ip]=GetPaletteColor((uint8_t)ip).rgbReserved;
- info_ptr->num_trans = (uint16_t)nc;
- info_ptr->valid |= PNG_INFO_tRNS;
- info_ptr->trans_alpha = trans;
- }
-
- // copy the palette colors
- info_ptr->palette = new png_color[nc];
- info_ptr->num_palette = (png_uint_16) nc;
- for (int32_t i=0; i<nc; i++)
- GetPaletteColor(i, &info_ptr->palette[i].red, &info_ptr->palette[i].green, &info_ptr->palette[i].blue);
- }
-
-#if CXIMAGE_SUPPORT_ALPHA // <vho>
- //Merge the transparent color with the alpha channel
- if (AlphaIsValid() && head.biBitCount==24 && info.nBkgndIndex>=0){
- for(int32_t y=0; y < head.biHeight; y++){
- for(int32_t x=0; x < head.biWidth ; x++){
- RGBQUAD c=GetPixelColor(x,y,false);
- if (*(int32_t*)&c==*(int32_t*)&tc)
- AlphaSet(x,y,0);
- } } }
-#endif // CXIMAGE_SUPPORT_ALPHA // <vho>
-
- int32_t row_size = max(info.dwEffWidth, info_ptr->width*info_ptr->channels*(info_ptr->bit_depth/8));
- info_ptr->rowbytes = row_size;
- uint8_t *row_pointers = new uint8_t[row_size];
-
- /* write the file information */
- png_write_info(png_ptr, info_ptr);
-
- //interlace handling
- int32_t num_pass = png_set_interlace_handling(png_ptr);
- for (int32_t pass = 0; pass < num_pass; pass++){
- //write image
- iter.Upset();
- int32_t ay=head.biHeight-1;
- RGBQUAD c;
- do {
-#if CXIMAGE_SUPPORT_ALPHA // <vho>
- if (AlphaIsValid()){
- for (int32_t ax=head.biWidth-1; ax>=0;ax--){
- c = BlindGetPixelColor(ax,ay);
- int32_t px = ax * info_ptr->channels;
- if (!bGrayScale){
- row_pointers[px++]=c.rgbRed;
- row_pointers[px++]=c.rgbGreen;
- }
- row_pointers[px++]=c.rgbBlue;
- row_pointers[px] = AlphaGet(ax,ay);
- }
- png_write_row(png_ptr, row_pointers);
- ay--;
- }
- else
-#endif //CXIMAGE_SUPPORT_ALPHA // <vho>
- {
- iter.GetRow(row_pointers, row_size);
- if (info_ptr->color_type == PNG_COLOR_TYPE_RGB) //HACK BY OP
- RGBtoBGR(row_pointers, row_size);
- png_write_row(png_ptr, row_pointers);
- }
- } while(iter.PrevRow());
- }
-
- delete [] row_pointers;
- row_pointers = NULL;
-
- //if necessary, restore the original palette
- if (!bGrayScale && head.biClrUsed && info.nBkgndIndex>0)
- SwapIndex((uint8_t)info.nBkgndIndex,0);
-
- /* It is REQUIRED to call this to finish writing the rest of the file */
- png_write_end(png_ptr, info_ptr);
-
- /* if you malloced the palette, free it here */
- if (info_ptr->palette){
- delete [] (info_ptr->palette);
- info_ptr->palette = NULL;
- }
-
- /* clean up after the write, and free any memory allocated */
- png_destroy_write_struct(&png_ptr, (png_infopp)&info_ptr);
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- return FALSE;
- }
- /* that's it */
- return TRUE;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_PNG
diff --git a/smelt/sdl/CxImage/ximapng.h b/smelt/sdl/CxImage/ximapng.h deleted file mode 100644 index bc53e52..0000000 --- a/smelt/sdl/CxImage/ximapng.h +++ /dev/null @@ -1,95 +0,0 @@ -/*
- * File: ximapng.h
- * Purpose: PNG Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImagePNG (c) 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- *
- * Special thanks to Troels Knakkergaard for new features, enhancements and bugfixes
- *
- * original CImagePNG and CImageIterator implementation are:
- * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra(at)servidor(dot)unam(dot)mx>
- *
- * libpng Copyright (c) 1998-2003 Glenn Randers-Pehrson
- * ==========================================================
- */
-#if !defined(__ximaPNG_h)
-#define __ximaPNG_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_PNG
-
-extern "C" {
-#ifdef _LINUX
- #undef _DLL
- #include <png.h>
-#else
- #include "png.h"
-#endif
-}
-
-class CxImagePNG: public CxImage
-{
-public:
- CxImagePNG(): CxImage(CXIMAGE_FORMAT_PNG) {}
-
-// bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_PNG);}
-// bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_PNG);}
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-
- enum CODEC_OPTION
- {
- ENCODE_INTERLACE = 0x01,
- // Exclusive compression types : 3 bit wide field
- ENCODE_COMPRESSION_MASK = 0x0E,
- ENCODE_NO_COMPRESSION = 1 << 1,
- ENCODE_BEST_SPEED = 2 << 1,
- ENCODE_BEST_COMPRESSION = 3 << 1,
- ENCODE_DEFAULT_COMPRESSION = 4 << 1
- };
-
-protected:
- void ima_png_error(png_struct *png_ptr, char *message);
- void expand2to4bpp(uint8_t* prow);
-
- static void PNGAPI user_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
- {
- CxFile* hFile = (CxFile*)png_get_io_ptr(png_ptr);
- if (hFile == NULL || hFile->Read(data,1,length) != length) png_error(png_ptr, "Read Error");
- }
-
- static void PNGAPI user_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
- {
- CxFile* hFile = (CxFile*)png_get_io_ptr(png_ptr);
- if (hFile == NULL || hFile->Write(data,1,length) != length) png_error(png_ptr, "Write Error");
- }
-
- static void PNGAPI user_flush_data(png_structp png_ptr)
- {
- CxFile* hFile = (CxFile*)png_get_io_ptr(png_ptr);
- if (hFile == NULL || !hFile->Flush()) png_error(png_ptr, "Flush Error");
- }
-
- static void PNGAPI user_error_fn(png_structp png_ptr,png_const_charp error_msg)
- {
-#if PNG_LIBPNG_VER > 10399
- strncpy((char*)png_get_error_ptr(png_ptr),error_msg,255);
- longjmp(png_jmpbuf(png_ptr), 1);
-#else
- strncpy((char*)png_ptr->error_ptr,error_msg,255);
- longjmp(png_ptr->jmpbuf, 1);
-#endif
- }
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximapsd.cpp b/smelt/sdl/CxImage/ximapsd.cpp deleted file mode 100644 index 2d8417b..0000000 --- a/smelt/sdl/CxImage/ximapsd.cpp +++ /dev/null @@ -1,1307 +0,0 @@ -/*
- * File: ximapsd.cpp
- * Purpose: Platform Independent PSD Image Class Loader
- * Dec/2010 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- *
- * libpsd (c) 2004-2007 Graphest Software
- *
- * Based on MyPSD class by Iosif Hamlatzis
- * Details: http://www.codeproject.com/KB/graphics/MyPSD.aspx
- * Cleaned up a bit and ported to CxImage by Vitaly Ovchinnikov
- * Send feedback to vitaly(dot)ovchinnikov(at)gmail.com
- */
-
-#include "ximapsd.h"
-
-#if CXIMAGE_SUPPORT_PSD
-
-enum {
- PSD_FILE_HEADER,
- PSD_COLOR_MODE_DATA,
- PSD_IMAGE_RESOURCE,
- PSD_LAYER_AND_MASK_INFORMATION,
- PSD_IMAGE_DATA,
- PSD_DONE
-};
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_USE_LIBPSD == 0
-// MyPSD.h /////////////////////////////////////////////////////////////////////
-
-#ifndef __MyPSD_H__
-#define __MyPSD_H__
-
-namespace MyPSD
-{
-
- class CPSD
- {
- struct HEADER_INFO
- {
- //Table 2-12: HeaderInfo Color spaces
- // Color-ID Name Description
- //-------------------------------------------
- // 0 Bitmap // Probably means black & white
- // 1 Grayscale The first value in the color data is the gray value, from 0...10000.
- // 2 Indexed
- // 3 RGB The first three values in the color data are red, green, and blue.
- // They are full unsigned 16–bit values as in Apple’s RGBColor data
- // structure. Pure red=65535,0,0.
- // 4 CMYK The four values in the color data are cyan, magenta, yellow, and
- // black. They are full unsigned 16–bit values. 0=100% ink. Pure
- // cyan=0,65535,65535,65535.
- // 7 Multichannel // Have no idea
- // 8 Duotone
- // 9 Lab The first three values in the color data are lightness, a chrominance,
- // and b chrominance.
- // Lightness is a 16–bit value from 0...100. The chromanance components
- // are each 16–bit values from –128...127. Gray values
- // are represented by chrominance components of 0. Pure
- // white=100,0,0.
- short nChannels;
- int nHeight;
- int nWidth;
- short nBitsPerPixel;
- short nColourMode;
- HEADER_INFO();
- };
-
- struct COLOUR_MODE_DATA
- {
- int nLength;
- unsigned char* ColourData;
- COLOUR_MODE_DATA();
- };
-
-
- struct IMAGE_RESOURCE
- {
- // Table 2–1: Image resource block
- // Type Name Description
- //-------------------------------------------
- // OSType Type Photoshop always uses its signature, 8BIM
- // int16 ID Unique identifier
- // PString Name A pascal string, padded to make size even (a null name consists of two bytes of 0)
- // Pascal style string where the first byte gives the length of the
- // string and the content bytes follow.
- // int32 Size Actual size of resource data. This does not include the
- // Type, ID, Name, or Size fields.
- // Variable Data Resource data, padded to make size even
- int nLength;
- char OSType[4];
- short nID;
- unsigned char* Name;
- int nSize;
- IMAGE_RESOURCE();
- void Reset();
- };
-
- struct RESOLUTION_INFO
- {
- // Table A-6: ResolutionInfo structure
- // Type Name Description
- //-------------------------------------------
- // Fixed hRes Horizontal resolution in pixels per inch.
- // int hResUnit 1=display horizontal resolution in pixels per inch;
- // 2=display horizontal resolution in pixels per cm.
- // short widthUnit Display width as 1=inches; 2=cm; 3=points; 4=picas; 5=columns.
- // Fixed vRes Vertical resolution in pixels per inch.
- // int vResUnit 1=display vertical resolution in pixels per inch;
- // 2=display vertical resolution in pixels per cm.
- // short heightUnit Display height as 1=inches; 2=cm; 3=points; 4=picas; 5=columns.
- short hRes;
- int hResUnit;
- short widthUnit;
-
- short vRes;
- int vResUnit;
- short heightUnit;
- RESOLUTION_INFO();
- };
-
- struct RESOLUTION_INFO_v2 // Obsolete - Photoshop 2.0
- {
- short nChannels;
- short nRows;
- short nColumns;
- short nDepth;
- short nMode;
- RESOLUTION_INFO_v2();
- };
-
- struct DISPLAY_INFO
- {
- // This structure contains display information about each channel.
- //Table A-7: DisplayInfo Color spaces
- // Color-ID Name Description
- //-------------------------------------------
- // 0 RGB The first three values in the color data are red, green, and blue.
- // They are full unsigned 16–bit values as in Apple’s RGBColor data
- // structure. Pure red=65535,0,0.
- // 1 HSB The first three values in the color data are hue, saturation, and
- // brightness. They are full unsigned 16–bit values as in Apple’s
- // HSVColor data structure. Pure red=0,65535, 65535.
- // 2 CMYK The four values in the color data are cyan, magenta, yellow, and
- // black. They are full unsigned 16–bit values. 0=100% ink. Pure
- // cyan=0,65535,65535,65535.
- // 7 Lab The first three values in the color data are lightness, a chrominance,
- // and b chrominance.
- // Lightness is a 16–bit value from 0...10000. The chromanance components
- // are each 16–bit values from –12800...12700. Gray values
- // are represented by chrominance components of 0. Pure
- // white=10000,0,0.
- // 8 grayscale The first value in the color data is the gray value, from 0...10000.
- short ColourSpace;
- short Colour[4];
- short Opacity; // 0..100
- bool kind; // selected = 0, protected = 1
- unsigned char padding; // should be zero
- DISPLAY_INFO();
- };
- struct THUMBNAIL
- {
- // Adobe Photoshop 5.0 and later stores thumbnail information for preview
- // display in an image resource block. These resource blocks consist of an
- // 28 byte header, followed by a JFIF thumbnail in RGB (red, green, blue)
- // for both Macintosh and Windows. Adobe Photoshop 4.0 stored the
- // thumbnail information in the same format except the data section is
- // (blue, green, red). The Adobe Photoshop 4.0 format is at resource ID
- // and the Adobe Photoshop 5.0 format is at resource ID 1036.
- // Table 2–5: Thumnail resource header
- // Type Name Description
- //-------------------------------------------
- // 4 bytes format = 1 (kJpegRGB). Also supports kRawRGB (0).
- // 4 bytes width Width of thumbnail in pixels.
- // 4 bytes height Height of thumbnail in pixels.
- // 4 bytes widthbytes Padded row bytes as (width * bitspixel + 31) / 32 * 4.
- // 4 bytes size Total size as widthbytes * height * planes
- // 4 bytes compressedsize Size after compression. Used for consistentcy check.
- // 2 bytes bitspixel = 24. Bits per pixel.
- // 2 bytes planes = 1. Number of planes.
- // Variable Data JFIF data in RGB format.
- // Note: For resource ID 1033 the data is in BGR format.
- int nFormat;
- int nWidth;
- int nHeight;
- int nWidthBytes;
- int nSize;
- int nCompressedSize;
- short nBitPerPixel;
- short nPlanes;
- unsigned char* Data;
- THUMBNAIL();
- };
-
-
- CxImage &m_image;
-
- HEADER_INFO header_info;
-
- COLOUR_MODE_DATA colour_mode_data;
- short mnColourCount;
- short mnTransparentIndex;
-
- IMAGE_RESOURCE image_resource;
-
- int mnGlobalAngle;
-
- RESOLUTION_INFO resolution_info;
- bool mbResolutionInfoFilled;
-
- RESOLUTION_INFO_v2 resolution_info_v2;
- bool mbResolutionInfoFilled_v2;
-
- DISPLAY_INFO display_info;
- bool mbDisplayInfoFilled;
-
- THUMBNAIL thumbnail;
- bool mbThumbNailFilled;
-
- bool mbCopyright;
-
- int Calculate(unsigned char* c, int nDigits);
- void XYZToRGB(const double X, const double Y, const double Z, int &R, int &G, int &B);
- void LabToRGB(const int L, const int a, const int b, int &R, int &G, int &B );
- void CMYKToRGB(const double C, const double M, const double Y, const double K, int &R, int &G, int &B);
-
- bool ReadHeader(CxFile &f, HEADER_INFO& header_info);
- bool ReadColourModeData(CxFile &f, COLOUR_MODE_DATA& colour_mode_data);
- bool ReadImageResource(CxFile &f, IMAGE_RESOURCE& image_resource);
- bool ReadLayerAndMaskInfoSection(CxFile &f); // Actually ignore it
- int ReadImageData(CxFile &f);
-
- int DecodeRawData(CxFile &pFile);
- int DecodeRLEData(CxFile &pFile);
-
- void ProccessBuffer(unsigned char* pData = 0);
-
- public:
- CPSD(CxImage &image);
- ~CPSD();
-
- int Load(LPCTSTR szPathName);
- int Load(CxFile &file);
-
- bool ThumbNailIncluded() const { return mbThumbNailFilled; }
- void DPI(int &x, int &y) const { x = resolution_info.hRes; y = resolution_info.vRes; }
- void Dimensions(int &cx, int &cy) const { cx = header_info.nWidth; cy = header_info.nHeight; }
- int BitsPerPixel() const { return header_info.nBitsPerPixel; }
- int GlobalAngle() const { return mnGlobalAngle; }
- bool IsCopyright() const { return mbCopyright; }
- HBITMAP Detach();
- };
-}
-
-#endif // __MyPSD_H__
-
-// MyPSD.cpp ///////////////////////////////////////////////////////////////////
-
-
-inline int dti(double value) { return (int)floor(value+.5f); }
-
-#define assert(a)
-
-#define mypsd_fread(a, b, c, d) d.Read(a, b, c)
-#define mypsd_fseek(a, b, c) a.Seek(b, c)
-#define mypsd_feof(a) a.Eof()
-
-namespace MyPSD
-{
- CPSD::CPSD(CxImage &image) : m_image(image)
- {
- mbThumbNailFilled = false;
- mbDisplayInfoFilled = false;
- mbResolutionInfoFilled = false;
- mbResolutionInfoFilled_v2 = false;
- mnGlobalAngle = 30;
- mbCopyright = false;
- mnColourCount = -1;
- mnTransparentIndex = -1;
- }
- CPSD::~CPSD()
- {
- // free memory
- if ( 0 < colour_mode_data.nLength )
- delete[] colour_mode_data.ColourData;
- colour_mode_data.ColourData = 0;
-
- if ( image_resource.Name )
- delete[] image_resource.Name;
- image_resource.Name = 0;
- }
-
- int CPSD::Calculate(unsigned char* c, int nDigits)
- {
- int nValue = 0;
-
- for(int n = 0; n < nDigits; ++n)
- nValue = ( nValue << 8 ) | *(c+n);
-
- return nValue;
- };
-
- void CPSD::XYZToRGB(const double X, const double Y, const double Z, int &R, int &G, int &B)
- {
- // Standards used Observer = 2, Illuminant = D65
- // ref_X = 95.047, ref_Y = 100.000, ref_Z = 108.883
- const double ref_X = 95.047;
- const double ref_Y = 100.000;
- const double ref_Z = 108.883;
-
- double var_X = X / 100.0;
- double var_Y = Y / 100.0;
- double var_Z = Z / 100.0;
-
- double var_R = var_X * 3.2406 + var_Y * (-1.5372) + var_Z * (-0.4986);
- double var_G = var_X * (-0.9689) + var_Y * 1.8758 + var_Z * 0.0415;
- double var_B = var_X * 0.0557 + var_Y * (-0.2040) + var_Z * 1.0570;
-
- if ( var_R > 0.0031308 )
- var_R = 1.055 * ( pow(var_R, 1/2.4) ) - 0.055;
- else
- var_R = 12.92 * var_R;
-
- if ( var_G > 0.0031308 )
- var_G = 1.055 * ( pow(var_G, 1/2.4) ) - 0.055;
- else
- var_G = 12.92 * var_G;
-
- if ( var_B > 0.0031308 )
- var_B = 1.055 * ( pow(var_B, 1/2.4) )- 0.055;
- else
- var_B = 12.92 * var_B;
-
- R = (int)(var_R * 256.0);
- G = (int)(var_G * 256.0);
- B = (int)(var_B * 256.0);
- };
-
- void CPSD::LabToRGB(const int L, const int a, const int b, int &R, int &G, int &B )
- {
- // For the conversion we first convert values to XYZ and then to RGB
- // Standards used Observer = 2, Illuminant = D65
- // ref_X = 95.047, ref_Y = 100.000, ref_Z = 108.883
- const double ref_X = 95.047;
- const double ref_Y = 100.000;
- const double ref_Z = 108.883;
-
- double var_Y = ( (double)L + 16.0 ) / 116.0;
- double var_X = (double)a / 500.0 + var_Y;
- double var_Z = var_Y - (double)b / 200.0;
-
- if ( pow(var_Y, 3) > 0.008856 )
- var_Y = pow(var_Y, 3);
- else
- var_Y = ( var_Y - 16 / 116 ) / 7.787;
-
- if ( pow(var_X, 3) > 0.008856 )
- var_X = pow(var_X, 3);
- else
- var_X = ( var_X - 16 / 116 ) / 7.787;
-
- if ( pow(var_Z, 3) > 0.008856 )
- var_Z = pow(var_Z, 3);
- else
- var_Z = ( var_Z - 16 / 116 ) / 7.787;
-
- double X = ref_X * var_X;
- double Y = ref_Y * var_Y;
- double Z = ref_Z * var_Z;
-
- XYZToRGB(X, Y, Z, R, G, B);
- };
-
- void CPSD::CMYKToRGB(const double C, const double M, const double Y, const double K, int &R, int &G, int &B )
- {
- R = dti( ( 1.0f - ( C *( 1.0f - K ) + K ) ) * 255.0f );
- G = dti( ( 1.0f - ( M *( 1.0f - K ) + K ) ) * 255.0f );
- B = dti( ( 1.0f - ( Y *( 1.0f - K ) + K ) ) * 255.0f );
- };
-
- bool CPSD::ReadLayerAndMaskInfoSection(CxFile &pFile) // Actually ignore it
- {
- bool bSuccess = false;
-
- unsigned char DataLength[4];
- int nBytesRead = 0;
- int nItemsRead = (int)(int)mypsd_fread(&DataLength, sizeof(DataLength), 1, pFile);
-
- int nTotalBytes = Calculate( DataLength, sizeof(DataLength) );
-
- unsigned char data[1];
- while( !mypsd_feof( pFile ) && ( nBytesRead < nTotalBytes ) )
- {
- data[0] = '\0';
- nItemsRead = (int)(int)mypsd_fread(&data, sizeof(data), 1, pFile);
- nBytesRead += nItemsRead * sizeof(data);
- }
-
- assert ( nBytesRead == nTotalBytes );
- if ( nBytesRead == nTotalBytes )
- bSuccess = true;
-
- return bSuccess;
- }
- bool CPSD::ReadImageResource(CxFile &pFile, IMAGE_RESOURCE& image_resource)
- {
- bool bSuccess = false;
-
- unsigned char Length[4];
- int nItemsRead = (int)(int)mypsd_fread(&Length, sizeof(Length), 1, pFile);
-
- image_resource.nLength = Calculate( Length, sizeof(image_resource.nLength) );
-
- int nBytesRead = 0;
- int nTotalBytes = image_resource.nLength;
-
- while( !mypsd_feof( pFile ) && ( nBytesRead < nTotalBytes ) )
- {
- nItemsRead = 0;
- image_resource.Reset();
-
- nItemsRead = (int)(int)mypsd_fread(&image_resource.OSType, sizeof(image_resource.OSType), 1, pFile);
- nBytesRead += nItemsRead * sizeof(image_resource.OSType);
-
- assert ( 0 == (nBytesRead % 2) );
- if (::memcmp(image_resource.OSType, "8BIM", 4) == 0)
- {
- unsigned char ID[2];
- nItemsRead = (int)(int)mypsd_fread(&ID, sizeof(ID), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ID);
-
- image_resource.nID = (short)Calculate( ID, sizeof(ID) );
-
- unsigned char SizeOfName;
- nItemsRead = (int)(int)mypsd_fread(&SizeOfName, sizeof(SizeOfName), 1, pFile);
- nBytesRead += nItemsRead * sizeof(SizeOfName);
-
- int nSizeOfName = Calculate( &SizeOfName, sizeof(SizeOfName) );
- if ( 0 < nSizeOfName )
- {
- image_resource.Name = new unsigned char[nSizeOfName];
- nItemsRead = (int)(int)mypsd_fread(image_resource.Name, nSizeOfName, 1, pFile);
- nBytesRead += nItemsRead * nSizeOfName;
- }
-
- if ( 0 == (nSizeOfName % 2) )
- {
- nItemsRead = (int)(int)mypsd_fread(&SizeOfName, sizeof(SizeOfName), 1, pFile);
- nBytesRead += nItemsRead * sizeof(SizeOfName);
- }
-
- unsigned char Size[4];
- nItemsRead = (int)(int)mypsd_fread(&Size, sizeof(Size), 1, pFile);
- nBytesRead += nItemsRead * sizeof(Size);
-
- image_resource.nSize = Calculate( Size, sizeof(image_resource.nSize) );
-
- if ( 0 != (image_resource.nSize % 2) ) // resource data must be even
- image_resource.nSize++;
- if ( 0 < image_resource.nSize )
- {
- unsigned char IntValue[4];
- unsigned char ShortValue[2];
-
- switch( image_resource.nID )
- {
- case 1000:
- {
- // Obsolete - Photoshop 2.0
- mbResolutionInfoFilled_v2 = true;
-
- nItemsRead = (int)(int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- resolution_info_v2.nChannels = (short)Calculate(ShortValue, sizeof(resolution_info_v2.nChannels) );
- nItemsRead = (int)(int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- resolution_info_v2.nRows = (short)Calculate(ShortValue, sizeof(resolution_info_v2.nRows) );
- nItemsRead = (int)(int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- resolution_info_v2.nColumns = (short)Calculate(ShortValue, sizeof(resolution_info_v2.nColumns) );
- nItemsRead = (int)(int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- resolution_info_v2.nDepth = (short)Calculate(ShortValue, sizeof(resolution_info_v2.nDepth) );
- nItemsRead = (int)(int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- resolution_info_v2.nMode = (short)Calculate(ShortValue, sizeof(resolution_info_v2.nMode) );
- }
- break;
- case 1005:
- {
- mbResolutionInfoFilled = true;
-
- nItemsRead = (int)(int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- resolution_info.hRes = (short)Calculate(ShortValue, sizeof(resolution_info.hRes) );
- nItemsRead = (int)(int)mypsd_fread(&IntValue, sizeof(IntValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(IntValue);
- resolution_info.hResUnit = Calculate(IntValue, sizeof(resolution_info.hResUnit) );
- nItemsRead = (int)(int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- resolution_info.widthUnit = (short)Calculate(ShortValue, sizeof(resolution_info.widthUnit) );
-
- nItemsRead = (int)(int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- resolution_info.vRes = (short)Calculate(ShortValue, sizeof(resolution_info.vRes) );
- nItemsRead = (int)(int)mypsd_fread(&IntValue, sizeof(IntValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(IntValue);
- resolution_info.vResUnit = Calculate(IntValue, sizeof(resolution_info.vResUnit) );
- nItemsRead = (int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- resolution_info.heightUnit = (short)Calculate(ShortValue, sizeof(resolution_info.heightUnit) );
- }
- break;
- case 1007:
- {
- mbDisplayInfoFilled = true;
-
- nItemsRead = (int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- display_info.ColourSpace = (short)Calculate(ShortValue, sizeof(display_info.ColourSpace) );
-
- for ( unsigned int n = 0; n < 4; ++n )
- {
- nItemsRead = (int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- display_info.Colour[n] = (short)Calculate(ShortValue, sizeof(display_info.Colour[n]) );
- }
-
- nItemsRead = (int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- display_info.Opacity = (short)Calculate(ShortValue, sizeof(display_info.Opacity) );
- assert ( 0 <= display_info.Opacity );
- assert ( 100 >= display_info.Opacity );
-
- unsigned char c[1];
- nItemsRead = (int)mypsd_fread(&c, sizeof(c), 1, pFile);
- nBytesRead += nItemsRead * sizeof(c);
- ( 1 == Calculate(c, sizeof(c) ) ) ? display_info.kind = true : display_info.kind = false;
-
- nItemsRead = (int)mypsd_fread(&c, sizeof(c), 1, pFile);
- nBytesRead += nItemsRead * sizeof(c);
- display_info.padding = (unsigned int)Calculate(c, sizeof(c) );
- assert ( 0 == display_info.padding );
- }
- break;
- case 1034:
- {
- nItemsRead = (int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- ( 1 == Calculate(ShortValue, sizeof(ShortValue) ) ) ? mbCopyright = true : mbCopyright = false;
- }
- break;
- case 1033:
- case 1036:
- {
- mbThumbNailFilled = true;
-
- nItemsRead = (int)mypsd_fread(&IntValue, sizeof(IntValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(IntValue);
- thumbnail.nFormat = Calculate(IntValue, sizeof(thumbnail.nFormat) );
-
- nItemsRead = (int)mypsd_fread(&IntValue, sizeof(IntValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(IntValue);
- thumbnail.nWidth = Calculate(IntValue, sizeof(thumbnail.nWidth) );
-
- nItemsRead = (int)mypsd_fread(&IntValue, sizeof(IntValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(IntValue);
- thumbnail.nHeight = Calculate(IntValue, sizeof(thumbnail.nHeight) );
-
- nItemsRead = (int)mypsd_fread(&IntValue, sizeof(IntValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(IntValue);
- thumbnail.nWidthBytes = Calculate(IntValue, sizeof(thumbnail.nWidthBytes) );
-
- nItemsRead = (int)mypsd_fread(&IntValue, sizeof(IntValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(IntValue);
- thumbnail.nSize = Calculate(IntValue, sizeof(thumbnail.nSize) );
-
- nItemsRead = (int)mypsd_fread(&IntValue, sizeof(IntValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(IntValue);
- thumbnail.nCompressedSize = Calculate(IntValue, sizeof(thumbnail.nCompressedSize) );
-
- nItemsRead = (int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- thumbnail.nBitPerPixel = (short)Calculate(ShortValue, sizeof(thumbnail.nBitPerPixel) );
-
- nItemsRead = (int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- thumbnail.nPlanes = (short)Calculate(ShortValue, sizeof(thumbnail.nPlanes) );
-
- int nTotalData = image_resource.nSize - 28; // header
- unsigned char* buffer = new unsigned char[nTotalData];
- unsigned char c[1];
- if ( 1033 == image_resource.nID )
- {
- // In BGR format
- for (int n = 0; n < nTotalData; n = n +3 )
- {
- nItemsRead = (int)mypsd_fread(&c, sizeof(unsigned char), 1, pFile);
- nBytesRead += nItemsRead * sizeof(unsigned char);
- buffer[n+2] = (unsigned char)Calculate(c, sizeof(unsigned char) );
- nItemsRead = (int)mypsd_fread(&c, sizeof(unsigned char), 1, pFile);
- nBytesRead += nItemsRead * sizeof(unsigned char);
- buffer[n+1] = (unsigned char)Calculate(c, sizeof(BYTE) );
- nItemsRead = (int)mypsd_fread(&c, sizeof(unsigned char), 1, pFile);
- nBytesRead += nItemsRead * sizeof(unsigned char);
- buffer[n] = (unsigned char)Calculate(c, sizeof(unsigned char) );
- }
- }
- else if ( 1036 == image_resource.nID )
- {
- // In RGB format
- for (int n = 0; n < nTotalData; ++n )
- {
- nItemsRead = (int)mypsd_fread(&c, sizeof(BYTE), 1, pFile);
- nBytesRead += nItemsRead * sizeof(BYTE);
- buffer[n] = (BYTE)Calculate(c, sizeof(BYTE) );
- }
- }
-
- delete[] buffer;
- buffer = 0;
- }
- break;
- case 1037:
- {
- nItemsRead = (int)mypsd_fread(&IntValue, sizeof(IntValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(IntValue);
- mnGlobalAngle = Calculate(IntValue, sizeof(mnGlobalAngle) );
- }
- break;
- case 1046:
- {
- nItemsRead = (int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- mnColourCount = (short)Calculate(ShortValue, sizeof(ShortValue) );
- }
- break;
- case 1047:
- {
- nItemsRead = (int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- nBytesRead += nItemsRead * sizeof(ShortValue);
- mnTransparentIndex = (short)Calculate(ShortValue, sizeof(ShortValue) );
- }
- break;
-
- default:
- pFile.Seek(image_resource.nSize, SEEK_CUR);
- nBytesRead += image_resource.nSize;
- break;
- }
- }
- }
- }
-
- assert ( nBytesRead == nTotalBytes );
- if ( nBytesRead == nTotalBytes )
- bSuccess = true;
-
- return bSuccess;
- }
- bool CPSD::ReadColourModeData(CxFile &pFile, COLOUR_MODE_DATA& colour_mode_data)
- {
- // Only indexed colour and duotone have colour mode data,
- // for all other modes this section is 4 bytes length, the length field is set to zero
-
- // For indexed color images, the length will be equal to 768, and the color
- // will contain the color table for the image, in non–interleaved order.
-
- // For duotone images, the color data will contain the duotone specification,
- // the format of which is not documented. Other applications that read
- // Photoshop files can treat a duotone image as a grayscale image, and just
- // preserve the contents of the duotone information when reading and writing
- // the file.
-
- // free memory
- if ( 0 < colour_mode_data.nLength )
- delete[] colour_mode_data.ColourData;
- colour_mode_data.ColourData = 0;
-
- unsigned char Length[4];
- int nItemsRead = (int)mypsd_fread(&Length, sizeof(Length), 1, pFile);
-
- colour_mode_data.nLength = Calculate( Length, sizeof(colour_mode_data.nLength) );
- if ( 0 < colour_mode_data.nLength )
- {
- colour_mode_data.ColourData = new unsigned char[colour_mode_data.nLength];
- nItemsRead = 0;
- memset(colour_mode_data.ColourData, 254, colour_mode_data.nLength);
-
- nItemsRead += (int)mypsd_fread( colour_mode_data.ColourData, colour_mode_data.nLength, 1, pFile);
-
- }
-
- return true;
- }
-
- bool CPSD::ReadHeader(CxFile &pFile, HEADER_INFO& header_info)
- {
- bool bSuccess = false;
-
- struct HEADER
- {
- char Signature[4]; // always equal 8BPS, do not read file if not
- unsigned char Version[2]; // always equal 1, do not read file if not
- char Reserved[6]; // must be zero
- unsigned char Channels[2]; // numer of channels including any alpha channels, supported range 1 to 24
- unsigned char Rows[4]; // height in PIXELS, supported range 1 to 30000
- unsigned char Columns[4]; // width in PIXELS, supported range 1 to 30000
- unsigned char Depth[2]; // number of bpp
- unsigned char Mode[2]; // colour mode of the file,
- // Btmap=0, Grayscale=1, Indexed=2, RGB=3,
- // CMYK=4, Multichannel=7, Duotone=8, Lab=9
- };
-
- HEADER header;
- int nItemsRead = (int)mypsd_fread(&header, sizeof(HEADER), 1, pFile);
- if ( nItemsRead )
- {
- if ( 0 == ::memcmp(header.Signature, "8BPS", 4))
- {
- int nVersion = Calculate( header.Version, sizeof(header.Version) );
-
- if ( 1 == nVersion )
- {
- unsigned int n = 0;
- bool bOK = true;
- while ( (n < 6) && bOK )
- {
- if ( '\0' != header.Reserved[n] )
- bOK = false;
- n++;
- }
- bSuccess = bOK;
-
- if ( bSuccess )
- {
- header_info.nChannels = (short)Calculate( header.Channels, sizeof(header.Channels) );
- header_info.nHeight = Calculate( header.Rows, sizeof(header.Rows) );
- header_info.nWidth = Calculate( header.Columns, sizeof(header.Columns) );
- header_info.nBitsPerPixel = (short)Calculate( header.Depth, sizeof(header.Depth) );
- header_info.nColourMode = (short)Calculate( header.Mode, sizeof(header.Mode) );
- }
- }
- }
- }
-
- return bSuccess;
- }
-
-
- void CPSD::ProccessBuffer(unsigned char* pData )
- {
- if (!pData) return;
-
- switch ( header_info.nColourMode )
- {
- case 1: // Grayscale
- case 8: // Duotone
- {
- bool bAlpha = header_info.nChannels > 1;
-
- int nPixels = header_info.nWidth * header_info.nHeight;
- byte *pRGBA = new byte[nPixels * (bAlpha ? 4 : 3)];
- byte *pSrc = pData, *pDst = pRGBA;
- for (int i = 0; i < nPixels; i++, pSrc += header_info.nChannels, pDst += bAlpha ? 4 : 3)
- {
- pDst[0] = pDst[1] = pDst[2] = pSrc[0];
- if (bAlpha) pDst[3] = pSrc[1];
- }
-
- m_image.CreateFromArray(pRGBA, header_info.nWidth, header_info.nHeight, bAlpha ? 32 : 24, header_info.nWidth * (bAlpha ? 4 : 3), true);
-
- delete [] pRGBA;
- }
- break;
- case 2: // Indexed
- {
- if (!colour_mode_data.ColourData) break;
- if (colour_mode_data.nLength != 768) break;
- if (mnColourCount == 0) break;
-
- int nPixels = header_info.nWidth * header_info.nHeight;
- byte *pRGB = new byte[nPixels * 3];
- ::memset(pRGB, 0, nPixels * 3);
- byte *pSrc = pData, *pDst = pRGB;
- for (int i = 0; i < nPixels; i++, pSrc += header_info.nChannels, pDst += 3)
- {
- int nIndex = *pSrc;
- pDst[2] = colour_mode_data.ColourData[nIndex + 0 * 256];
- pDst[1] = colour_mode_data.ColourData[nIndex + 1 * 256];
- pDst[0] = colour_mode_data.ColourData[nIndex + 2 * 256];
- }
-
- m_image.CreateFromArray(pRGB, header_info.nWidth, header_info.nHeight, 24, header_info.nWidth * 3, true);
- delete [] pRGB;
- }
- break;
- case 3: // RGB
- {
- m_image.CreateFromArray(pData, header_info.nWidth, header_info.nHeight, header_info.nChannels == 3 ? 24 : 32, header_info.nWidth * header_info.nChannels, true);
- m_image.SwapRGB2BGR();
- }
- break;
- case 4: // CMYK
- {
- bool bAlpha = header_info.nChannels > 4;
-
- int nPixels = header_info.nWidth * header_info.nHeight;
- byte *pRGBA = new byte[nPixels * (bAlpha ? 4 : 3)];
- byte *pSrc = pData, *pDst = pRGBA;
- double C, M, Y, K;
- int nRed, nGreen, nBlue;
- for (int i = 0; i < nPixels; i++, pSrc += header_info.nChannels, pDst += bAlpha ? 4 : 3)
- {
- C = (1.0 - (double)pSrc[0] / 256);
- M = (1.0 - (double)pSrc[1] / 256);
- Y = (1.0 - (double)pSrc[2] / 256);
- K = (1.0 - (double)pSrc[3] / 256);
-
- CMYKToRGB(C, M, Y, K, nRed, nGreen, nBlue);
-
- if (0 > nRed) nRed = 0; else if (255 < nRed) nRed = 255;
- if (0 > nGreen) nGreen = 0; else if (255 < nGreen) nGreen = 255;
- if (0 > nBlue) nBlue = 0; else if (255 < nBlue) nBlue = 255;
-
- pDst[0] = nBlue; pDst[1] = nGreen; pDst[2] = nRed;
- if (bAlpha) pDst[3] = pSrc[4];
- }
-
- m_image.CreateFromArray(pRGBA, header_info.nWidth, header_info.nHeight, bAlpha ? 32 : 24, header_info.nWidth * (bAlpha ? 4 : 3), true);
-
- delete [] pRGBA;
- }
- break;
- case 7: // Multichannel
- {
- if (header_info.nChannels == 0 || header_info.nChannels > 4) break; // ???
-
- int nPixels = header_info.nWidth * header_info.nHeight;
- byte *pRGB = new byte[nPixels * 3];
- byte *pSrc = pData, *pDst = pRGB;
- double C, M, Y, K;
- int nRed, nGreen, nBlue;
- for (int i = 0; i < nPixels; i++, pSrc += header_info.nChannels, pDst += 3)
- {
- C = M = Y = K = 0;
- C = (1.0 - (double)pSrc[0] / 256);
- if (header_info.nChannels > 1) M = (1.0 - (double)pSrc[1] / 256);
- if (header_info.nChannels > 2) Y = (1.0 - (double)pSrc[2] / 256);
- if (header_info.nChannels > 3) K = (1.0 - (double)pSrc[3] / 256);
-
- CMYKToRGB(C, M, Y, K, nRed, nGreen, nBlue);
-
- if (0 > nRed) nRed = 0; else if (255 < nRed) nRed = 255;
- if (0 > nGreen) nGreen = 0; else if (255 < nGreen) nGreen = 255;
- if (0 > nBlue) nBlue = 0; else if (255 < nBlue) nBlue = 255;
-
- pDst[0] = nBlue; pDst[1] = nGreen; pDst[2] = nRed;
- }
-
- m_image.CreateFromArray(pRGB, header_info.nWidth, header_info.nHeight, 24, header_info.nWidth * 3, true);
-
- delete [] pRGB;
- }
- break;
- case 9: // Lab
- {
- bool bAlpha = header_info.nChannels > 3;
-
- int nPixels = header_info.nWidth * header_info.nHeight;
- byte *pRGBA = new byte[nPixels * (bAlpha ? 4 : 3)];
- byte *pSrc = pData, *pDst = pRGBA;
-
- double L_coef = 256.f / 100.f, a_coef = 256.f / 256.f, b_coef = 256.f / 256.f;
- int L, a, b;
- int nRed, nGreen, nBlue;
- for (int i = 0; i < nPixels; i++, pSrc += header_info.nChannels, pDst += bAlpha ? 4 : 3)
- {
- L = (int)((float)pSrc[0] / L_coef);
- a = (int)((float)pSrc[1] / a_coef - 128.0);
- b = (int)((float)pSrc[2] / b_coef - 128.0);
-
- LabToRGB(L, a, b, nRed, nGreen, nBlue );
-
- if (0 > nRed) nRed = 0; else if (255 < nRed) nRed = 255;
- if (0 > nGreen) nGreen = 0; else if (255 < nGreen) nGreen = 255;
- if (0 > nBlue) nBlue = 0; else if (255 < nBlue) nBlue = 255;
-
- pDst[0] = nBlue; pDst[1] = nGreen; pDst[2] = nRed;
- if (bAlpha) pDst[3] = pSrc[3];
- }
-
- m_image.CreateFromArray(pRGBA, header_info.nWidth, header_info.nHeight, bAlpha ? 32 : 24, header_info.nWidth * (bAlpha ? 4 : 3), true);
-
- delete [] pRGBA;
- }
- break;
- }
- }
-
- int CPSD::Load(LPCTSTR szPathName)
- {
- CxIOFile f;
- if (!f.Open(szPathName, _T("rb"))) return -1;
- return Load(f);
- }
-
- int CPSD::Load(CxFile &f)
- {
- if (!ReadHeader(f, header_info)) return -2; // Error in header
- if (!ReadColourModeData(f, colour_mode_data)) return -3; // Error in ColourMode Data
- if (!ReadImageResource(f, image_resource)) return -4; // Error in Image Resource
- if (!ReadLayerAndMaskInfoSection(f)) return -5; // Error in Mask Info
- if (ReadImageData(f) != 0) return -6; // Error in Image Data
- return 0; // all right
- }
-
- int CPSD::DecodeRawData( CxFile &pFile)
- {
- if (header_info.nBitsPerPixel != 8 && header_info.nBitsPerPixel != 16) return -7; // can't read this
-
- int nWidth = header_info.nWidth;
- int nHeight = header_info.nHeight;
- int bytesPerPixelPerChannel = header_info.nBitsPerPixel / 8;
-
- int nPixels = nWidth * nHeight;
- int nTotalBytes = 0;
-
- byte* pData = NULL;
-
- switch ( header_info.nColourMode )
- {
- case 1: // Grayscale
- case 2: // Indexed
- case 3: // RGB
- case 4: // CMYK
- case 8: // Duotone
- case 9: // Lab
- {
- // read RRRRRRRGGGGGGGBBBBBBAAAAAA data
- int nAllDataSize = nPixels * bytesPerPixelPerChannel * header_info.nChannels;
- byte *pFileData = new byte[nAllDataSize];
- ::memset(pFileData, 0, nAllDataSize);
- if (pFile.Read(pFileData, nAllDataSize, 1) != 1)
- {
- delete [] pFileData;
- return -1; // bad data
- }
-
- // and convert them to RGBARGBARGBA data (depends on number of channels)
- nTotalBytes = nPixels * header_info.nChannels;
- pData = new byte[nTotalBytes];
- byte *pSource = pFileData;
- for (int nChannel = 0; nChannel < header_info.nChannels; nChannel++)
- {
- byte *pDest = pData + nChannel;
- for (int pos = 0; pos < nPixels; pos++, pDest += header_info.nChannels, pSource += bytesPerPixelPerChannel) *pDest = *pSource;
- }
- delete [] pFileData;
- }
- break;
- default:
- return -1; // unsupported format
- }
-
- ProccessBuffer(pData);
- delete [] pData;
-
- // dpi related things
- int ppm_x = 3780; // 96 dpi
- int ppm_y = 3780; // 96 dpi
- if (mbResolutionInfoFilled)
- {
- int nHorResolution = (int)resolution_info.hRes;
- int nVertResolution = (int)resolution_info.vRes;
- ppm_x = (nHorResolution * 10000) / 254;
- ppm_y = (nVertResolution * 10000) / 254;
- }
- m_image.SetXDPI(ppm_x);
- m_image.SetYDPI(ppm_y);
-
- return 0;
- }
-
-
- int CPSD::DecodeRLEData(CxFile & pFile)
- {
- if (header_info.nBitsPerPixel != 8) return -7; // can't read this
-
- int nWidth = header_info.nWidth;
- int nHeight = header_info.nHeight;
- int nPixels = nWidth * nHeight;
-
- // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data
- // read them and compute size of RLE data
- int nLengthDataSize = nHeight * header_info.nChannels * 2;
- byte *pLengthData = new byte[nLengthDataSize];
- if (pFile.Read(pLengthData, nLengthDataSize, 1) != 1)
- {
- delete [] pLengthData;
- return -1; // error while reading
- }
- int nRLEDataSize = 0;
- for (int i = 0; i < nHeight * header_info.nChannels * 2; i += 2)
- nRLEDataSize += Calculate(pLengthData + i, 2);
- delete [] pLengthData;
-
- // now read RLE data to the buffer for fast access
- byte *pRLEData = new byte[nRLEDataSize];
- if (pFile.Read(pRLEData, nRLEDataSize, 1) != 1)
- {
- delete [] pRLEData;
- return -1;
- }
-
- // allocate buffer for raw data (RRRRRRR...RRRGGGGG...GGGGGGBBBBB...BBBBBAAAAA....AAAAA) it has the same size as the final buffer
- // and the perform RLE-decoding
- int nTotalBytes = nPixels * header_info.nChannels;
- byte* pRawData = new byte[nTotalBytes];
- byte *pRLESource = pRLEData, *pRLEDest = pRawData;
- for (int channel = 0; channel < header_info.nChannels; channel++)
- {
- int nCount = 0;
- while (nCount < nPixels)
- {
- int len = *pRLESource++;
- if ( 128 > len )
- { // copy next (len + 1) bytes as is
- len++;
- nCount += len;
- ::memcpy(pRLEDest, pRLESource, len);
- pRLEDest += len; pRLESource += len;
- }
- else if ( 128 < len )
- {
- // Next -len+1 bytes in the dest are replicated from next source byte.
- // (Interpret len as a negative 8-bit int.)
- len ^= 0x0FF;
- len += 2;
- nCount += len;
- ::memset(pRLEDest, *pRLESource++, len);
- pRLEDest += len;
- }
- else if ( 128 == len ) { /* Do nothing */ }
- }
- }
- delete [] pRLEData;
-
- // transform raw data to the good one (RGBARGBARGBA...RGBA)
- byte *pRawSource = pRawData;
- byte *pData = new byte[nTotalBytes];
- int nPixelCounter = 0;
- for( int nColour = 0; nColour < header_info.nChannels; ++nColour )
- {
- nPixelCounter = nColour;
- for (int nPos = 0; nPos < nPixels; nPos++, pRawSource++)
- {
- pData[nPixelCounter] = *pRawSource;
- nPixelCounter += header_info.nChannels;
- }
- }
- delete[] pRawData;
-
- // create image
- ProccessBuffer(pData);
- delete [] pData;
-
- // dpi related things
- int ppm_x = 3780; // 96 dpi
- int ppm_y = 3780; // 96 dpi
- if (mbResolutionInfoFilled)
- {
- int nHorResolution = (int)resolution_info.hRes;
- int nVertResolution = (int)resolution_info.vRes;
- ppm_x = (nHorResolution * 10000) / 254;
- ppm_y = (nVertResolution * 10000) / 254;
- }
- m_image.SetXDPI(ppm_x);
- m_image.SetYDPI(ppm_y);
-
- return 0;
- }
-
- int CPSD::ReadImageData(CxFile &pFile)
- {
- int nErrorCode = 0; // No Errors
-
- if ( !mypsd_feof(pFile) )
- {
- unsigned char ShortValue[2];
- int nBytesRead = 0;
- int nItemsRead = (int)mypsd_fread(&ShortValue, sizeof(ShortValue), 1, pFile);
- short nCompression = (short)Calculate( ShortValue, sizeof(ShortValue) );
-
- switch ( nCompression )
- {
- case 0: // raw data
- nErrorCode = DecodeRawData(pFile);
- break;
- case 1: // RLE compression
- nErrorCode = DecodeRLEData(pFile);
- break;
- case 2: // ZIP without prediction
- nErrorCode = -10; // ZIP without prediction, no specification
- break;
- case 3: // ZIP with prediction
- nErrorCode = -11; // ZIP with prediction, no specification
- break;
- default:
- nErrorCode = -12; // Unknown format
- }
- }
- return nErrorCode;
- }
-
- //////////////////////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////
- CPSD::HEADER_INFO::HEADER_INFO()
- {
- nChannels = -1;
- nHeight = -1;
- nWidth = -1;
- nBitsPerPixel = -1;
- nColourMode = -1;
- }
-
- CPSD::COLOUR_MODE_DATA::COLOUR_MODE_DATA()
- {
- nLength = -1;
- ColourData = 0;
- }
-
- CPSD::IMAGE_RESOURCE::IMAGE_RESOURCE()
- {
- Name = 0;
- Reset();
- }
-
- void CPSD::IMAGE_RESOURCE::Reset()
- {
- nLength = -1;
- memset( OSType, '\0', sizeof(OSType) );
- nID = -1;
- if ( Name )
- delete[] Name;
- Name = 0;
- nSize = -1;
- }
-
- CPSD::RESOLUTION_INFO::RESOLUTION_INFO()
- {
- hRes = -1;
- hResUnit = -1;
- widthUnit = -1;
- vRes = -1;
- vResUnit = -1;
- heightUnit = -1;
- }
-
- CPSD::RESOLUTION_INFO_v2::RESOLUTION_INFO_v2()
- {
- nChannels = -1;
- nRows = -1;
- nColumns = -1;
- nDepth = -1;
- nMode = -1;
- }
-
- CPSD::DISPLAY_INFO::DISPLAY_INFO()
- {
- ColourSpace = -1;
- for ( unsigned int n = 0; n < 4; ++n)
- Colour[n] = 0;
- Opacity = -1;
- kind = false;
- padding = '0';
- }
-
- CPSD::THUMBNAIL::THUMBNAIL()
- {
- nFormat = -1;
- nWidth = -1;
- nHeight = -1;
- nWidthBytes = -1;
- nSize = -1;
- nCompressedSize = -1;
- nBitPerPixel = -1;
- nPlanes = -1;
- Data = 0;
- }
-} // MyPSD
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_USE_LIBPSD
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImagePSD::Decode(CxFile *hFile)
-{
- if (hFile==NULL)
- return false;
-
-#if CXIMAGE_USE_LIBPSD
- psd_context* context = NULL;
-#endif
-
- cx_try
- {
-#if CXIMAGE_USE_LIBPSD
-
- psd_status status;
-
- context = (psd_context *)malloc(sizeof(psd_context));
- if(context == NULL){
- cx_throw("CxImagePSD: psd_status_malloc_failed");
- }
- memset(context, 0, sizeof(psd_context));
-
- // install file manager
- CxFilePsd src(hFile,context);
-
- context->state = PSD_FILE_HEADER;
- context->stream.file_length = hFile->Size();
- context->load_tag = psd_load_tag_all;
- status = psd_main_loop(context);
-
- if(status != psd_status_done){
- cx_throw("CxImagePSD: psd_main_loop failed");
- }
-
- Create(context->width,context->height,24,CXIMAGE_FORMAT_PSD);
-
- uint8_t* rgba = (uint8_t*)context->merged_image_data;
- uint8_t* alpha = NULL;
- if (context->alpha_channel_info)
- alpha = (uint8_t*)context->alpha_channel_info->channel_data;
- if (alpha)
- AlphaCreate();
-
- int32_t x,y;
- RGBQUAD c;
- c.rgbReserved = 0;
- if (rgba){
- for(y =context->height-1; y--;){
- for (x=0; x<context->width; x++){
- c.rgbBlue = *rgba++;
- c.rgbGreen = *rgba++;
- c.rgbRed = *rgba++;
- rgba++;
- SetPixelColor(x,y,c);
-#if CXIMAGE_SUPPORT_ALPHA
- if (alpha) AlphaSet(x,y,*alpha++);
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- }
- }
-
- psd_image_free(context);
- free(context);
-
-#else //CXIMAGE_USE_LIBPSD == 0
-
- MyPSD::CPSD psd(*this);
- int nErrorCode = psd.Load(*hFile);
- if (nErrorCode != 0) cx_throw("error loading PSD file");
-
-#endif //CXIMAGE_USE_LIBPSD
-
- } cx_catch {
-
-#if CXIMAGE_USE_LIBPSD
- psd_image_free(context);
- if (context) free(context);
-#endif //CXIMAGE_USE_LIBPSD
-
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- if (info.nEscape == -1 && info.dwType == CXIMAGE_FORMAT_PSD) return true;
- return false;
- }
- /* that's it */
- return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImagePSD::Encode(CxFile * hFile)
-{
- if (hFile == NULL) return false;
- strcpy(info.szLastError, "Save PSD not supported");
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_PSD
-
diff --git a/smelt/sdl/CxImage/ximapsd.h b/smelt/sdl/CxImage/ximapsd.h deleted file mode 100644 index 92be8f1..0000000 --- a/smelt/sdl/CxImage/ximapsd.h +++ /dev/null @@ -1,110 +0,0 @@ -/*
- * File: ximapsd.h
- * Purpose: PSD Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImagePSD (c) Dec/2010
- * For conditions of distribution and use, see copyright notice in ximage.h
- *
- * libpsd (c) 2004-2007 Graphest Software
- *
- * ==========================================================
- */
-#if !defined(__ximaPSD_h)
-#define __ximaPSD_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_PSD
-
-#define CXIMAGE_USE_LIBPSD 1
-
-#if CXIMAGE_USE_LIBPSD
- extern "C" {
- #include "../libpsd/libpsd.h"
- }
-#endif
-
-class CxImagePSD: public CxImage
-{
-
-public:
- CxImagePSD(): CxImage(CXIMAGE_FORMAT_PSD) {}
-
-// bool Load(const char * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_PSD);}
-// bool Save(const char * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_PSD);}
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-//#if CXIMAGE_SUPPORT_EXIF
-// bool GetExifThumbnail(const TCHAR *filename, const TCHAR *outname, int32_t type);
-//#endif //CXIMAGE_SUPPORT_EXIF
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-
-#if CXIMAGE_USE_LIBPSD
-protected:
- class CxFilePsd
- {
- public:
- CxFilePsd(CxFile* pFile,psd_context *context)
- {
- context->file = pFile;
-
- psd_CxFile_ops.size_ = psd_file_size;
- psd_CxFile_ops.seek_ = psd_file_seek;
- psd_CxFile_ops.read_ = psd_file_read;
-// psd_CxFile_ops.write_ = psd_file_write;
-// psd_CxFile_ops.close_ = psd_file_close;
-// psd_CxFile_ops.gets_ = psd_file_gets;
-// psd_CxFile_ops.eof_ = psd_file_eof;
-// psd_CxFile_ops.tell_ = psd_file_tell;
-// psd_CxFile_ops.getc_ = psd_file_getc;
-// psd_CxFile_ops.scanf_ = psd_file_scanf;
-
- context->ops_ = &psd_CxFile_ops;
-
- }
-
- static int32_t psd_file_size(psd_file_obj *obj)
- { return ((CxFile*)obj)->Size(); }
-
- static int32_t psd_file_seek(psd_file_obj *obj, int32_t offset, int32_t origin)
- { return ((CxFile*)obj)->Seek(offset,origin); }
-
- static int32_t psd_file_read(psd_file_obj *obj, void *buf, int32_t size, int32_t cnt)
- { return ((CxFile*)obj)->Read(buf,size,cnt); }
-
-// static int32_t psd_file_write(psd_file_obj *obj, void *buf, int32_t size, int32_t cnt)
-// { return ((CxFile*)obj)->Write(buf,size,cnt); }
-
-// static int32_t psd_file_close(psd_file_obj *obj)
-// { return 1; /*((CxFile*)obj)->Close();*/ }
-
-// static char* psd_file_gets(psd_file_obj *obj, char *string, int32_t n)
-// { return ((CxFile*)obj)->GetS(string,n); }
-
-// static int32_t psd_file_eof(psd_file_obj *obj)
-// { return ((CxFile*)obj)->Eof(); }
-
-// static long psd_file_tell(psd_file_obj *obj)
-// { return ((CxFile*)obj)->Tell(); }
-
-// static int32_t psd_file_getc(psd_file_obj *obj)
-// { return ((CxFile*)obj)->GetC(); }
-
-// static int32_t psd_file_scanf(psd_file_obj *obj,const char *format, void* output)
-// { return ((CxFile*)obj)->Scanf(format, output); }
-
- private:
- psd_file_ops psd_CxFile_ops;
- };
-#endif //CXIMAGE_USE_LIBPSD
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximaraw.cpp b/smelt/sdl/CxImage/ximaraw.cpp deleted file mode 100644 index aedc50a..0000000 --- a/smelt/sdl/CxImage/ximaraw.cpp +++ /dev/null @@ -1,331 +0,0 @@ -/*
- * File: ximaraw.cpp
- * Purpose: Platform Independent RAW Image Class Loader
- * 16/Dec/2007 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- *
- * CxImageRAW (c) May/2006 pdw63
- *
- * based on dcraw.c -- Dave Coffin's raw photo decoder
- * Copyright 1997-2007 by Dave Coffin, dcoffin a cybercom o net
- */
-
-#include "ximaraw.h"
-
-#if CXIMAGE_SUPPORT_RAW
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageRAW::Decode(CxFile *hFile)
-{
- if (hFile==NULL)
- return false;
-
- DCRAW dcr;
-
- cx_try
- {
- // initialization
- dcr_init_dcraw(&dcr);
-
- dcr.opt.user_qual = GetCodecOption(CXIMAGE_FORMAT_RAW) & 0x03;
-
- // setup variables for debugging
- char szClass[] = "CxImageRAW";
- dcr.ifname = szClass;
- dcr.sz_error = info.szLastError;
-
- // setup library options, see dcr_print_manual for the available switches
- // call dcr_parse_command_line_options(&dcr,0,0,0) to set default options
- // if (dcr_parse_command_line_options(&dcr,argc,argv,&arg))
- if (dcr_parse_command_line_options(&dcr,0,0,0)){
- cx_throw("CxImageRAW: unknown option");
- }
-
- // set return point for error handling
- if (setjmp (dcr.failure)) {
- cx_throw("");
- }
-
- // install file manager
- CxFileRaw src(hFile,&dcr);
-
- // check file header
- dcr_identify(&dcr);
-
- if(!dcr.is_raw){
- cx_throw("CxImageRAW: not a raw image");
- }
-
- if (dcr.load_raw == NULL) {
- cx_throw("CxImageRAW: missing raw decoder");
- }
-
- // verify special case
- if (dcr.load_raw == dcr_kodak_ycbcr_load_raw) {
- dcr.height += dcr.height & 1;
- dcr.width += dcr.width & 1;
- }
-
- if (info.nEscape == -1){
- head.biWidth = dcr.width;
- head.biHeight= dcr.height;
- info.dwType = CXIMAGE_FORMAT_RAW;
- cx_throw("output dimensions returned");
- }
-
- // shrinked decoding available and requested?
- dcr.shrink = dcr.filters && (dcr.opt.half_size || dcr.opt.threshold || dcr.opt.aber[0] != 1 || dcr.opt.aber[2] != 1);
- dcr.iheight = (dcr.height + dcr.shrink) >> dcr.shrink;
- dcr.iwidth = (dcr.width + dcr.shrink) >> dcr.shrink;
-
- // install custom camera matrix
- if (dcr.opt.use_camera_matrix && dcr.cmatrix[0][0] > 0.25) {
- memcpy (dcr.rgb_cam, dcr.cmatrix, sizeof dcr.cmatrix);
- dcr.raw_color = 0;
- } else {
- dcr.opt.use_camera_wb = 1;
- }
-
- // allocate memory for the image
- dcr.image = (ushort (*)[4]) calloc (dcr.iheight*dcr.iwidth, sizeof *dcr.image);
- dcr_merror (&dcr, dcr.image, szClass);
-
- if (dcr.meta_length) {
- dcr.meta_data = (char *) malloc (dcr.meta_length);
- dcr_merror (&dcr, dcr.meta_data, szClass);
- }
-
- // start image decoder
- hFile->Seek(dcr.data_offset, SEEK_SET);
- (*dcr.load_raw)(&dcr);
-
- // post processing
- if (dcr.zero_is_bad) dcr_remove_zeroes(&dcr);
-
- dcr_bad_pixels(&dcr,dcr.opt.bpfile);
-
- if (dcr.opt.dark_frame) dcr_subtract (&dcr,dcr.opt.dark_frame);
-
- dcr.quality = 2 + !dcr.fuji_width;
-
- if (dcr.opt.user_qual >= 0) dcr.quality = dcr.opt.user_qual;
-
- if (dcr.opt.user_black >= 0) dcr.black = dcr.opt.user_black;
-
- if (dcr.opt.user_sat >= 0) dcr.maximum = dcr.opt.user_sat;
-
-#ifdef COLORCHECK
- dcr_colorcheck(&dcr);
-#endif
-
-#if RESTRICTED
- if (dcr.is_foveon && !dcr.opt.document_mode) dcr_foveon_interpolate(&dcr);
-#endif
-
- if (!dcr.is_foveon && dcr.opt.document_mode < 2) dcr_scale_colors(&dcr);
-
- // pixel interpolation and filters
- dcr_pre_interpolate(&dcr);
-
- if (dcr.filters && !dcr.opt.document_mode) {
- if (dcr.quality == 0)
- dcr_lin_interpolate(&dcr);
- else if (dcr.quality == 1 || dcr.colors > 3)
- dcr_vng_interpolate(&dcr);
- else if (dcr.quality == 2)
- dcr_ppg_interpolate(&dcr);
- else
- dcr_ahd_interpolate(&dcr);
- }
-
- if (dcr.mix_green) {
- int32_t i;
- for (dcr.colors=3, i=0; i < dcr.height*dcr.width; i++) {
- dcr.image[i][1] = (dcr.image[i][1] + dcr.image[i][3]) >> 1;
- }
- }
-
- if (!dcr.is_foveon && dcr.colors == 3) dcr_median_filter(&dcr);
-
- if (!dcr.is_foveon && dcr.opt.highlight == 2) dcr_blend_highlights(&dcr);
-
- if (!dcr.is_foveon && dcr.opt.highlight > 2) dcr_recover_highlights(&dcr);
-
- if (dcr.opt.use_fuji_rotate) dcr_fuji_rotate(&dcr);
-
-#ifndef NO_LCMS
- if (dcr.opt.cam_profile) dcr_apply_profile (dcr.opt.cam_profile, dcr.opt.out_profile);
-#endif
-
- // final conversion
- dcr_convert_to_rgb(&dcr);
-
- if (dcr.opt.use_fuji_rotate) dcr_stretch(&dcr);
-
- dcr.iheight = dcr.height;
- dcr.iwidth = dcr.width;
- if (dcr.flip & 4) SWAP(dcr.height,dcr.width);
-
- // ready to transfer data from dcr.image
- if (!Create(dcr.width,dcr.height,24,CXIMAGE_FORMAT_RAW)){
- cx_throw("");
- }
-
- uchar *ppm = (uchar *) calloc (dcr.width, dcr.colors*dcr.opt.output_bps/8);
- ushort *ppm2 = (ushort *) ppm;
- dcr_merror (&dcr, ppm, szClass);
-
- uchar lut[0x10000];
- if (dcr.opt.output_bps == 8) dcr_gamma_lut (&dcr, lut);
-
- int32_t c, row, col, soff, rstep, cstep;
- soff = dcr_flip_index (&dcr, 0, 0);
- cstep = dcr_flip_index (&dcr, 0, 1) - soff;
- rstep = dcr_flip_index (&dcr, 1, 0) - dcr_flip_index (&dcr, 0, dcr.width);
- for (row=0; row < dcr.height; row++, soff += rstep) {
- for (col=0; col < dcr.width; col++, soff += cstep) {
- if (dcr.opt.output_bps == 8)
- for (c=0; c < dcr.colors; c++) ppm [col*dcr.colors+c] = lut[dcr.image[soff][c]];
- else
- for (c=0; c < dcr.colors; c++) ppm2[col*dcr.colors+c] = dcr.image[soff][c];
- }
- if (dcr.opt.output_bps == 16 && !dcr.opt.output_tiff && htons(0x55aa) != 0x55aa)
-#if defined(_LINUX) || defined(__APPLE__)
- swab ((char*)ppm2, (char*)ppm2, dcr.width*dcr.colors*2);
-#else
- _swab ((char*)ppm2, (char*)ppm2, dcr.width*dcr.colors*2);
-#endif
-
- uint32_t size = dcr.width * (dcr.colors*dcr.opt.output_bps/8);
- RGBtoBGR(ppm,size);
- memcpy(GetBits(dcr.height - 1 - row), ppm, min(size,GetEffWidth()));
- }
- free (ppm);
-
-
- dcr_cleanup_dcraw(&dcr);
-
- } cx_catch {
-
- dcr_cleanup_dcraw(&dcr);
-
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- if (info.nEscape == -1 && info.dwType == CXIMAGE_FORMAT_RAW) return true;
- return false;
- }
- /* that's it */
- return true;
-}
-
-#if CXIMAGE_SUPPORT_EXIF
-bool CxImageRAW::GetExifThumbnail(const TCHAR *filename, const TCHAR *outname, int32_t type)
-{
- DCRAW dcr;
-
- CxIOFile file;
- if (!file.Open(filename, _T("rb")))
- return false;
-
- cx_try
- {
- // initialization
- dcr_init_dcraw(&dcr);
-
- dcr.opt.user_qual = GetCodecOption(CXIMAGE_FORMAT_RAW) & 0x03;
-
- // setup variables for debugging
- char szClass[] = "CxImageRAW";
- dcr.ifname = szClass;
- dcr.sz_error = info.szLastError;
-
- // setup library options, see dcr_print_manual for the available switches
- // call dcr_parse_command_line_options(&dcr,0,0,0) to set default options
- // if (dcr_parse_command_line_options(&dcr,argc,argv,&arg))
- if (dcr_parse_command_line_options(&dcr,0,0,0)){
- cx_throw("CxImageRAW: unknown option");
- }
-
- // set return point for error handling
- if (setjmp (dcr.failure)) {
- cx_throw("");
- }
-
- // install file manager
- CxFileRaw src(&file,&dcr);
-
- // check file header
- dcr_identify(&dcr);
-
- if(!dcr.is_raw){
- cx_throw("CxImageRAW: not a raw image");
- }
-
- if (dcr.load_raw == NULL) {
- cx_throw("CxImageRAW: missing raw decoder");
- }
-
- // THUMB.
- if (dcr.thumb_offset != 0)
- {
- FILE* file = _tfopen(outname, _T("wb"));
- DCRAW* p = &dcr;
- dcr_fseek(dcr.obj_, dcr.thumb_offset, SEEK_SET);
- dcr.write_thumb(&dcr, file);
- fclose(file);
-
- // Read in the thumbnail to resize and rotate.
- CxImage image(outname, CXIMAGE_FORMAT_UNKNOWN);
- if (image.IsValid())
- {
- // Resizing.
- if (image.GetWidth() > 256 || image.GetHeight() > 256)
- {
- float amount = 256.0f / max(image.GetWidth(), image.GetHeight());
- image.Resample((int32_t)(image.GetWidth() * amount), (int32_t)(image.GetHeight() * amount), 0);
- }
-
- // Rotation.
- if (p->flip != 0)
- image.RotateExif(p->flip);
-
- return image.Save(outname, CXIMAGE_FORMAT_JPG);
- }
- }
- else
- {
- cx_throw("No thumbnail!");
- }
-
- dcr_cleanup_dcraw(&dcr);
-
- } cx_catch {
-
- dcr_cleanup_dcraw(&dcr);
-
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- if (info.nEscape == -1 && info.dwType == CXIMAGE_FORMAT_RAW) return true;
- return false;
- }
- /* that's it */
- return true;
-}
-#endif //CXIMAGE_SUPPORT_EXIF
-
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageRAW::Encode(CxFile * hFile)
-{
- if (hFile == NULL) return false;
- strcpy(info.szLastError, "Save RAW not supported");
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_RAW
-
diff --git a/smelt/sdl/CxImage/ximaraw.h b/smelt/sdl/CxImage/ximaraw.h deleted file mode 100644 index 2fe4961..0000000 --- a/smelt/sdl/CxImage/ximaraw.h +++ /dev/null @@ -1,112 +0,0 @@ -/*
- * File: ximaraw.h
- * Purpose: RAW Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImageRAW (c) May/2006 pdw63
- * For conditions of distribution and use, see copyright notice in ximage.h
- * Special thanks to David Coffin for dcraw without which this class would not exist
- *
- * libdcr (c) Dec/2007 Davide Pizzolato - www.xdp.it
- *
- * based on dcraw.c -- Dave Coffin's raw photo decoder
- * Copyright 1997-2007 by Dave Coffin, dcoffin a cybercom o net
- * ==========================================================
- */
-#if !defined(__ximaRAW_h)
-#define __ximaRAW_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_RAW
-
-extern "C" {
- #include "../raw/libdcr.h"
-}
-
-class CxImageRAW: public CxImage
-{
-
-public:
- CxImageRAW(): CxImage(CXIMAGE_FORMAT_RAW) {}
-
-// bool Load(const char * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_ICO);}
-// bool Save(const char * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_ICO);}
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_EXIF
- bool GetExifThumbnail(const TCHAR *filename, const TCHAR *outname, int32_t type);
-#endif //CXIMAGE_SUPPORT_EXIF
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-
- enum CODEC_OPTION
- {
- DECODE_QUALITY_LIN = 0x00,
- DECODE_QUALITY_VNG = 0x01,
- DECODE_QUALITY_PPG = 0x02,
- DECODE_QUALITY_AHD = 0x03,
- };
-
-protected:
-
- class CxFileRaw
- {
- public:
- CxFileRaw(CxFile* pFile,DCRAW *stream)
- {
- stream->obj_ = pFile;
-
- ras_stream_CxFile.read_ = raw_sfile_read;
- ras_stream_CxFile.write_ = raw_sfile_write;
- ras_stream_CxFile.seek_ = raw_sfile_seek;
- ras_stream_CxFile.close_ = raw_sfile_close;
- ras_stream_CxFile.gets_ = raw_sfile_gets;
- ras_stream_CxFile.eof_ = raw_sfile_eof;
- ras_stream_CxFile.tell_ = raw_sfile_tell;
- ras_stream_CxFile.getc_ = raw_sfile_getc;
- ras_stream_CxFile.scanf_ = raw_sfile_scanf;
-
- stream->ops_ = &ras_stream_CxFile;
-
- }
-
- static int32_t raw_sfile_read(dcr_stream_obj *obj, void *buf, int32_t size, int32_t cnt)
- { return ((CxFile*)obj)->Read(buf,size,cnt); }
-
- static int32_t raw_sfile_write(dcr_stream_obj *obj, void *buf, int32_t size, int32_t cnt)
- { return ((CxFile*)obj)->Write(buf,size,cnt); }
-
- static long raw_sfile_seek(dcr_stream_obj *obj, long offset, int32_t origin)
- { return ((CxFile*)obj)->Seek(offset,origin); }
-
- static int32_t raw_sfile_close(dcr_stream_obj *obj)
- { return 1; /*((CxFile*)obj)->Close();*/ }
-
- static char* raw_sfile_gets(dcr_stream_obj *obj, char *string, int32_t n)
- { return ((CxFile*)obj)->GetS(string,n); }
-
- static int32_t raw_sfile_eof(dcr_stream_obj *obj)
- { return ((CxFile*)obj)->Eof(); }
-
- static long raw_sfile_tell(dcr_stream_obj *obj)
- { return ((CxFile*)obj)->Tell(); }
-
- static int32_t raw_sfile_getc(dcr_stream_obj *obj)
- { return ((CxFile*)obj)->GetC(); }
-
- static int32_t raw_sfile_scanf(dcr_stream_obj *obj,const char *format, void* output)
- { return ((CxFile*)obj)->Scanf(format, output); }
-
- private:
- dcr_stream_ops ras_stream_CxFile;
- };
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximasel.cpp b/smelt/sdl/CxImage/ximasel.cpp deleted file mode 100644 index c50ff99..0000000 --- a/smelt/sdl/CxImage/ximasel.cpp +++ /dev/null @@ -1,698 +0,0 @@ -// xImaSel.cpp : Selection functions
-/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximage.h"
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks if the image has a valid selection.
- */
-bool CxImage::SelectionIsValid()
-{
- return pSelection!=0;
-}
-
-#if CXIMAGE_SUPPORT_SELECTION
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the smallest rectangle that contains the selection
- */
-void CxImage::SelectionGetBox(RECT& r)
-{
- memcpy(&r,&info.rSelectionBox,sizeof(RECT));
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Empties the selection.
- */
-bool CxImage::SelectionClear(uint8_t level)
-{
- if (pSelection){
- if (level==0){
- memset(pSelection,0,head.biWidth * head.biHeight);
- info.rSelectionBox.left = head.biWidth;
- info.rSelectionBox.bottom = head.biHeight;
- info.rSelectionBox.right = info.rSelectionBox.top = 0;
- } else {
- memset(pSelection,level,head.biWidth * head.biHeight);
- info.rSelectionBox.right = head.biWidth;
- info.rSelectionBox.top = head.biHeight;
- info.rSelectionBox.left = info.rSelectionBox.bottom = 0;
- }
- return true;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Allocates an empty selection.
- */
-bool CxImage::SelectionCreate()
-{
- SelectionDelete();
- pSelection = (uint8_t*)calloc(head.biWidth * head.biHeight, 1);
- return (pSelection!=0);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Deallocates the selction.
- */
-bool CxImage::SelectionDelete()
-{
- if (pSelection){
- free(pSelection);
- pSelection=NULL;
- }
- info.rSelectionBox.left = head.biWidth;
- info.rSelectionBox.bottom = head.biHeight;
- info.rSelectionBox.right = info.rSelectionBox.top = 0;
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks if the coordinates are inside the selection.
- */
-bool CxImage::SelectionIsInside(int32_t x, int32_t y)
-{
- if (IsInside(x,y)){
- if (pSelection==NULL) return true;
- return pSelection[x+y*head.biWidth]!=0;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks if the coordinates are inside the selection.
- * "blind" version assumes that (x,y) is inside to the image.
- */
-bool CxImage::BlindSelectionIsInside(int32_t x, int32_t y)
-{
-#ifdef _DEBUG
- if (!IsInside(x,y))
- #if CXIMAGE_SUPPORT_EXCEPTION_HANDLING
- throw 0;
- #else
- return 0;
- #endif
-#endif
- if (pSelection==NULL) return true;
- return pSelection[x+y*head.biWidth]!=0;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Adds a rectangle to the existing selection.
- */
-bool CxImage::SelectionAddRect(RECT r, uint8_t level)
-{
- if (pSelection==NULL) SelectionCreate();
- if (pSelection==NULL) return false;
-
- RECT r2;
- if (r.left<r.right) {r2.left=r.left; r2.right=r.right; } else {r2.left=r.right ; r2.right=r.left; }
- if (r.bottom<r.top) {r2.bottom=r.bottom; r2.top=r.top; } else {r2.bottom=r.top ; r2.top=r.bottom; }
-
- if (info.rSelectionBox.top <= r2.top) info.rSelectionBox.top = max(0L,min(head.biHeight,r2.top+1));
- if (info.rSelectionBox.left > r2.left) info.rSelectionBox.left = max(0L,min(head.biWidth,r2.left));
- if (info.rSelectionBox.right <= r2.right) info.rSelectionBox.right = max(0L,min(head.biWidth,r2.right+1));
- if (info.rSelectionBox.bottom > r2.bottom) info.rSelectionBox.bottom = max(0L,min(head.biHeight,r2.bottom));
-
- int32_t ymin = max(0L,min(head.biHeight,r2.bottom));
- int32_t ymax = max(0L,min(head.biHeight,r2.top+1));
- int32_t xmin = max(0L,min(head.biWidth,r2.left));
- int32_t xmax = max(0L,min(head.biWidth,r2.right+1));
-
- for (int32_t y=ymin; y<ymax; y++)
- memset(pSelection + xmin + y * head.biWidth, level, xmax-xmin);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Adds an ellipse to the existing selection.
- */
-bool CxImage::SelectionAddEllipse(RECT r, uint8_t level)
-{
- if (pSelection==NULL) SelectionCreate();
- if (pSelection==NULL) return false;
-
- int32_t xradius = abs(r.right - r.left)/2;
- int32_t yradius = abs(r.top - r.bottom)/2;
- if (xradius==0 || yradius==0) return false;
-
- int32_t xcenter = (r.right + r.left)/2;
- int32_t ycenter = (r.top + r.bottom)/2;
-
- if (info.rSelectionBox.left > (xcenter - xradius)) info.rSelectionBox.left = max(0L,min(head.biWidth,(xcenter - xradius)));
- if (info.rSelectionBox.right <= (xcenter + xradius)) info.rSelectionBox.right = max(0L,min(head.biWidth,(xcenter + xradius + 1)));
- if (info.rSelectionBox.bottom > (ycenter - yradius)) info.rSelectionBox.bottom = max(0L,min(head.biHeight,(ycenter - yradius)));
- if (info.rSelectionBox.top <= (ycenter + yradius)) info.rSelectionBox.top = max(0L,min(head.biHeight,(ycenter + yradius + 1)));
-
- int32_t xmin = max(0L,min(head.biWidth,xcenter - xradius));
- int32_t xmax = max(0L,min(head.biWidth,xcenter + xradius + 1));
- int32_t ymin = max(0L,min(head.biHeight,ycenter - yradius));
- int32_t ymax = max(0L,min(head.biHeight,ycenter + yradius + 1));
-
- int32_t y,yo;
- for (y=ymin; y<min(ycenter,ymax); y++){
- for (int32_t x=xmin; x<xmax; x++){
- yo = (int32_t)(ycenter - yradius * sqrt(1-pow((float)(x - xcenter)/(float)xradius,2)));
- if (yo<y) pSelection[x + y * head.biWidth] = level;
- }
- }
- for (y=ycenter; y<ymax; y++){
- for (int32_t x=xmin; x<xmax; x++){
- yo = (int32_t)(ycenter + yradius * sqrt(1-pow((float)(x - xcenter)/(float)xradius,2)));
- if (yo>y) pSelection[x + y * head.biWidth] = level;
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Inverts the selection.
- * Note: the SelectionBox is set to "full image", call SelectionGetBox before (if necessary)
- */
-bool CxImage::SelectionInvert()
-{
- if (pSelection) {
- uint8_t *iSrc=pSelection;
- int32_t n=head.biHeight*head.biWidth;
- for(int32_t i=0; i < n; i++){
- *iSrc=(uint8_t)~(*(iSrc));
- iSrc++;
- }
-
- SelectionRebuildBox();
-
- return true;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Imports an existing region from another image with the same width and height.
- */
-bool CxImage::SelectionCopy(CxImage &from)
-{
- if (from.pSelection == NULL || head.biWidth != from.head.biWidth || head.biHeight != from.head.biHeight) return false;
- if (pSelection==NULL) pSelection = (uint8_t*)malloc(head.biWidth * head.biHeight);
- if (pSelection==NULL) return false;
- memcpy(pSelection,from.pSelection,head.biWidth * head.biHeight);
- memcpy(&info.rSelectionBox,&from.info.rSelectionBox,sizeof(RECT));
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Adds a polygonal region to the existing selection. points points to an array of POINT structures.
- * Each structure specifies the x-coordinate and y-coordinate of one vertex of the polygon.
- * npoints specifies the number of POINT structures in the array pointed to by points.
- */
-bool CxImage::SelectionAddPolygon(POINT *points, int32_t npoints, uint8_t level)
-{
- if (points==NULL || npoints<3) return false;
-
- if (pSelection==NULL) SelectionCreate();
- if (pSelection==NULL) return false;
-
- uint8_t* plocal = (uint8_t*)calloc(head.biWidth*head.biHeight, 1);
- RECT localbox = {head.biWidth,0,0,head.biHeight};
-
- int32_t x,y,i=0;
- POINT *current;
- POINT *next = NULL;
- POINT *start = NULL;
- //trace contour
- while (i < npoints){
- current = &points[i];
- if (current->x!=-1){
- if (i==0 || (i>0 && points[i-1].x==-1)) start = &points[i];
-
- if ((i+1)==npoints || points[i+1].x==-1)
- next = start;
- else
- next = &points[i+1];
-
- float beta;
- if (current->x != next->x){
- beta = (float)(next->y - current->y)/(float)(next->x - current->x);
- if (current->x < next->x){
- for (x=current->x; x<=next->x; x++){
- y = (int32_t)(current->y + (x - current->x) * beta);
- if (IsInside(x,y)) plocal[x + y * head.biWidth] = 255;
- }
- } else {
- for (x=current->x; x>=next->x; x--){
- y = (int32_t)(current->y + (x - current->x) * beta);
- if (IsInside(x,y)) plocal[x + y * head.biWidth] = 255;
- }
- }
- }
- if (current->y != next->y){
- beta = (float)(next->x - current->x)/(float)(next->y - current->y);
- if (current->y < next->y){
- for (y=current->y; y<=next->y; y++){
- x = (int32_t)(current->x + (y - current->y) * beta);
- if (IsInside(x,y)) plocal[x + y * head.biWidth] = 255;
- }
- } else {
- for (y=current->y; y>=next->y; y--){
- x = (int32_t)(current->x + (y - current->y) * beta);
- if (IsInside(x,y)) plocal[x + y * head.biWidth] = 255;
- }
- }
- }
- }
-
- RECT r2;
- if (current->x < next->x) {r2.left=current->x; r2.right=next->x; } else {r2.left=next->x ; r2.right=current->x; }
- if (current->y < next->y) {r2.bottom=current->y; r2.top=next->y; } else {r2.bottom=next->y ; r2.top=current->y; }
- if (localbox.top < r2.top) localbox.top = max(0L,min(head.biHeight-1,r2.top+1));
- if (localbox.left > r2.left) localbox.left = max(0L,min(head.biWidth-1,r2.left-1));
- if (localbox.right < r2.right) localbox.right = max(0L,min(head.biWidth-1,r2.right+1));
- if (localbox.bottom > r2.bottom) localbox.bottom = max(0L,min(head.biHeight-1,r2.bottom-1));
-
- i++;
- }
-
- //fill the outer region
- int32_t npix=(localbox.right - localbox.left)*(localbox.top - localbox.bottom);
- POINT* pix = (POINT*)calloc(npix,sizeof(POINT));
- uint8_t back=0, mark=1;
- int32_t fx, fy, fxx, fyy, first, last;
- int32_t xmin = 0;
- int32_t xmax = 0;
- int32_t ymin = 0;
- int32_t ymax = 0;
-
- for (int32_t side=0; side<4; side++){
- switch(side){
- case 0:
- xmin=localbox.left; xmax=localbox.right+1; ymin=localbox.bottom; ymax=localbox.bottom+1;
- break;
- case 1:
- xmin=localbox.right; xmax=localbox.right+1; ymin=localbox.bottom; ymax=localbox.top+1;
- break;
- case 2:
- xmin=localbox.left; xmax=localbox.right+1; ymin=localbox.top; ymax=localbox.top+1;
- break;
- case 3:
- xmin=localbox.left; xmax=localbox.left+1; ymin=localbox.bottom; ymax=localbox.top+1;
- break;
- }
- //fill from the border points
- for(y=ymin;y<ymax;y++){
- for(x=xmin;x<xmax;x++){
- if (plocal[x+y*head.biWidth]==0){
- // Subject: FLOOD FILL ROUTINE Date: 12-23-97 (00:57)
- // Author: Petter Holmberg Code: QB, QBasic, PDS
- // Origin: petter.holmberg@usa.net Packet: GRAPHICS.ABC
- first=0;
- last=1;
- while(first!=last){
- fx = pix[first].x;
- fy = pix[first].y;
- fxx = fx + x;
- fyy = fy + y;
- for(;;)
- {
- if ((plocal[fxx + fyy*head.biWidth] == back) &&
- fxx>=localbox.left && fxx<=localbox.right && fyy>=localbox.bottom && fyy<=localbox.top )
- {
- plocal[fxx + fyy*head.biWidth] = mark;
- if (fyy > 0 && plocal[fxx + (fyy - 1)*head.biWidth] == back){
- pix[last].x = fx;
- pix[last].y = fy - 1;
- last++;
- if (last == npix) last = 0;
- }
- if ((fyy + 1)<head.biHeight && plocal[fxx + (fyy + 1)*head.biWidth] == back){
- pix[last].x = fx;
- pix[last].y = fy + 1;
- last++;
- if (last == npix) last = 0;
- }
- } else {
- break;
- }
- fx++;
- fxx++;
- };
-
- fx = pix[first].x - 1;
- fy = pix[first].y;
- fxx = fx + x;
- fyy = fy + y;
-
- for( ;; )
- {
- if ((plocal[fxx + fyy*head.biWidth] == back) &&
- fxx>=localbox.left && fxx<=localbox.right && fyy>=localbox.bottom && fyy<=localbox.top )
- {
- plocal[fxx + (y + fy)*head.biWidth] = mark;
- if (fyy > 0 && plocal[fxx + (fyy - 1)*head.biWidth] == back){
- pix[last].x = fx;
- pix[last].y = fy - 1;
- last++;
- if (last == npix) last = 0;
- }
- if ((fyy + 1)<head.biHeight && plocal[fxx + (fyy + 1)*head.biWidth] == back){
- pix[last].x = fx;
- pix[last].y = fy + 1;
- last++;
- if (last == npix) last = 0;
- }
- } else {
- break;
- }
- fx--;
- fxx--;
- }
-
- first++;
- if (first == npix) first = 0;
- }
- }
- }
- }
- }
-
- //transfer the region
- int32_t yoffset;
- for (y=localbox.bottom; y<=localbox.top; y++){
- yoffset = y * head.biWidth;
- for (x=localbox.left; x<=localbox.right; x++)
- if (plocal[x + yoffset]!=1) pSelection[x + yoffset]=level;
- }
- if (info.rSelectionBox.top <= localbox.top) info.rSelectionBox.top = min(head.biHeight,localbox.top + 1);
- if (info.rSelectionBox.left > localbox.left) info.rSelectionBox.left = min(head.biWidth,localbox.left);
- if (info.rSelectionBox.right <= localbox.right) info.rSelectionBox.right = min(head.biWidth,localbox.right + 1);
- if (info.rSelectionBox.bottom > localbox.bottom) info.rSelectionBox.bottom = min(head.biHeight,localbox.bottom);
-
- free(plocal);
- free(pix);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Adds to the selection all the pixels matching the specified color.
- */
-bool CxImage::SelectionAddColor(RGBQUAD c, uint8_t level)
-{
- if (pSelection==NULL) SelectionCreate();
- if (pSelection==NULL) return false;
-
- RECT localbox = {head.biWidth,0,0,head.biHeight};
-
- for (int32_t y = 0; y < head.biHeight; y++){
- for (int32_t x = 0; x < head.biWidth; x++){
- RGBQUAD color = BlindGetPixelColor(x, y);
- if (color.rgbRed == c.rgbRed &&
- color.rgbGreen == c.rgbGreen &&
- color.rgbBlue == c.rgbBlue)
- {
- pSelection[x + y * head.biWidth] = level;
-
- if (localbox.top < y) localbox.top = y;
- if (localbox.left > x) localbox.left = x;
- if (localbox.right < x) localbox.right = x;
- if (localbox.bottom > y) localbox.bottom = y;
- }
- }
- }
-
- if (info.rSelectionBox.top <= localbox.top) info.rSelectionBox.top = localbox.top + 1;
- if (info.rSelectionBox.left > localbox.left) info.rSelectionBox.left = localbox.left;
- if (info.rSelectionBox.right <= localbox.right) info.rSelectionBox.right = localbox.right + 1;
- if (info.rSelectionBox.bottom > localbox.bottom) info.rSelectionBox.bottom = localbox.bottom;
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Adds a single pixel to the existing selection.
- */
-bool CxImage::SelectionAddPixel(int32_t x, int32_t y, uint8_t level)
-{
- if (pSelection==NULL) SelectionCreate();
- if (pSelection==NULL) return false;
-
- if (IsInside(x,y)) {
- pSelection[x + y * head.biWidth] = level; // set the correct mask bit
-
- if (info.rSelectionBox.top <= y) info.rSelectionBox.top = y+1;
- if (info.rSelectionBox.left > x) info.rSelectionBox.left = x;
- if (info.rSelectionBox.right <= x) info.rSelectionBox.right = x+1;
- if (info.rSelectionBox.bottom > y) info.rSelectionBox.bottom = y;
-
- return true;
- }
-
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Exports the selection channel in a 8bpp grayscale image.
- */
-bool CxImage::SelectionSplit(CxImage *dest)
-{
- if (!pSelection || !dest) return false;
-
- CxImage tmp(head.biWidth,head.biHeight,8);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- for(int32_t y=0; y<head.biHeight; y++){
- for(int32_t x=0; x<head.biWidth; x++){
- tmp.BlindSetPixelIndex(x,y,pSelection[x+y*head.biWidth]);
- }
- }
-
- tmp.SetGrayPalette();
- dest->Transfer(tmp);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Creates the selection channel from a gray scale image.
- * black = unselected
- */
-bool CxImage::SelectionSet(CxImage &from)
-{
- if (!from.IsGrayScale() || head.biWidth != from.head.biWidth || head.biHeight != from.head.biHeight){
- strcpy(info.szLastError,"CxImage::SelectionSet: wrong width or height, or image is not gray scale");
- return false;
- }
-
- if (pSelection==NULL) pSelection = (uint8_t*)malloc(head.biWidth * head.biHeight);
-
- uint8_t* src = from.info.pImage;
- uint8_t* dst = pSelection;
- if (src==NULL || dst==NULL){
- strcpy(info.szLastError,"CxImage::SelectionSet: null pointer");
- return false;
- }
-
- for (int32_t y=0; y<head.biHeight; y++){
- memcpy(dst,src,head.biWidth);
- dst += head.biWidth;
- src += from.info.dwEffWidth;
- }
-
- SelectionRebuildBox();
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets the Selection level for a single pixel
- * internal use only: doesn't set SelectionBox. Use SelectionAddPixel
- */
-void CxImage::SelectionSet(const int32_t x,const int32_t y,const uint8_t level)
-{
- if (pSelection && IsInside(x,y)) pSelection[x+y*head.biWidth]=level;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the Selection level for a single pixel
- */
-uint8_t CxImage::SelectionGet(const int32_t x,const int32_t y)
-{
- if (pSelection && IsInside(x,y)) return pSelection[x+y*head.biWidth];
- return 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Rebuilds the SelectionBox
- */
-void CxImage::SelectionRebuildBox()
-{
- info.rSelectionBox.left = head.biWidth;
- info.rSelectionBox.bottom = head.biHeight;
- info.rSelectionBox.right = info.rSelectionBox.top = 0;
-
- if (!pSelection)
- return;
-
- int32_t x,y;
-
- for (y=0; y<head.biHeight; y++){
- for (x=0; x<info.rSelectionBox.left; x++){
- if (pSelection[x+y*head.biWidth]){
- info.rSelectionBox.left = x;
- continue;
- }
- }
- }
-
- for (y=0; y<head.biHeight; y++){
- for (x=head.biWidth-1; x>=info.rSelectionBox.right; x--){
- if (pSelection[x+y*head.biWidth]){
- info.rSelectionBox.right = x+1;
- continue;
- }
- }
- }
-
- for (x=0; x<head.biWidth; x++){
- for (y=0; y<info.rSelectionBox.bottom; y++){
- if (pSelection[x+y*head.biWidth]){
- info.rSelectionBox.bottom = y;
- continue;
- }
- }
- }
-
- for (x=0; x<head.biWidth; x++){
- for (y=head.biHeight-1; y>=info.rSelectionBox.top; y--){
- if (pSelection[x+y*head.biWidth]){
- info.rSelectionBox.top = y+1;
- continue;
- }
- }
- }
-
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the Selection level for a single pixel
- * "blind" version assumes that (x,y) is inside to the image.
- */
-uint8_t CxImage::BlindSelectionGet(const int32_t x,const int32_t y)
-{
-#ifdef _DEBUG
- if (!IsInside(x,y) || (pSelection==0))
- #if CXIMAGE_SUPPORT_EXCEPTION_HANDLING
- throw 0;
- #else
- return 0;
- #endif
-#endif
- return pSelection[x+y*head.biWidth];
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns pointer to selection data for pixel (x,y).
- */
-uint8_t* CxImage::SelectionGetPointer(const int32_t x,const int32_t y)
-{
- if (pSelection && IsInside(x,y)) return pSelection+x+y*head.biWidth;
- return 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::SelectionFlip()
-{
- if (!pSelection) return false;
-
- uint8_t *buff = (uint8_t*)malloc(head.biWidth);
- if (!buff) return false;
-
- uint8_t *iSrc,*iDst;
- iSrc = pSelection + (head.biHeight-1)*head.biWidth;
- iDst = pSelection;
- for (int32_t i=0; i<(head.biHeight/2); ++i)
- {
- memcpy(buff, iSrc, head.biWidth);
- memcpy(iSrc, iDst, head.biWidth);
- memcpy(iDst, buff, head.biWidth);
- iSrc-=head.biWidth;
- iDst+=head.biWidth;
- }
-
- free(buff);
-
- int32_t top = info.rSelectionBox.top;
- info.rSelectionBox.top = head.biHeight - info.rSelectionBox.bottom;
- info.rSelectionBox.bottom = head.biHeight - top;
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::SelectionMirror()
-{
- if (!pSelection) return false;
- uint8_t* pSelection2 = (uint8_t*)malloc(head.biWidth * head.biHeight);
- if (!pSelection2) return false;
-
- uint8_t *iSrc,*iDst;
- int32_t wdt=head.biWidth-1;
- iSrc=pSelection + wdt;
- iDst=pSelection2;
- for(int32_t y=0; y < head.biHeight; y++){
- for(int32_t x=0; x <= wdt; x++)
- *(iDst+x)=*(iSrc-x);
- iSrc+=head.biWidth;
- iDst+=head.biWidth;
- }
- free(pSelection);
- pSelection=pSelection2;
-
- int32_t left = info.rSelectionBox.left;
- info.rSelectionBox.left = head.biWidth - info.rSelectionBox.right;
- info.rSelectionBox.right = head.biWidth - left;
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_WINDOWS
-/**
- * Converts the selection in a HRGN object.
- */
-bool CxImage::SelectionToHRGN(HRGN& region)
-{
- if (pSelection && region){
- for(int32_t y = 0; y < head.biHeight; y++){
- HRGN hTemp = NULL;
- int32_t iStart = -1;
- int32_t x = 0;
- for(; x < head.biWidth; x++){
- if (pSelection[x + y * head.biWidth] != 0){
- if (iStart == -1) iStart = x;
- continue;
- }else{
- if (iStart >= 0){
- hTemp = CreateRectRgn(iStart, y, x, y + 1);
- CombineRgn(region, hTemp, region, RGN_OR);
- DeleteObject(hTemp);
- iStart = -1;
- }
- }
- }
- if (iStart >= 0){
- hTemp = CreateRectRgn(iStart, y, x, y + 1);
- CombineRgn(region, hTemp, region, RGN_OR);
- DeleteObject(hTemp);
- iStart = -1;
- }
- }
- return true;
- }
- return false;
-}
-#endif //CXIMAGE_SUPPORT_WINDOWS
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_SELECTION
diff --git a/smelt/sdl/CxImage/ximaska.cpp b/smelt/sdl/CxImage/ximaska.cpp deleted file mode 100644 index 6f1b1c2..0000000 --- a/smelt/sdl/CxImage/ximaska.cpp +++ /dev/null @@ -1,126 +0,0 @@ -/*
- * File: ximaska.cpp
- * Purpose: Platform Independent SKA Image Class Loader and Writer
- * 25/Sep/2007 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximaska.h"
-
-#if CXIMAGE_SUPPORT_SKA
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageSKA::Decode(CxFile *hFile)
-{
- if (hFile==NULL)
- return false;
-
- // read the header
- SKAHEADER ska_header;
- hFile->Read(&ska_header,sizeof(SKAHEADER),1);
-
- ska_header.Width = m_ntohs(ska_header.Width);
- ska_header.Height = m_ntohs(ska_header.Height);
- ska_header.dwUnknown = m_ntohl(ska_header.dwUnknown);
-
- // check header
- if (ska_header.dwUnknown != 0x01000000 ||
- ska_header.Width > 0x7FFF || ska_header.Height > 0x7FFF ||
- ska_header.BppExp != 3)
- return false;
-
- if (info.nEscape == -1){
- head.biWidth = ska_header.Width ;
- head.biHeight= ska_header.Height;
- info.dwType = CXIMAGE_FORMAT_SKA;
- return true;
- }
-
- int32_t bpp = 1<<ska_header.BppExp;
-
- Create(ska_header.Width,ska_header.Height,bpp,CXIMAGE_FORMAT_SKA);
- if (!IsValid())
- return false;
-
- // read the palette
- int32_t nColors = 1<<bpp;
- rgb_color* ppal = (rgb_color*)malloc(nColors*sizeof(rgb_color));
- if (!ppal) return false;
- hFile->Read(ppal,nColors*sizeof(rgb_color),1);
- SetPalette(ppal,nColors);
- free(ppal);
-
- //read the image
- hFile->Read(GetBits(),ska_header.Width*ska_header.Height,1);
-
- //reorder rows
- if (GetEffWidth() != ska_header.Width){
- uint8_t *src,*dst;
- src = GetBits() + ska_header.Width*(ska_header.Height-1);
- dst = GetBits(ska_header.Height-1);
- for(int32_t y=0;y<ska_header.Height;y++){
- memcpy(dst,src,ska_header.Width);
- src -= ska_header.Width;
- dst -= GetEffWidth();
- }
- }
-
- Flip();
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageSKA::Encode(CxFile * hFile)
-{
- if (EncodeSafeCheck(hFile)) return false;
-
- if(head.biBitCount > 8) {
- strcpy(info.szLastError,"SKA Images must be 8 bit or less");
- return false;
- }
-
- SKAHEADER ska_header;
-
- ska_header.Width = (uint16_t)GetWidth();
- ska_header.Height = (uint16_t)GetHeight();
- ska_header.BppExp = 3;
- ska_header.dwUnknown = 0x01000000;
-
- ska_header.Width = m_ntohs(ska_header.Width);
- ska_header.Height = m_ntohs(ska_header.Height);
- ska_header.dwUnknown = m_ntohl(ska_header.dwUnknown);
-
- hFile->Write(&ska_header,sizeof(SKAHEADER),1);
-
- ska_header.Width = m_ntohs(ska_header.Width);
- ska_header.Height = m_ntohs(ska_header.Height);
- ska_header.dwUnknown = m_ntohl(ska_header.dwUnknown);
-
- if (head.biBitCount<8) IncreaseBpp(8);
-
- rgb_color pal[256];
- for(int32_t idx=0; idx<256; idx++){
- GetPaletteColor(idx,&(pal[idx].r),&(pal[idx].g),&(pal[idx].b));
- }
-
- hFile->Write(pal,256*sizeof(rgb_color),1);
-
- uint8_t* src = GetBits(ska_header.Height-1);
- for(int32_t y=0;y<ska_header.Height;y++){
- hFile->Write(src,ska_header.Width,1);
- src -= GetEffWidth();
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_SKA
-
diff --git a/smelt/sdl/CxImage/ximaska.h b/smelt/sdl/CxImage/ximaska.h deleted file mode 100644 index ad3f598..0000000 --- a/smelt/sdl/CxImage/ximaska.h +++ /dev/null @@ -1,44 +0,0 @@ -/*
- * File: ximaska.h
- * Purpose: SKA Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImageSKA (c) 25/Sep/2007 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- * ==========================================================
- */
-#if !defined(__ximaSKA_h)
-#define __ximaSKA_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_SKA
-
-class CxImageSKA: public CxImage
-{
-#pragma pack(1)
- typedef struct tagSkaHeader {
- uint16_t Width;
- uint16_t Height;
- uint8_t BppExp;
- uint32_t dwUnknown;
-} SKAHEADER;
-#pragma pack()
-
-public:
- CxImageSKA(): CxImage(CXIMAGE_FORMAT_SKA) {}
-
-// bool Load(const char * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_ICO);}
-// bool Save(const char * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_ICO);}
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximatga.cpp b/smelt/sdl/CxImage/ximatga.cpp deleted file mode 100644 index f1a762a..0000000 --- a/smelt/sdl/CxImage/ximatga.cpp +++ /dev/null @@ -1,320 +0,0 @@ -/*
- * File: ximatga.cpp
- * Purpose: Platform Independent TGA Image Class Loader and Writer
- * 05/Jan/2001 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximatga.h"
-
-#if CXIMAGE_SUPPORT_TGA
-
-#include "ximaiter.h"
-
-// Definitions for image types.
-#define TGA_Null 0
-#define TGA_Map 1
-#define TGA_RGB 2
-#define TGA_Mono 3
-#define TGA_RLEMap 9
-#define TGA_RLERGB 10
-#define TGA_RLEMono 11
-#define TGA_CompMap 32
-#define TGA_CompMap4 33
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageTGA::Decode(CxFile *hFile)
-{
- if (hFile == NULL) return false;
-
- TGAHEADER tgaHead;
-
- cx_try
- {
- if (hFile->Read(&tgaHead,sizeof(tgaHead),1)==0)
- cx_throw("Not a TGA");
-
- tga_toh(&tgaHead);
-
- bool bCompressed;
- switch (tgaHead.ImageType){
- case TGA_Map:
- case TGA_RGB:
- case TGA_Mono:
- bCompressed = false;
- break;
- case TGA_RLEMap:
- case TGA_RLERGB:
- case TGA_RLEMono:
- bCompressed = true;
- break;
- default:
- cx_throw("Unknown TGA image type");
- }
-
- if (tgaHead.ImageWidth==0 || tgaHead.ImageHeight==0 || tgaHead.PixelDepth==0 || tgaHead.CmapLength>256)
- cx_throw("bad TGA header");
-
- if (tgaHead.PixelDepth!=8 && tgaHead.PixelDepth!=15 && tgaHead.PixelDepth!=16 && tgaHead.PixelDepth!=24 && tgaHead.PixelDepth!=32)
- cx_throw("bad TGA header");
-
- if (info.nEscape == -1){
- head.biWidth = tgaHead.ImageWidth ;
- head.biHeight= tgaHead.ImageHeight;
- info.dwType = CXIMAGE_FORMAT_TGA;
- return true;
- }
-
- if (tgaHead.IdLength>0) hFile->Seek(tgaHead.IdLength,SEEK_CUR); //skip descriptor
-
- Create(tgaHead.ImageWidth, tgaHead.ImageHeight, tgaHead.PixelDepth, CXIMAGE_FORMAT_TGA);
-#if CXIMAGE_SUPPORT_ALPHA // <vho>
- if (tgaHead.PixelDepth==32) AlphaCreate(); // Image has alpha channel
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- if (!IsValid()) cx_throw("TGA Create failed");
-
- if (info.nEscape) cx_throw("Cancelled"); // <vho> - cancel decoding
-
- if (tgaHead.CmapType != 0){ // read the palette
- rgb_color pal[256];
- hFile->Read(pal,tgaHead.CmapLength*sizeof(rgb_color), 1);
- for (int32_t i=0;i<tgaHead.CmapLength; i++) SetPaletteColor((uint8_t)i,pal[i].b,pal[i].g,pal[i].r);
- }
-
- if (tgaHead.ImageType == TGA_Mono || tgaHead.ImageType == TGA_RLEMono)
- SetGrayPalette();
-
- // Bits 4 & 5 of the Image Descriptor byte control the ordering of the pixels.
- bool bXReversed = ((tgaHead.ImagDesc & 16) == 16);
- bool bYReversed = ((tgaHead.ImagDesc & 32) == 32);
-
- CImageIterator iter(this);
- uint8_t rleLeftover = 255; //for images with illegal packet boundary
- uint8_t* pDest;
- for (int32_t y=0; y < tgaHead.ImageHeight; y++){
-
- if (info.nEscape) cx_throw("Cancelled"); // <vho> - cancel decoding
-
- if (hFile == NULL || hFile->Eof()) cx_throw("corrupted TGA");
-
- if (bYReversed) pDest = iter.GetRow(tgaHead.ImageHeight-y-1);
- else pDest = iter.GetRow(y);
-
- if (bCompressed) rleLeftover = ExpandCompressedLine(pDest,&tgaHead,hFile,tgaHead.ImageWidth,y,rleLeftover);
- else ExpandUncompressedLine (pDest,&tgaHead,hFile,tgaHead.ImageWidth,y,0);
- }
-
- if (bXReversed) Mirror();
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (bYReversed && tgaHead.PixelDepth==32) AlphaFlip(); //<lioucr>
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- return false;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageTGA::Encode(CxFile * hFile)
-{
- if (EncodeSafeCheck(hFile)) return false;
-
- if (head.biBitCount<8){
- strcpy(info.szLastError,"Bit depth must be 8 or 24");
- return false;
- }
-
- TGAHEADER tgaHead;
-
- tgaHead.IdLength = 0; // Image ID Field Length
- tgaHead.CmapType = GetPalette()!=0; // Color Map Type
- tgaHead.ImageType = (head.biBitCount == 8) ? (uint8_t)TGA_Map : (uint8_t)TGA_RGB; // Image Type
-
- tgaHead.CmapIndex=0; // First Entry Index
- tgaHead.CmapLength=(head.biBitCount == 8) ? 256 : 0; // Color Map Length
- tgaHead.CmapEntrySize=(head.biBitCount == 8) ? (uint8_t)24 : (uint8_t)0; // Color Map Entry Size
-
- tgaHead.X_Origin=0; // X-origin of Image
- tgaHead.Y_Origin=0; // Y-origin of Image
- tgaHead.ImageWidth=(uint16_t)head.biWidth; // Image Width
- tgaHead.ImageHeight=(uint16_t)head.biHeight; // Image Height
- tgaHead.PixelDepth=(uint8_t)head.biBitCount; // Pixel Depth
- tgaHead.ImagDesc=0; // Image Descriptor
-
- if (pAlpha && head.biBitCount==24) tgaHead.PixelDepth=32;
-
- tga_toh(&tgaHead);
- hFile->Write(&tgaHead,sizeof(TGAHEADER),1);
- tga_toh(&tgaHead);
-
- if (head.biBitCount==8){
- rgb_color pal[256];
- RGBQUAD* ppal = GetPalette();
- for (int32_t i=0;i<256; i++){
- pal[i].r = ppal[i].rgbBlue;
- pal[i].g = ppal[i].rgbGreen;
- pal[i].b = ppal[i].rgbRed;
- }
- hFile->Write(&pal,256*sizeof(rgb_color),1);
- }
-
- CImageIterator iter(this);
- uint8_t* pDest;
- if (pAlpha==0 || head.biBitCount==8){
- for (int32_t y=0; y < tgaHead.ImageHeight; y++){
- pDest = iter.GetRow(y);
- hFile->Write(pDest,tgaHead.ImageWidth * (head.biBitCount >> 3),1);
- }
- } else {
- pDest = (uint8_t*)malloc(4*tgaHead.ImageWidth);
- RGBQUAD c;
- for (int32_t y=0; y < tgaHead.ImageHeight; y++){
- for(int32_t x=0, x4=0;x<tgaHead.ImageWidth;x++, x4+=4){
- c = BlindGetPixelColor(x,y);
- pDest[x4+0]=c.rgbBlue;
- pDest[x4+1]=c.rgbGreen;
- pDest[x4+2]=c.rgbRed;
-#if CXIMAGE_SUPPORT_ALPHA // <vho>
- pDest[x4+3]=AlphaGet(x,y);
-#else
- pDest[x4+3]=0;
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- hFile->Write(pDest,4*tgaHead.ImageWidth,1);
- }
- free(pDest);
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-uint8_t CxImageTGA::ExpandCompressedLine(uint8_t* pDest,TGAHEADER* ptgaHead,CxFile *hFile,int32_t width, int32_t y, uint8_t rleLeftover)
-{
- uint8_t rle;
- int32_t filePos=0;
- for (int32_t x=0; x<width; ){
- if (rleLeftover != 255){
- rle = rleLeftover;
- rleLeftover = 255;
- } else {
- hFile->Read(&rle,1,1);
- }
- if (rle & 128) { // RLE-Encoded packet
- rle -= 127; // Calculate real repeat count.
- if ((x+rle)>width){
- rleLeftover = (uint8_t)(128 + (rle - (width - x) - 1));
- filePos = hFile->Tell();
- rle = (uint8_t)(width - x);
- }
- switch (ptgaHead->PixelDepth)
- {
- case 32: {
- RGBQUAD color;
- hFile->Read(&color,4,1);
- for (int32_t ix = 0; ix < rle; ix++){
- memcpy(&pDest[3*ix],&color,3);
-#if CXIMAGE_SUPPORT_ALPHA // <vho>
- AlphaSet(ix+x,y,color.rgbReserved);
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- break;
- }
- case 24: {
- rgb_color triple;
- hFile->Read(&triple,3,1);
- for (int32_t ix = 0; ix < rle; ix++) memcpy(&pDest[3*ix],&triple,3);
- break;
- }
- case 15:
- case 16: {
- uint16_t pixel;
- hFile->Read(&pixel,2,1);
- rgb_color triple;
- triple.r = (uint8_t)(( pixel & 0x1F ) * 8); // red
- triple.g = (uint8_t)(( pixel >> 2 ) & 0x0F8); // green
- triple.b = (uint8_t)(( pixel >> 7 ) & 0x0F8); // blue
- for (int32_t ix = 0; ix < rle; ix++){
- memcpy(&pDest[3*ix],&triple,3);
- }
- break;
- }
- case 8: {
- uint8_t pixel;
- hFile->Read(&pixel,1,1);
- for (int32_t ix = 0; ix < rle; ix++) pDest[ix] = pixel;
- }
- }
- if (rleLeftover!=255) hFile->Seek(filePos, SEEK_SET);
- } else { // Raw packet
- rle += 1; // Calculate real repeat count.
- if ((x+rle)>width){
- rleLeftover = (uint8_t)(rle - (width - x) - 1);
- rle = (uint8_t)(width - x);
- }
- ExpandUncompressedLine(pDest,ptgaHead,hFile,rle,y,x);
- }
- if (head.biBitCount == 24) pDest += rle*3; else pDest += rle;
- x += rle;
- }
- return rleLeftover;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageTGA::ExpandUncompressedLine(uint8_t* pDest,TGAHEADER* ptgaHead,CxFile *hFile,int32_t width, int32_t y, int32_t xoffset)
-{
- switch (ptgaHead->PixelDepth){
- case 8:
- hFile->Read(pDest,width,1);
- break;
- case 15:
- case 16:{
- uint8_t* dst=pDest;
- uint16_t pixel;
- for (int32_t x=0; x<width; x++){
- hFile->Read(&pixel,2,1);
- *dst++ = (uint8_t)(( pixel & 0x1F ) * 8); // blue
- *dst++ = (uint8_t)(( pixel >> 2 ) & 0x0F8); // green
- *dst++ = (uint8_t)(( pixel >> 7 ) & 0x0F8); // red
- }
- break;
- }
- case 24:
- hFile->Read(pDest,3*width,1);
- break;
- case 32:{
- uint8_t* dst=pDest;
- for (int32_t x=0; x<width; x++){
- RGBQUAD pixel;
- hFile->Read(&pixel,4,1);
- *dst++ = pixel.rgbBlue;
- *dst++ = pixel.rgbGreen;
- *dst++ = pixel.rgbRed;
-#if CXIMAGE_SUPPORT_ALPHA // <vho>
- AlphaSet(x+xoffset,y,pixel.rgbReserved); //alpha
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- break;
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageTGA::tga_toh(TGAHEADER* p)
-{
- p->CmapIndex = m_ntohs(p->CmapIndex);
- p->CmapLength = m_ntohs(p->CmapLength);
- p->X_Origin = m_ntohs(p->X_Origin);
- p->Y_Origin = m_ntohs(p->Y_Origin);
- p->ImageWidth = m_ntohs(p->ImageWidth);
- p->ImageHeight = m_ntohs(p->ImageHeight);
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_TGA
diff --git a/smelt/sdl/CxImage/ximatga.h b/smelt/sdl/CxImage/ximatga.h deleted file mode 100644 index 3cbc36a..0000000 --- a/smelt/sdl/CxImage/ximatga.h +++ /dev/null @@ -1,61 +0,0 @@ -/*
- * File: ximatga.h
- * Purpose: TARGA Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImageTGA (c) 05/Jan/2002 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- *
- * Parts of the code come from Paintlib : Copyright (c) 1996-1998 Ulrich von Zadow
- * ==========================================================
- */
-#if !defined(__ximaTGA_h)
-#define __ximaTGA_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_TGA
-
-class CxImageTGA: public CxImage
-{
-#pragma pack(1)
-typedef struct tagTgaHeader
-{
- uint8_t IdLength; // Image ID Field Length
- uint8_t CmapType; // Color Map Type
- uint8_t ImageType; // Image Type
-
- uint16_t CmapIndex; // First Entry Index
- uint16_t CmapLength; // Color Map Length
- uint8_t CmapEntrySize; // Color Map Entry Size
-
- uint16_t X_Origin; // X-origin of Image
- uint16_t Y_Origin; // Y-origin of Image
- uint16_t ImageWidth; // Image Width
- uint16_t ImageHeight; // Image Height
- uint8_t PixelDepth; // Pixel Depth
- uint8_t ImagDesc; // Image Descriptor
-} TGAHEADER;
-#pragma pack()
-
-public:
- CxImageTGA(): CxImage(CXIMAGE_FORMAT_TGA) {}
-
-// bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_TGA);}
-// bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_TGA);}
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-protected:
- uint8_t ExpandCompressedLine(uint8_t* pDest,TGAHEADER* ptgaHead,CxFile *hFile,int32_t width, int32_t y, uint8_t rleLeftover);
- void ExpandUncompressedLine(uint8_t* pDest,TGAHEADER* ptgaHead,CxFile *hFile,int32_t width, int32_t y, int32_t xoffset);
- void tga_toh(TGAHEADER* p);
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximath.cpp b/smelt/sdl/CxImage/ximath.cpp deleted file mode 100644 index 0175184..0000000 --- a/smelt/sdl/CxImage/ximath.cpp +++ /dev/null @@ -1,97 +0,0 @@ -#include "ximage.h"
-#include "ximath.h"
-#include <math.h>
-
-//this module should contain some classes for geometrical transformations
-//usable with selections, etc... once it's done, that is. :)
-
-CxPoint2::CxPoint2()
-{
- x=y=0.0f;
-}
-
-CxPoint2::CxPoint2(float const x_, float const y_)
-{
- x=x_;
- y=y_;
-}
-
-CxPoint2::CxPoint2(CxPoint2 const &p)
-{
- x=p.x;
- y=p.y;
-}
-
-float CxPoint2::Distance(CxPoint2 const p2)
-{
- return (float)sqrt((x-p2.x)*(x-p2.x)+(y-p2.y)*(y-p2.y));
-}
-
-float CxPoint2::Distance(float const x_, float const y_)
-{
- return (float)sqrt((x-x_)*(x-x_)+(y-y_)*(y-y_));
-}
-
-CxRect2::CxRect2()
-{
-}
-
-CxRect2::CxRect2(float const x1_, float const y1_, float const x2_, float const y2_)
-{
- botLeft.x=x1_;
- botLeft.y=y1_;
- topRight.x=x2_;
- topRight.y=y2_;
-}
-
-CxRect2::CxRect2(CxRect2 const &p)
-{
- botLeft=p.botLeft;
- topRight=p.topRight;
-}
-
-float CxRect2::Surface() const
-/*
- * Returns the surface of rectangle.
- */
-{
- return (topRight.x-botLeft.x)*(topRight.y-botLeft.y);
-}
-
-CxRect2 CxRect2::CrossSection(CxRect2 const &r2) const
-/*
- * Returns crossection with another rectangle.
- */
-{
- CxRect2 cs;
- cs.botLeft.x=max(botLeft.x, r2.botLeft.x);
- cs.botLeft.y=max(botLeft.y, r2.botLeft.y);
- cs.topRight.x=min(topRight.x, r2.topRight.x);
- cs.topRight.y=min(topRight.y, r2.topRight.y);
- if (cs.botLeft.x<=cs.topRight.x && cs.botLeft.y<=cs.topRight.y) {
- return cs;
- } else {
- return CxRect2(0,0,0,0);
- }//if
-}
-
-CxPoint2 CxRect2::Center() const
-/*
- * Returns the center point of rectangle.
- */
-{
- return CxPoint2((topRight.x+botLeft.x)/2.0f, (topRight.y+botLeft.y)/2.0f);
-}
-
-float CxRect2::Width() const
-//returns rectangle width
-{
- return topRight.x-botLeft.x;
-}
-
-float CxRect2::Height() const
-//returns rectangle height
-{
- return topRight.y-botLeft.y;
-}
-
diff --git a/smelt/sdl/CxImage/ximath.h b/smelt/sdl/CxImage/ximath.h deleted file mode 100644 index 014c14b..0000000 --- a/smelt/sdl/CxImage/ximath.h +++ /dev/null @@ -1,39 +0,0 @@ -#if !defined(__ximath_h)
-#define __ximath_h
-
-#include "ximadef.h"
-
-//***bd*** simple floating point point
-class DLL_EXP CxPoint2
-{
-public:
- CxPoint2();
- CxPoint2(float const x_, float const y_);
- CxPoint2(CxPoint2 const &p);
-
- float Distance(CxPoint2 const p2);
- float Distance(float const x_, float const y_);
-
- float x,y;
-};
-
-//and simple rectangle
-class DLL_EXP CxRect2
-{
-public:
- CxRect2();
- CxRect2(float const x1_, float const y1_, float const x2_, float const y2_);
- CxRect2(CxPoint2 const &bl, CxPoint2 const &tr);
- CxRect2(CxRect2 const &p);
-
- float Surface() const;
- CxRect2 CrossSection(CxRect2 const &r2) const;
- CxPoint2 Center() const;
- float Width() const;
- float Height() const;
-
- CxPoint2 botLeft;
- CxPoint2 topRight;
-};
-
-#endif
diff --git a/smelt/sdl/CxImage/ximatif.cpp b/smelt/sdl/CxImage/ximatif.cpp deleted file mode 100644 index 7675361..0000000 --- a/smelt/sdl/CxImage/ximatif.cpp +++ /dev/null @@ -1,982 +0,0 @@ -/*
- * File: ximatif.cpp
- * Purpose: Platform Independent TIFF Image Class Loader and Writer
- * 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximatif.h"
-
-#if CXIMAGE_SUPPORT_TIF
-
-#define FIX_16BPP_DARKIMG // + VK: if uncomment, dark 16bpp images are fixed
-
-#include "../tiff/tiffio.h"
-
-#define CVT(x) (((x) * 255L) / ((1L<<16)-1))
-#define SCALE(x) (((x)*((1L<<16)-1))/255)
-#define CalculateLine(width,bitdepth) (((width * bitdepth) + 7) / 8)
-#define CalculatePitch(line) (line + 3 & ~3)
-
-extern "C" TIFF* _TIFFOpenEx(CxFile* stream, const char* mode);
-
-////////////////////////////////////////////////////////////////////////////////
-CxImageTIF::~CxImageTIF()
-{
- if (m_tif2) TIFFClose(m_tif2);
-}
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageTIF::Decode(CxFile * hFile)
-{
- //Comment this line if you need more information on errors
- // TIFFSetErrorHandler(NULL); //<Patrick Hoffmann>
-
- //Open file and fill the TIFF structure
- // m_tif = TIFFOpen(imageFileName,"rb");
- TIFF* m_tif = _TIFFOpenEx(hFile, "rb");
-
- uint32 height=0;
- uint32 width=0;
- uint16 bitspersample=1;
- uint16 samplesperpixel=1;
- uint32 rowsperstrip=(uint32_t)-1;
- uint16 photometric=0;
- uint16 compression=1;
- uint16 orientation=ORIENTATION_TOPLEFT; //<vho>
- uint16 res_unit; //<Trifon>
- uint32 x, y;
- float resolution, offset;
- BOOL isRGB;
- uint8_t *bits; //pointer to source data
- uint8_t *bits2; //pointer to destination data
-
- cx_try
- {
- //check if it's a tiff file
- if (!m_tif)
- cx_throw("Error encountered while opening TIFF file");
-
- // <Robert Abram> - 12/2002 : get NumFrames directly, instead of looping
- // info.nNumFrames=0;
- // while(TIFFSetDirectory(m_tif,(uint16)info.nNumFrames)) info.nNumFrames++;
- info.nNumFrames = TIFFNumberOfDirectories(m_tif);
-
- if (!TIFFSetDirectory(m_tif, (uint16)info.nFrame))
- cx_throw("Error: page not present in TIFF file");
-
- //get image info
- TIFFGetField(m_tif, TIFFTAG_IMAGEWIDTH, &width);
- TIFFGetField(m_tif, TIFFTAG_IMAGELENGTH, &height);
- TIFFGetField(m_tif, TIFFTAG_SAMPLESPERPIXEL, &samplesperpixel);
- TIFFGetField(m_tif, TIFFTAG_BITSPERSAMPLE, &bitspersample);
- TIFFGetField(m_tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
- TIFFGetField(m_tif, TIFFTAG_PHOTOMETRIC, &photometric);
- TIFFGetField(m_tif, TIFFTAG_ORIENTATION, &orientation);
-
- if (info.nEscape == -1) {
- // Return output dimensions only
- head.biWidth = width;
- head.biHeight = height;
- info.dwType = CXIMAGE_FORMAT_TIF;
- cx_throw("output dimensions returned");
- }
-
- TIFFGetFieldDefaulted(m_tif, TIFFTAG_RESOLUTIONUNIT, &res_unit);
- if (TIFFGetField(m_tif, TIFFTAG_XRESOLUTION, &resolution))
- {
- if (res_unit == RESUNIT_CENTIMETER) resolution = (float)(resolution*2.54f + 0.5f);
- SetXDPI((int32_t)resolution);
- }
- if (TIFFGetField(m_tif, TIFFTAG_YRESOLUTION, &resolution))
- {
- if (res_unit == RESUNIT_CENTIMETER) resolution = (float)(resolution*2.54f + 0.5f);
- SetYDPI((int32_t)resolution);
- }
-
- if (TIFFGetField(m_tif, TIFFTAG_XPOSITION, &offset)) info.xOffset = (int32_t)offset;
- if (TIFFGetField(m_tif, TIFFTAG_YPOSITION, &offset)) info.yOffset = (int32_t)offset;
-
- head.biClrUsed=0;
- info.nBkgndIndex =-1;
-
- if (rowsperstrip>height){
- rowsperstrip=height;
- TIFFSetField(m_tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
- }
-
- isRGB = /*(bitspersample >= 8) && (VK: it is possible so for RGB to have < 8 bpp!)*/
- (photometric == PHOTOMETRIC_RGB) ||
- (photometric == PHOTOMETRIC_YCBCR) ||
- (photometric == PHOTOMETRIC_SEPARATED) ||
- (photometric == PHOTOMETRIC_LOGL) ||
- (photometric == PHOTOMETRIC_LOGLUV);
-
- if (isRGB){
- head.biBitCount=24;
- }else{
- if ((photometric==PHOTOMETRIC_MINISBLACK)||(photometric==PHOTOMETRIC_MINISWHITE)||(photometric==PHOTOMETRIC_PALETTE)){
- if (bitspersample == 1){
- head.biBitCount=1; //B&W image
- head.biClrUsed =2;
- } else if (bitspersample == 4) {
- head.biBitCount=4; //16 colors gray scale
- head.biClrUsed =16;
- } else {
- head.biBitCount=8; //gray scale
- head.biClrUsed =256;
- }
- } else if (bitspersample == 4) {
- head.biBitCount=4; // 16 colors
- head.biClrUsed=16;
- } else {
- head.biBitCount=8; //256 colors
- head.biClrUsed=256;
- }
-
- if ((bitspersample > 8) && (photometric==PHOTOMETRIC_PALETTE)) // + VK + (BIG palette! => convert to RGB)
- { head.biBitCount=24;
- head.biClrUsed =0;
- }
- }
-
- if (info.nEscape) cx_throw("Cancelled"); // <vho> - cancel decoding
-
- Create(width,height,head.biBitCount,CXIMAGE_FORMAT_TIF); //image creation
- if (!pDib) cx_throw("CxImageTIF can't create image");
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (samplesperpixel==4) AlphaCreate(); //add alpha support for 32bpp tiffs
- if (samplesperpixel==2 && bitspersample==8) AlphaCreate(); //add alpha support for 8bpp + alpha
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- TIFFGetField(m_tif, TIFFTAG_COMPRESSION, &compression);
- SetCodecOption(compression); // <DPR> save original compression type
-
- if (isRGB) {
- // Read the whole image into one big RGBA buffer using
- // the traditional TIFFReadRGBAImage() API that we trust.
- uint32* raster; // retrieve RGBA image
- uint32 *row;
-
- raster = (uint32*)_TIFFmalloc(width * height * sizeof (uint32));
- if (raster == NULL) cx_throw("No space for raster buffer");
-
- // Read the image in one chunk into an RGBA array
- if(!TIFFReadRGBAImage(m_tif, width, height, raster, 1)) {
- _TIFFfree(raster);
- cx_throw("Corrupted TIFF file!");
- }
-
- // read the raster lines and save them in the DIB
- // with RGB mode, we have to change the order of the 3 samples RGB
- row = &raster[0];
- bits2 = info.pImage;
- for (y = 0; y < height; y++) {
-
- if (info.nEscape){ // <vho> - cancel decoding
- _TIFFfree(raster);
- cx_throw("Cancelled");
- }
-
- bits = bits2;
- for (x = 0; x < width; x++) {
- *bits++ = (uint8_t)TIFFGetB(row[x]);
- *bits++ = (uint8_t)TIFFGetG(row[x]);
- *bits++ = (uint8_t)TIFFGetR(row[x]);
-#if CXIMAGE_SUPPORT_ALPHA
- if (samplesperpixel==4) AlphaSet(x,y,(uint8_t)TIFFGetA(row[x]));
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- row += width;
- bits2 += info.dwEffWidth;
- }
- _TIFFfree(raster);
- } else {
- int32_t BIG_palette = (bitspersample > 8) && // + VK
- (photometric==PHOTOMETRIC_PALETTE);
- if (BIG_palette && (bitspersample > 24)) // + VK
- cx_throw("Too big palette to handle"); // + VK
-
- RGBQUAD *pal;
- pal=(RGBQUAD*)calloc(BIG_palette ? 1<<bitspersample : 256,sizeof(RGBQUAD));
- // ! VK: it coasts nothing but more correct to use 256 as temp palette storage
- // ! VK: but for case of BIG palette it just copied
- if (pal==NULL) cx_throw("Unable to allocate TIFF palette");
-
- int32_t bpp = bitspersample <= 8 ? bitspersample : 8; // + VK (to use instead of bitspersample for case of > 8)
-
- // set up the colormap based on photometric
- switch(photometric) {
- case PHOTOMETRIC_MINISBLACK: // bitmap and greyscale image types
- case PHOTOMETRIC_MINISWHITE:
- if (bitspersample == 1) { // Monochrome image
- if (photometric == PHOTOMETRIC_MINISBLACK) {
- pal[1].rgbRed = pal[1].rgbGreen = pal[1].rgbBlue = 255;
- } else {
- pal[0].rgbRed = pal[0].rgbGreen = pal[0].rgbBlue = 255;
- }
- } else { // need to build the scale for greyscale images
- if (photometric == PHOTOMETRIC_MINISBLACK) {
- for (int32_t i=0; i<(1<<bpp); i++){
- pal[i].rgbRed = pal[i].rgbGreen = pal[i].rgbBlue = (uint8_t)(i*(255/((1<<bpp)-1)));
- }
- } else {
- for (int32_t i=0; i<(1<<bpp); i++){
- pal[i].rgbRed = pal[i].rgbGreen = pal[i].rgbBlue = (uint8_t)(255-i*(255/((1<<bpp)-1)));
- }
- }
- }
- break;
- case PHOTOMETRIC_PALETTE: // color map indexed
- uint16 *red;
- uint16 *green;
- uint16 *blue;
- TIFFGetField(m_tif, TIFFTAG_COLORMAP, &red, &green, &blue);
-
- // Is the palette 16 or 8 bits ?
- BOOL Palette16Bits = /*FALSE*/ BIG_palette;
- if (!BIG_palette) {
- int32_t n= 1<<bpp;
- while (n-- > 0) {
- if (red[n] >= 256 || green[n] >= 256 || blue[n] >= 256) {
- Palette16Bits=TRUE;
- break;
- }
- }
- }
-
- // load the palette in the DIB
- for (int32_t i = (1 << ( BIG_palette ? bitspersample : bpp )) - 1; i >= 0; i--) {
- if (Palette16Bits) {
- pal[i].rgbRed =(uint8_t) CVT(red[i]);
- pal[i].rgbGreen = (uint8_t) CVT(green[i]);
- pal[i].rgbBlue = (uint8_t) CVT(blue[i]);
- } else {
- pal[i].rgbRed = (uint8_t) red[i];
- pal[i].rgbGreen = (uint8_t) green[i];
- pal[i].rgbBlue = (uint8_t) blue[i];
- }
- }
- break;
- }
- if (!BIG_palette) { // + VK (BIG palette is stored until image is ready)
- SetPalette(pal,/*head.biClrUsed*/ 1<<bpp); //palette assign // * VK
- free(pal);
- pal = NULL;
- }
-
- // read the tiff lines and save them in the DIB
- uint32 nrow;
- uint32 ys;
- int32_t line = CalculateLine(width, bitspersample * samplesperpixel);
-
- int32_t bitsize = TIFFStripSize(m_tif);
- //verify bitsize: could be wrong if StripByteCounts is missing.
- if (bitsize>(int32_t)(head.biSizeImage*samplesperpixel))
- bitsize = head.biSizeImage*samplesperpixel;
- if (bitsize<(int32_t)(info.dwEffWidth*rowsperstrip))
- bitsize = info.dwEffWidth*rowsperstrip;
-
- if ((bitspersample > 8) && (bitspersample != 16)) // + VK (for bitspersample == 9..15,17..32..64
- bitsize *= (bitspersample + 7)/8;
-
- int32_t tiled_image = TIFFIsTiled(m_tif);
- uint32 tw=0, tl=0;
- uint8_t* tilebuf=NULL;
- if (tiled_image){
- TIFFGetField(m_tif, TIFFTAG_TILEWIDTH, &tw);
- TIFFGetField(m_tif, TIFFTAG_TILELENGTH, &tl);
- rowsperstrip = tl;
- bitsize = TIFFTileSize(m_tif) * (int32_t)(1+width/tw);
- tilebuf = (uint8_t*)malloc(TIFFTileSize(m_tif));
- }
-
- bits = (uint8_t*)malloc(bitspersample==16? bitsize*2 : bitsize); // * VK
- uint8_t * bits16 = NULL; // + VK
- int32_t line16 = 0; // + VK
-
- if (!tiled_image && bitspersample==16) { // + VK +
- line16 = line;
- line = CalculateLine(width, 8 * samplesperpixel);
- bits16 = bits;
- bits = (uint8_t*)malloc(bitsize);
- }
-
- if (bits==NULL){
- if (bits16) free(bits16); // + VK
- if (pal) free(pal); // + VK
- if (tilebuf)free(tilebuf); // + VK
- cx_throw("CxImageTIF can't allocate memory");
- }
-
-#ifdef FIX_16BPP_DARKIMG // + VK: for each line, store shift count bits used to fix it
- uint8_t* row_shifts = NULL;
- if (bits16) row_shifts = (uint8_t*)malloc(height);
-#endif
-
- for (ys = 0; ys < height; ys += rowsperstrip) {
-
- if (info.nEscape){ // <vho> - cancel decoding
- free(bits);
- cx_throw("Cancelled");
- }
-
- nrow = (ys + rowsperstrip > height ? height - ys : rowsperstrip);
-
- if (tiled_image){
- uint32 imagew = TIFFScanlineSize(m_tif);
- uint32 tilew = TIFFTileRowSize(m_tif);
- int32_t iskew = imagew - tilew;
- uint8* bufp = (uint8*) bits;
-
- uint32 colb = 0;
- for (uint32 col = 0; col < width; col += tw) {
- if (TIFFReadTile(m_tif, tilebuf, col, ys, 0, 0) < 0){
- free(tilebuf);
- free(bits);
- cx_throw("Corrupted tiled TIFF file!");
- }
-
- if (colb + tw > imagew) {
- uint32 owidth = imagew - colb;
- uint32 oskew = tilew - owidth;
- TileToStrip(bufp + colb, tilebuf, nrow, owidth, oskew + iskew, oskew );
- } else {
- TileToStrip(bufp + colb, tilebuf, nrow, tilew, iskew, 0);
- }
- colb += tilew;
- }
-
- } else {
- if (TIFFReadEncodedStrip(m_tif, TIFFComputeStrip(m_tif, ys, 0),
- (bits16? bits16 : bits), nrow * (bits16 ? line16 : line)) == -1) { // * VK
-
-#ifdef NOT_IGNORE_CORRUPTED
- free(bits);
- if (bits16) free(bits16); // + VK
- cx_throw("Corrupted TIFF file!");
-#else
- break;
-#endif
- }
- }
-
- for (y = 0; y < nrow; y++) {
- int32_t offset=(nrow-y-1)*line;
- if ((bitspersample==16) && !BIG_palette) { // * VK
- int32_t offset16 = (nrow-y-1)*line16; // + VK
- if (bits16) { // + VK +
-#ifdef FIX_16BPP_DARKIMG
- int32_t the_shift;
- uint8_t hi_byte, hi_max=0;
- uint32_t xi;
- for (xi=0;xi<(uint32)line;xi++) {
- hi_byte = bits16[xi*2+offset16+1];
- if(hi_byte>hi_max)
- hi_max = hi_byte;
- }
- the_shift = (hi_max == 0) ? 8 : 0;
- if (!the_shift)
- while( ! (hi_max & 0x80) ) {
- the_shift++;
- hi_max <<= 1;
- }
- row_shifts[height-ys-nrow+y] = the_shift;
- the_shift = 8 - the_shift;
- for (xi=0;xi<(uint32)line;xi++)
- bits[xi+offset]= ((bits16[xi*2+offset16+1]<<8) | bits16[xi*2+offset16]) >> the_shift;
-#else
- for (uint32_t xi=0;xi<(uint32)line;xi++)
- bits[xi+offset]=bits16[xi*2+offset16+1];
-#endif
- } else {
- for (uint32_t xi=0;xi<width;xi++)
- bits[xi+offset]=bits[xi*2+offset+1];
- }
- }
- if (samplesperpixel==1) {
- if (BIG_palette)
- if (bits16) {
- int32_t offset16 = (nrow-y-1)*line16; // + VK
- MoveBitsPal( info.pImage + info.dwEffWidth * (height-ys-nrow+y),
- bits16 + offset16, width, bitspersample, pal );
- } else
- MoveBitsPal( info.pImage + info.dwEffWidth * (height-ys-nrow+y),
- bits + offset, width, bitspersample, pal );
- else if ((bitspersample == head.biBitCount) ||
- (bitspersample == 16)) //simple 8bpp, 4bpp image or 16bpp
- memcpy(info.pImage+info.dwEffWidth*(height-ys-nrow+y),bits+offset,min((unsigned)line, info.dwEffWidth));
- else
- MoveBits( info.pImage + info.dwEffWidth * (height-ys-nrow+y),
- bits + offset, width, bitspersample );
- } else if (samplesperpixel==2) { //8bpp image with alpha layer
- int32_t xi=0;
- int32_t ii=0;
- int32_t yi=height-ys-nrow+y;
-#if CXIMAGE_SUPPORT_ALPHA
- if (!pAlpha) AlphaCreate(); // + VK
-#endif //CXIMAGE_SUPPORT_ALPHA
- while (ii<line){
- SetPixelIndex(xi,yi,bits[ii+offset]);
-#if CXIMAGE_SUPPORT_ALPHA
- AlphaSet(xi,yi,bits[ii+offset+1]);
-#endif //CXIMAGE_SUPPORT_ALPHA
- ii+=2;
- xi++;
- if (xi>=(int32_t)width){
- yi--;
- xi=0;
- }
- }
- } else { //photometric==PHOTOMETRIC_CIELAB
- if (head.biBitCount!=24){ //fix image
- Create(width,height,24,CXIMAGE_FORMAT_TIF);
-#if CXIMAGE_SUPPORT_ALPHA
- if (samplesperpixel==4) AlphaCreate();
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
-
- int32_t xi=0;
- uint32 ii=0;
- int32_t yi=height-ys-nrow+y;
- RGBQUAD c;
- int32_t l,a,b,bitsoffset;
- double p,cx,cy,cz,cr,cg,cb;
- while (ii</*line*/width){ // * VK
- bitsoffset = ii*samplesperpixel+offset;
- l=bits[bitsoffset];
- a=bits[bitsoffset+1];
- b=bits[bitsoffset+2];
- if (a>127) a-=256;
- if (b>127) b-=256;
- // lab to xyz
- p = (l/2.55 + 16) / 116.0;
- cx = pow( p + a * 0.002, 3);
- cy = pow( p, 3);
- cz = pow( p - b * 0.005, 3);
- // white point
- cx*=0.95047;
- //cy*=1.000;
- cz*=1.0883;
- // xyz to rgb
- cr = 3.240479 * cx - 1.537150 * cy - 0.498535 * cz;
- cg = -0.969256 * cx + 1.875992 * cy + 0.041556 * cz;
- cb = 0.055648 * cx - 0.204043 * cy + 1.057311 * cz;
-
- if ( cr > 0.00304 ) cr = 1.055 * pow(cr,0.41667) - 0.055;
- else cr = 12.92 * cr;
- if ( cg > 0.00304 ) cg = 1.055 * pow(cg,0.41667) - 0.055;
- else cg = 12.92 * cg;
- if ( cb > 0.00304 ) cb = 1.055 * pow(cb,0.41667) - 0.055;
- else cb = 12.92 * cb;
-
- c.rgbRed =(uint8_t)max(0,min(255,(int32_t)(cr*255)));
- c.rgbGreen=(uint8_t)max(0,min(255,(int32_t)(cg*255)));
- c.rgbBlue =(uint8_t)max(0,min(255,(int32_t)(cb*255)));
-
- SetPixelColor(xi,yi,c);
-#if CXIMAGE_SUPPORT_ALPHA
- if (samplesperpixel==4) AlphaSet(xi,yi,bits[bitsoffset+3]);
-#endif //CXIMAGE_SUPPORT_ALPHA
- ii++;
- xi++;
- if (xi>=(int32_t)width){
- yi--;
- xi=0;
- }
- }
- }
- }
- }
- free(bits);
- if (bits16) free(bits16);
-
-#ifdef FIX_16BPP_DARKIMG
- if (row_shifts && (samplesperpixel == 1) && (bitspersample==16) && !BIG_palette) {
- // 1. calculate maximum necessary shift
- int32_t min_row_shift = 8;
- for( y=0; y<height; y++ ) {
- if (min_row_shift > row_shifts[y]) min_row_shift = row_shifts[y];
- }
- // 2. for rows having less shift value, correct such rows:
- for( y=0; y<height; y++ ) {
- if (min_row_shift < row_shifts[y]) {
- int32_t need_shift = row_shifts[y] - min_row_shift;
- uint8_t* data = info.pImage + info.dwEffWidth * y;
- for( x=0; x<width; x++, data++ )
- *data >>= need_shift;
- }
- }
- }
- if (row_shifts) free( row_shifts );
-#endif
-
- if (tiled_image) free(tilebuf);
- if (pal) free(pal);
-
- switch(orientation){
- case ORIENTATION_TOPRIGHT: /* row 0 top, col 0 rhs */
- Mirror();
- break;
- case ORIENTATION_BOTRIGHT: /* row 0 bottom, col 0 rhs */
- Flip();
- Mirror();
- break;
- case ORIENTATION_BOTLEFT: /* row 0 bottom, col 0 lhs */
- Flip();
- break;
- case ORIENTATION_LEFTTOP: /* row 0 lhs, col 0 top */
- RotateRight();
- Mirror();
- break;
- case ORIENTATION_RIGHTTOP: /* row 0 rhs, col 0 top */
- RotateLeft();
- break;
- case ORIENTATION_RIGHTBOT: /* row 0 rhs, col 0 bottom */
- RotateLeft();
- Mirror();
- break;
- case ORIENTATION_LEFTBOT: /* row 0 lhs, col 0 bottom */
- RotateRight();
- break;
- }
-
- }
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- if (m_tif) TIFFClose(m_tif);
- if (info.nEscape == -1 && info.dwType == CXIMAGE_FORMAT_TIF) return true;
- return false;
- }
- TIFFClose(m_tif);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageTIF::Encode(CxFile * hFile, bool bAppend)
-{
- cx_try
- {
- if (hFile==NULL) cx_throw(CXIMAGE_ERR_NOFILE);
- if (pDib==NULL) cx_throw(CXIMAGE_ERR_NOIMAGE);
-
- // <RJ> replaced "w+b" with "a", to append an image directly on an existing file
- if (m_tif2==NULL) m_tif2=_TIFFOpenEx(hFile, "a");
- if (m_tif2==NULL) cx_throw("initialization fail");
-
- if (bAppend || m_pages) m_multipage=true;
- m_pages++;
-
- if (!EncodeBody(m_tif2,m_multipage,m_pages,m_pages)) cx_throw("Error saving TIFF file");
- if (bAppend) {
- if (!TIFFWriteDirectory(m_tif2)) cx_throw("Error saving TIFF directory");
- }
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- if (m_tif2){
- TIFFClose(m_tif2);
- m_tif2=NULL;
- m_multipage=false;
- m_pages=0;
- }
- return false;
- }
- if (!bAppend){
- TIFFClose(m_tif2);
- m_tif2=NULL;
- m_multipage=false;
- m_pages=0;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-// Thanks to Abe <God(dot)bless(at)marihuana(dot)com>
-bool CxImageTIF::Encode(CxFile * hFile, CxImage ** pImages, int32_t pagecount)
-{
- cx_try
- {
- if (hFile==NULL) cx_throw("invalid file pointer");
- if (pImages==NULL || pagecount<=0) cx_throw("multipage TIFF, no images!");
-
- int32_t i;
- for (i=0; i<pagecount; i++){
- if (pImages[i]==NULL)
- cx_throw("Bad image pointer");
- if (!(pImages[i]->IsValid()))
- cx_throw("Empty image");
- }
-
- CxImageTIF ghost;
- for (i=0; i<pagecount; i++){
- ghost.Ghost(pImages[i]);
- if (!ghost.Encode(hFile,true)) cx_throw("Error saving TIFF file");
- }
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- return false;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageTIF::EncodeBody(TIFF *m_tif, bool multipage, int32_t page, int32_t pagecount)
-{
- uint32 height=head.biHeight;
- uint32 width=head.biWidth;
- uint16 bitcount=head.biBitCount;
- uint16 bitspersample;
- uint16 samplesperpixel;
- uint16 photometric=0;
- uint16 compression;
-// uint16 pitch;
-// int32_t line;
- uint32 x, y;
-
- samplesperpixel = ((bitcount == 24) || (bitcount == 32)) ? (uint8_t)3 : (uint8_t)1;
-#if CXIMAGE_SUPPORT_ALPHA
- if (bitcount==24 && AlphaIsValid()) { bitcount=32; samplesperpixel=4; }
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- bitspersample = bitcount / samplesperpixel;
-
- //set the PHOTOMETRIC tag
- RGBQUAD *rgb = GetPalette();
- switch (bitcount) {
- case 1:
- if (CompareColors(&rgb[0],&rgb[1])<0) {
- /* <abe> some viewers do not handle PHOTOMETRIC_MINISBLACK:
- * let's transform the image in PHOTOMETRIC_MINISWHITE
- */
- //invert the colors
- RGBQUAD tempRGB=GetPaletteColor(0);
- SetPaletteColor(0,GetPaletteColor(1));
- SetPaletteColor(1,tempRGB);
- //invert the pixels
- uint8_t *iSrc=info.pImage;
- for (uint32_t i=0;i<head.biSizeImage;i++){
- *iSrc=(uint8_t)~(*(iSrc));
- iSrc++;
- }
- photometric = PHOTOMETRIC_MINISWHITE;
- //photometric = PHOTOMETRIC_MINISBLACK;
- } else {
- photometric = PHOTOMETRIC_MINISWHITE;
- }
- break;
- case 4: // Check if the DIB has a color or a greyscale palette
- case 8:
- photometric = PHOTOMETRIC_MINISBLACK; //default to gray scale
- for (x = 0; x < head.biClrUsed; x++) {
- if ((rgb->rgbRed != x)||(rgb->rgbRed != rgb->rgbGreen)||(rgb->rgbRed != rgb->rgbBlue)){
- photometric = PHOTOMETRIC_PALETTE;
- break;
- }
- rgb++;
- }
- break;
- case 24:
- case 32:
- photometric = PHOTOMETRIC_RGB;
- break;
- }
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid() && bitcount==8) samplesperpixel=2; //8bpp + alpha layer
-#endif //CXIMAGE_SUPPORT_ALPHA
-
-// line = CalculateLine(width, bitspersample * samplesperpixel);
-// pitch = (uint16)CalculatePitch(line);
-
- //prepare the palette struct
- RGBQUAD pal[256];
- if (GetPalette()){
- uint8_t b;
- memcpy(pal,GetPalette(),GetPaletteSize());
- for(uint16_t a=0;a<head.biClrUsed;a++){ //swap blue and red components
- b=pal[a].rgbBlue; pal[a].rgbBlue=pal[a].rgbRed; pal[a].rgbRed=b;
- }
- }
-
- // handle standard width/height/bpp stuff
- TIFFSetField(m_tif, TIFFTAG_IMAGEWIDTH, width);
- TIFFSetField(m_tif, TIFFTAG_IMAGELENGTH, height);
- TIFFSetField(m_tif, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
- TIFFSetField(m_tif, TIFFTAG_BITSPERSAMPLE, bitspersample);
- TIFFSetField(m_tif, TIFFTAG_PHOTOMETRIC, photometric);
- TIFFSetField(m_tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); // single image plane
- TIFFSetField(m_tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
-
- uint32 rowsperstrip = TIFFDefaultStripSize(m_tif, (uint32) -1); //<REC> gives better compression
- TIFFSetField(m_tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
-
- // handle metrics
- TIFFSetField(m_tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
- TIFFSetField(m_tif, TIFFTAG_XRESOLUTION, (float)info.xDPI);
- TIFFSetField(m_tif, TIFFTAG_YRESOLUTION, (float)info.yDPI);
-// TIFFSetField(m_tif, TIFFTAG_XPOSITION, (float)info.xOffset);
-// TIFFSetField(m_tif, TIFFTAG_YPOSITION, (float)info.yOffset);
-
- // multi-paging - Thanks to Abe <God(dot)bless(at)marihuana(dot)com>
- if (multipage)
- {
- char page_number[20];
- sprintf(page_number, "Page %d", page);
-
- TIFFSetField(m_tif, TIFFTAG_SUBFILETYPE, FILETYPE_PAGE);
- TIFFSetField(m_tif, TIFFTAG_PAGENUMBER, page,pagecount);
- TIFFSetField(m_tif, TIFFTAG_PAGENAME, page_number);
- } else {
- TIFFSetField(m_tif, TIFFTAG_SUBFILETYPE, 0);
- }
-
- // palettes (image colormaps are automatically scaled to 16-bits)
- if (photometric == PHOTOMETRIC_PALETTE) {
- uint16 *r, *g, *b;
- r = (uint16 *) _TIFFmalloc(sizeof(uint16) * 3 * 256);
- g = r + 256;
- b = g + 256;
-
- for (int32_t i = 255; i >= 0; i--) {
- b[i] = (uint16)SCALE((uint16)pal[i].rgbRed);
- g[i] = (uint16)SCALE((uint16)pal[i].rgbGreen);
- r[i] = (uint16)SCALE((uint16)pal[i].rgbBlue);
- }
-
- TIFFSetField(m_tif, TIFFTAG_COLORMAP, r, g, b);
- _TIFFfree(r);
- }
-
- // compression
- if (GetCodecOption(CXIMAGE_FORMAT_TIF)) {
- compression = (uint16_t)GetCodecOption(CXIMAGE_FORMAT_TIF);
- } else {
- switch (bitcount) {
- case 1 :
- compression = COMPRESSION_CCITTFAX4;
- break;
- case 4 :
- case 8 :
- compression = COMPRESSION_LZW;
- break;
- case 24 :
- case 32 :
- compression = COMPRESSION_JPEG;
- break;
- default :
- compression = COMPRESSION_NONE;
- break;
- }
- }
- TIFFSetField(m_tif, TIFFTAG_COMPRESSION, compression);
-
- switch (compression) {
- case COMPRESSION_JPEG:
- TIFFSetField(m_tif, TIFFTAG_JPEGQUALITY, GetJpegQuality());
- TIFFSetField(m_tif, TIFFTAG_ROWSPERSTRIP, ((7+rowsperstrip)>>3)<<3);
- break;
- case COMPRESSION_LZW:
- if (bitcount>=8) TIFFSetField(m_tif, TIFFTAG_PREDICTOR, 2);
- break;
- }
-
- // read the DIB lines from bottom to top and save them in the TIF
-
- uint8_t *bits;
- switch(bitcount) {
- case 1 :
- case 4 :
- case 8 :
- {
- if (samplesperpixel==1){
- bits = (uint8_t*)malloc(info.dwEffWidth);
- if (!bits) return false;
- for (y = 0; y < height; y++) {
- memcpy(bits,info.pImage + (height - y - 1)*info.dwEffWidth,info.dwEffWidth);
- if (TIFFWriteScanline(m_tif,bits, y, 0)==-1){
- free(bits);
- return false;
- }
- }
- free(bits);
- }
-#if CXIMAGE_SUPPORT_ALPHA
- else { //8bpp + alpha layer
- bits = (uint8_t*)malloc(2*width);
- if (!bits) return false;
- for (y = 0; y < height; y++) {
- for (x=0;x<width;x++){
- bits[2*x]=BlindGetPixelIndex(x,height - y - 1);
- bits[2*x+1]=AlphaGet(x,height - y - 1);
- }
- if (TIFFWriteScanline(m_tif,bits, y, 0)==-1) {
- free(bits);
- return false;
- }
- }
- free(bits);
- }
-#endif //CXIMAGE_SUPPORT_ALPHA
- break;
- }
- case 24:
- {
- uint8_t *buffer = (uint8_t *)malloc(info.dwEffWidth);
- if (!buffer) return false;
- for (y = 0; y < height; y++) {
- // get a pointer to the scanline
- memcpy(buffer, info.pImage + (height - y - 1)*info.dwEffWidth, info.dwEffWidth);
- // TIFFs store color data RGB instead of BGR
- uint8_t *pBuf = buffer;
- for (x = 0; x < width; x++) {
- uint8_t tmp = pBuf[0];
- pBuf[0] = pBuf[2];
- pBuf[2] = tmp;
- pBuf += 3;
- }
- // write the scanline to disc
- if (TIFFWriteScanline(m_tif, buffer, y, 0)==-1){
- free(buffer);
- return false;
- }
- }
- free(buffer);
- break;
- }
- case 32 :
- {
-#if CXIMAGE_SUPPORT_ALPHA
- uint8_t *buffer = (uint8_t *)malloc((info.dwEffWidth*4)/3);
- if (!buffer) return false;
- for (y = 0; y < height; y++) {
- // get a pointer to the scanline
- memcpy(buffer, info.pImage + (height - y - 1)*info.dwEffWidth, info.dwEffWidth);
- // TIFFs store color data RGB instead of BGR
- uint8_t *pSrc = buffer + 3 * width;
- uint8_t *pDst = buffer + 4 * width;
- for (x = 0; x < width; x++) {
- pDst-=4;
- pSrc-=3;
- pDst[3] = AlphaGet(width-x-1,height-y-1);
- pDst[2] = pSrc[0];
- pDst[1] = pSrc[1];
- pDst[0] = pSrc[2];
- }
- // write the scanline to disc
- if (TIFFWriteScanline(m_tif, buffer, y, 0)==-1){
- free(buffer);
- return false;
- }
- }
- free(buffer);
-#endif //CXIMAGE_SUPPORT_ALPHA
- break;
- }
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-void CxImageTIF::TileToStrip(uint8* out, uint8* in, uint32 rows, uint32 cols, int32_t outskew, int32_t inskew)
-{
- while (rows-- > 0) {
- uint32 j = cols;
- while (j-- > 0)
- *out++ = *in++;
- out += outskew;
- in += inskew;
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-TIFF* CxImageTIF::TIFFOpenEx(CxFile * hFile)
-{
- if (hFile) return _TIFFOpenEx(hFile, "rb");
- return NULL;
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageTIF::TIFFCloseEx(TIFF* tif)
-{
- if (tif) TIFFClose(tif);
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageTIF::MoveBits( uint8_t* dest, uint8_t* from, int32_t count, int32_t bpp )
-{ int32_t offbits = 0;
- uint16 w;
- uint32 d;
- if (bpp <= 8) {
- while (count-- > 0) {
- if (offbits + bpp <= 8)
- w = *from >> (8 - offbits - bpp);
- else {
- w = *from++ << (offbits + bpp - 8);
- w |= *from >> (16 - offbits - bpp);
- }
- offbits += bpp;
- if (offbits >= 8) {
- offbits -= 8;
- if (offbits == 0) from++;
- }
- *dest++ = (uint8_t)w & ((1 << bpp)-1);
- }
- } else if (bpp < 16) {
- while (count-- > 0) {
- d = (*from << 24) | (from[1]<<16) | (from[2]<<8) | from[3];
- d >>= (24 - offbits);
- *dest++ = (uint8_t) ( d );
- offbits += bpp;
- while (offbits >= 8) {
- from++;
- offbits -= 8;
- }
- }
- } else if (bpp < 32) {
- while (count-- > 0) {
- d = (*from << 24) | (from[1]<<16) | (from[2]<<8) | from[3];
- //d = *(uint32*)from;
- *dest++ = (uint8_t) ( d >> (offbits + bpp - 8) );
- offbits += bpp;
- while (offbits >= 8) {
- from++;
- offbits -= 8;
- }
- }
- } else {
- while (count-- > 0) {
- d = *(uint32*)from;
- *dest++ = (uint8_t) (d >> 24);
- from += 4;
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-void CxImageTIF::MoveBitsPal( uint8_t* dest, uint8_t*from, int32_t count, int32_t bpp, RGBQUAD* pal )
-{ int32_t offbits = 0;
- uint32 d;
- uint16 palidx;
- while (count-- > 0) {
- d = (*from << 24) | ( *( from + 1 ) << 16 )
- | ( *( from + 2 ) << 8 )
- | ( *( from + 3 ) );
- palidx = (uint16) (d >> (32 - offbits - bpp));
- if (bpp < 16) {
- palidx <<= 16-bpp;
- palidx = (palidx >> 8) | (palidx <<8);
- palidx >>= 16-bpp;
- } else palidx = (palidx >> 8) | (palidx << 8);
- *dest++ = pal[palidx].rgbBlue;
- *dest++ = pal[palidx].rgbGreen;
- *dest++ = pal[palidx].rgbRed;
- offbits += bpp;
- while (offbits >= 8) {
- from++;
- offbits -= 8;
- }
- }
-}
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // CXIMAGE_SUPPORT_TIF
diff --git a/smelt/sdl/CxImage/ximatif.h b/smelt/sdl/CxImage/ximatif.h deleted file mode 100644 index 5ea31f0..0000000 --- a/smelt/sdl/CxImage/ximatif.h +++ /dev/null @@ -1,62 +0,0 @@ -/*
- * File: ximatif.h
- * Purpose: TIFF Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImageTIF (c) 07/Aug/2001 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- *
- * Special thanks to Troels Knakkergaard for new features, enhancements and bugfixes
- *
- * Special thanks to Abe <God(dot)bless(at)marihuana(dot)com> for MultiPageTIFF code.
- *
- * LibTIFF is:
- * Copyright (c) 1988-1997 Sam Leffler
- * Copyright (c) 1991-1997 Silicon Graphics, Inc.
- * ==========================================================
- */
-
-#if !defined(__ximatif_h)
-#define __ximatif_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_TIF
-
-#include "../tiff/tiffio.h"
-
-class DLL_EXP CxImageTIF: public CxImage
-{
-public:
- CxImageTIF(): CxImage(CXIMAGE_FORMAT_TIF) {m_tif2=NULL; m_multipage=false; m_pages=0;}
- ~CxImageTIF();
-
- TIFF* TIFFOpenEx(CxFile * hFile);
- void TIFFCloseEx(TIFF* tif);
-
-// bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_TIF);}
-// bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_TIF);}
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile, bool bAppend=false);
- bool Encode(CxFile * hFile, CxImage ** pImages, int32_t pagecount);
- bool Encode(FILE *hFile, bool bAppend=false) { CxIOFile file(hFile); return Encode(&file,bAppend); }
- bool Encode(FILE *hFile, CxImage ** pImages, int32_t pagecount)
- { CxIOFile file(hFile); return Encode(&file, pImages, pagecount); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-
-protected:
- void TileToStrip(uint8* out, uint8* in, uint32 rows, uint32 cols, int32_t outskew, int32_t inskew);
- bool EncodeBody(TIFF *m_tif, bool multipage=false, int32_t page=0, int32_t pagecount=0);
- TIFF *m_tif2;
- bool m_multipage;
- int32_t m_pages;
- void MoveBits( uint8_t* dest, uint8_t* from, int32_t count, int32_t bpp );
- void MoveBitsPal( uint8_t* dest, uint8_t*from, int32_t count, int32_t bpp, RGBQUAD* pal );
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximatran.cpp b/smelt/sdl/CxImage/ximatran.cpp deleted file mode 100644 index decac18..0000000 --- a/smelt/sdl/CxImage/ximatran.cpp +++ /dev/null @@ -1,2728 +0,0 @@ -// xImaTran.cpp : Transformation functions
-/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximage.h"
-#include "ximath.h"
-
-#if CXIMAGE_SUPPORT_BASICTRANSFORMATIONS
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Increases the number of bits per pixel of the image.
- * \param nbit: 4, 8, 24
- */
-bool CxImage::IncreaseBpp(uint32_t nbit)
-{
- if (!pDib) return false;
- switch (nbit){
- case 4:
- {
- if (head.biBitCount==4) return true;
- if (head.biBitCount>4) return false;
-
- CxImage tmp;
- tmp.CopyInfo(*this);
- tmp.Create(head.biWidth,head.biHeight,4,info.dwType);
- tmp.SetPalette(GetPalette(),GetNumColors());
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
-
-#if CXIMAGE_SUPPORT_SELECTION
- tmp.SelectionCopy(*this);
-#endif //CXIMAGE_SUPPORT_SELECTION
-
-#if CXIMAGE_SUPPORT_ALPHA
- tmp.AlphaCopy(*this);
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- for (int32_t y=0;y<head.biHeight;y++){
- if (info.nEscape) break;
- for (int32_t x=0;x<head.biWidth;x++){
- tmp.BlindSetPixelIndex(x,y,BlindGetPixelIndex(x,y));
- }
- }
- Transfer(tmp);
- return true;
- }
- case 8:
- {
- if (head.biBitCount==8) return true;
- if (head.biBitCount>8) return false;
-
- CxImage tmp;
- tmp.CopyInfo(*this);
- tmp.Create(head.biWidth,head.biHeight,8,info.dwType);
- tmp.SetPalette(GetPalette(),GetNumColors());
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
-#if CXIMAGE_SUPPORT_SELECTION
- tmp.SelectionCopy(*this);
-#endif //CXIMAGE_SUPPORT_SELECTION
-
-#if CXIMAGE_SUPPORT_ALPHA
- tmp.AlphaCopy(*this);
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- for (int32_t y=0;y<head.biHeight;y++){
- if (info.nEscape) break;
- for (int32_t x=0;x<head.biWidth;x++){
- tmp.BlindSetPixelIndex(x,y,BlindGetPixelIndex(x,y));
- }
- }
- Transfer(tmp);
- return true;
- }
- case 24:
- {
- if (head.biBitCount==24) return true;
- if (head.biBitCount>24) return false;
-
- CxImage tmp;
- tmp.CopyInfo(*this);
- tmp.Create(head.biWidth,head.biHeight,24,info.dwType);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- if (info.nBkgndIndex>=0) //translate transparency
- tmp.info.nBkgndColor=GetPaletteColor((uint8_t)info.nBkgndIndex);
-
-#if CXIMAGE_SUPPORT_SELECTION
- tmp.SelectionCopy(*this);
-#endif //CXIMAGE_SUPPORT_SELECTION
-
-#if CXIMAGE_SUPPORT_ALPHA
- tmp.AlphaCopy(*this);
- if (AlphaPaletteIsValid() && !AlphaIsValid()) tmp.AlphaCreate();
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- for (int32_t y=0;y<head.biHeight;y++){
- if (info.nEscape) break;
- for (int32_t x=0;x<head.biWidth;x++){
- tmp.BlindSetPixelColor(x,y,BlindGetPixelColor(x,y),true);
- }
- }
- Transfer(tmp);
- return true;
- }
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::GrayScale()
-{
- if (!pDib) return false;
- if (head.biBitCount<=8){
- RGBQUAD* ppal=GetPalette();
- int32_t gray;
- //converts the colors to gray, use the blue channel only
- for(uint32_t i=0;i<head.biClrUsed;i++){
- gray=(int32_t)RGB2GRAY(ppal[i].rgbRed,ppal[i].rgbGreen,ppal[i].rgbBlue);
- ppal[i].rgbBlue = (uint8_t)gray;
- }
- // preserve transparency
- if (info.nBkgndIndex >= 0) info.nBkgndIndex = ppal[info.nBkgndIndex].rgbBlue;
- //create a "real" 8 bit gray scale image
- if (head.biBitCount==8){
- uint8_t *img=info.pImage;
- for(uint32_t i=0;i<head.biSizeImage;i++) img[i]=ppal[img[i]].rgbBlue;
- SetGrayPalette();
- }
- //transform to 8 bit gray scale
- if (head.biBitCount==4 || head.biBitCount==1){
- CxImage ima;
- ima.CopyInfo(*this);
- if (!ima.Create(head.biWidth,head.biHeight,8,info.dwType)) return false;
- ima.SetGrayPalette();
-#if CXIMAGE_SUPPORT_SELECTION
- ima.SelectionCopy(*this);
-#endif //CXIMAGE_SUPPORT_SELECTION
-#if CXIMAGE_SUPPORT_ALPHA
- ima.AlphaCopy(*this);
-#endif //CXIMAGE_SUPPORT_ALPHA
- for (int32_t y=0;y<head.biHeight;y++){
- uint8_t *iDst = ima.GetBits(y);
- uint8_t *iSrc = GetBits(y);
- for (int32_t x=0;x<head.biWidth; x++){
- //iDst[x]=ppal[BlindGetPixelIndex(x,y)].rgbBlue;
- if (head.biBitCount==4){
- uint8_t pos = (uint8_t)(4*(1-x%2));
- iDst[x]= ppal[(uint8_t)((iSrc[x >> 1]&((uint8_t)0x0F<<pos)) >> pos)].rgbBlue;
- } else {
- uint8_t pos = (uint8_t)(7-x%8);
- iDst[x]= ppal[(uint8_t)((iSrc[x >> 3]&((uint8_t)0x01<<pos)) >> pos)].rgbBlue;
- }
- }
- }
- Transfer(ima);
- }
- } else { //from RGB to 8 bit gray scale
- uint8_t *iSrc=info.pImage;
- CxImage ima;
- ima.CopyInfo(*this);
- if (!ima.Create(head.biWidth,head.biHeight,8,info.dwType)) return false;
- ima.SetGrayPalette();
- if (GetTransIndex()>=0){
- RGBQUAD c = GetTransColor();
- ima.SetTransIndex((uint8_t)RGB2GRAY(c.rgbRed,c.rgbGreen,c.rgbBlue));
- }
-#if CXIMAGE_SUPPORT_SELECTION
- ima.SelectionCopy(*this);
-#endif //CXIMAGE_SUPPORT_SELECTION
-#if CXIMAGE_SUPPORT_ALPHA
- ima.AlphaCopy(*this);
-#endif //CXIMAGE_SUPPORT_ALPHA
- uint8_t *img=ima.GetBits();
- int32_t l8=ima.GetEffWidth();
- int32_t l=head.biWidth * 3;
- for(int32_t y=0; y < head.biHeight; y++) {
- for(int32_t x=0,x8=0; x < l; x+=3,x8++) {
- img[x8+y*l8]=(uint8_t)RGB2GRAY(*(iSrc+x+2),*(iSrc+x+1),*(iSrc+x+0));
- }
- iSrc+=info.dwEffWidth;
- }
- Transfer(ima);
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \sa Mirror
- * \author [qhbo]
- */
-bool CxImage::Flip(bool bFlipSelection, bool bFlipAlpha)
-{
- if (!pDib) return false;
-
- uint8_t *buff = (uint8_t*)malloc(info.dwEffWidth);
- if (!buff) return false;
-
- uint8_t *iSrc,*iDst;
- iSrc = GetBits(head.biHeight-1);
- iDst = GetBits(0);
- for (int32_t i=0; i<(head.biHeight/2); ++i)
- {
- memcpy(buff, iSrc, info.dwEffWidth);
- memcpy(iSrc, iDst, info.dwEffWidth);
- memcpy(iDst, buff, info.dwEffWidth);
- iSrc-=info.dwEffWidth;
- iDst+=info.dwEffWidth;
- }
-
- free(buff);
-
- if (bFlipSelection){
-#if CXIMAGE_SUPPORT_SELECTION
- SelectionFlip();
-#endif //CXIMAGE_SUPPORT_SELECTION
- }
-
- if (bFlipAlpha){
-#if CXIMAGE_SUPPORT_ALPHA
- AlphaFlip();
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \sa Flip
- */
-bool CxImage::Mirror(bool bMirrorSelection, bool bMirrorAlpha)
-{
- if (!pDib) return false;
-
- CxImage* imatmp = new CxImage(*this,false,true,true);
- if (!imatmp) return false;
- if (!imatmp->IsValid()){
- delete imatmp;
- return false;
- }
-
- uint8_t *iSrc,*iDst;
- int32_t wdt=(head.biWidth-1) * (head.biBitCount==24 ? 3:1);
- iSrc=info.pImage + wdt;
- iDst=imatmp->info.pImage;
- int32_t x,y;
- switch (head.biBitCount){
- case 24:
- for(y=0; y < head.biHeight; y++){
- for(x=0; x <= wdt; x+=3){
- *(iDst+x)=*(iSrc-x);
- *(iDst+x+1)=*(iSrc-x+1);
- *(iDst+x+2)=*(iSrc-x+2);
- }
- iSrc+=info.dwEffWidth;
- iDst+=info.dwEffWidth;
- }
- break;
- case 8:
- for(y=0; y < head.biHeight; y++){
- for(x=0; x <= wdt; x++)
- *(iDst+x)=*(iSrc-x);
- iSrc+=info.dwEffWidth;
- iDst+=info.dwEffWidth;
- }
- break;
- default:
- for(y=0; y < head.biHeight; y++){
- for(x=0; x <= wdt; x++)
- imatmp->SetPixelIndex(x,y,GetPixelIndex(wdt-x,y));
- }
- }
-
- if (bMirrorSelection){
-#if CXIMAGE_SUPPORT_SELECTION
- imatmp->SelectionMirror();
-#endif //CXIMAGE_SUPPORT_SELECTION
- }
-
- if (bMirrorAlpha){
-#if CXIMAGE_SUPPORT_ALPHA
- imatmp->AlphaMirror();
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
-
- Transfer(*imatmp);
- delete imatmp;
- return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-#define RBLOCK 64
-
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::RotateLeft(CxImage* iDst)
-{
- if (!pDib) return false;
-
- int32_t newWidth = GetHeight();
- int32_t newHeight = GetWidth();
-
- CxImage imgDest;
- imgDest.CopyInfo(*this);
- imgDest.Create(newWidth,newHeight,GetBpp(),GetType());
- imgDest.SetPalette(GetPalette());
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) imgDest.AlphaCreate();
-#endif
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (SelectionIsValid()) imgDest.SelectionCreate();
-#endif
-
- int32_t x,x2,y,dlineup;
-
- // Speedy rotate for BW images <Robert Abram>
- if (head.biBitCount == 1) {
-
- uint8_t *sbits, *dbits, *dbitsmax, bitpos, *nrow,*srcdisp;
- ldiv_t div_r;
-
- uint8_t *bsrc = GetBits(), *bdest = imgDest.GetBits();
- dbitsmax = bdest + imgDest.head.biSizeImage - 1;
- dlineup = 8 * imgDest.info.dwEffWidth - imgDest.head.biWidth;
-
- imgDest.Clear(0);
- for (y = 0; y < head.biHeight; y++) {
- // Figure out the Column we are going to be copying to
- div_r = ldiv(y + dlineup, (int32_t)8);
- // set bit pos of src column byte
- bitpos = (uint8_t)(1 << div_r.rem);
- srcdisp = bsrc + y * info.dwEffWidth;
- for (x = 0; x < (int32_t)info.dwEffWidth; x++) {
- // Get Source Bits
- sbits = srcdisp + x;
- // Get destination column
- nrow = bdest + (x * 8) * imgDest.info.dwEffWidth + imgDest.info.dwEffWidth - 1 - div_r.quot;
- for (int32_t z = 0; z < 8; z++) {
- // Get Destination Byte
- dbits = nrow + z * imgDest.info.dwEffWidth;
- if ((dbits < bdest) || (dbits > dbitsmax)) break;
- if (*sbits & (128 >> z)) *dbits |= bitpos;
- }
- }
- }//for y
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) {
- for (x = 0; x < newWidth; x++){
- x2=newWidth-x-1;
- for (y = 0; y < newHeight; y++){
- imgDest.AlphaSet(x,y,BlindAlphaGet(y, x2));
- }//for y
- }//for x
- }
-#endif //CXIMAGE_SUPPORT_ALPHA
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (SelectionIsValid()) {
- imgDest.info.rSelectionBox.left = newWidth-info.rSelectionBox.top;
- imgDest.info.rSelectionBox.right = newWidth-info.rSelectionBox.bottom;
- imgDest.info.rSelectionBox.bottom = info.rSelectionBox.left;
- imgDest.info.rSelectionBox.top = info.rSelectionBox.right;
- for (x = 0; x < newWidth; x++){
- x2=newWidth-x-1;
- for (y = 0; y < newHeight; y++){
- imgDest.SelectionSet(x,y,BlindSelectionGet(y, x2));
- }//for y
- }//for x
- }
-#endif //CXIMAGE_SUPPORT_SELECTION
-
- } else {
- //anything other than BW:
- //bd, 10. 2004: This optimized version of rotation rotates image by smaller blocks. It is quite
- //a bit faster than obvious algorithm, because it produces much less CPU cache misses.
- //This optimization can be tuned by changing block size (RBLOCK). 96 is good value for current
- //CPUs (tested on Athlon XP and Celeron D). Larger value (if CPU has enough cache) will increase
- //speed somehow, but once you drop out of CPU's cache, things will slow down drastically.
- //For older CPUs with less cache, lower value would yield better results.
-
- uint8_t *srcPtr, *dstPtr; //source and destionation for 24-bit version
- int32_t xs, ys; //x-segment and y-segment
- for (xs = 0; xs < newWidth; xs+=RBLOCK) { //for all image blocks of RBLOCK*RBLOCK pixels
- for (ys = 0; ys < newHeight; ys+=RBLOCK) {
- if (head.biBitCount==24) {
- //RGB24 optimized pixel access:
- for (x = xs; x < min(newWidth, xs+RBLOCK); x++){ //do rotation
- info.nProgress = (int32_t)(100*x/newWidth);
- x2=newWidth-x-1;
- dstPtr = (uint8_t*) imgDest.BlindGetPixelPointer(x,ys);
- srcPtr = (uint8_t*) BlindGetPixelPointer(ys, x2);
- for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
- //imgDest.SetPixelColor(x, y, GetPixelColor(y, x2));
- *(dstPtr) = *(srcPtr);
- *(dstPtr+1) = *(srcPtr+1);
- *(dstPtr+2) = *(srcPtr+2);
- srcPtr += 3;
- dstPtr += imgDest.info.dwEffWidth;
- }//for y
- }//for x
- } else {
- //anything else than 24bpp (and 1bpp): palette
- for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
- info.nProgress = (int32_t)(100*x/newWidth); //<Anatoly Ivasyuk>
- x2=newWidth-x-1;
- for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
- imgDest.SetPixelIndex(x, y, BlindGetPixelIndex(y, x2));
- }//for y
- }//for x
- }//if (version selection)
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) {
- for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
- x2=newWidth-x-1;
- for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
- imgDest.AlphaSet(x,y,BlindAlphaGet(y, x2));
- }//for y
- }//for x
- }//if (alpha channel)
-#endif //CXIMAGE_SUPPORT_ALPHA
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (SelectionIsValid()) {
- imgDest.info.rSelectionBox.left = newWidth-info.rSelectionBox.top;
- imgDest.info.rSelectionBox.right = newWidth-info.rSelectionBox.bottom;
- imgDest.info.rSelectionBox.bottom = info.rSelectionBox.left;
- imgDest.info.rSelectionBox.top = info.rSelectionBox.right;
- for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
- x2=newWidth-x-1;
- for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
- imgDest.SelectionSet(x,y,BlindSelectionGet(y, x2));
- }//for y
- }//for x
- }//if (selection)
-#endif //CXIMAGE_SUPPORT_SELECTION
- }//for ys
- }//for xs
- }//if
-
- //select the destination
- if (iDst) iDst->Transfer(imgDest);
- else Transfer(imgDest);
- return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::RotateRight(CxImage* iDst)
-{
- if (!pDib) return false;
-
- int32_t newWidth = GetHeight();
- int32_t newHeight = GetWidth();
-
- CxImage imgDest;
- imgDest.CopyInfo(*this);
- imgDest.Create(newWidth,newHeight,GetBpp(),GetType());
- imgDest.SetPalette(GetPalette());
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) imgDest.AlphaCreate();
-#endif
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (SelectionIsValid()) imgDest.SelectionCreate();
-#endif
-
- int32_t x,y,y2;
- // Speedy rotate for BW images <Robert Abram>
- if (head.biBitCount == 1) {
-
- uint8_t *sbits, *dbits, *dbitsmax, bitpos, *nrow,*srcdisp;
- ldiv_t div_r;
-
- uint8_t *bsrc = GetBits(), *bdest = imgDest.GetBits();
- dbitsmax = bdest + imgDest.head.biSizeImage - 1;
-
- imgDest.Clear(0);
- for (y = 0; y < head.biHeight; y++) {
- // Figure out the Column we are going to be copying to
- div_r = ldiv(y, (int32_t)8);
- // set bit pos of src column byte
- bitpos = (uint8_t)(128 >> div_r.rem);
- srcdisp = bsrc + y * info.dwEffWidth;
- for (x = 0; x < (int32_t)info.dwEffWidth; x++) {
- // Get Source Bits
- sbits = srcdisp + x;
- // Get destination column
- nrow = bdest + (imgDest.head.biHeight-1-(x*8)) * imgDest.info.dwEffWidth + div_r.quot;
- for (int32_t z = 0; z < 8; z++) {
- // Get Destination Byte
- dbits = nrow - z * imgDest.info.dwEffWidth;
- if ((dbits < bdest) || (dbits > dbitsmax)) break;
- if (*sbits & (128 >> z)) *dbits |= bitpos;
- }
- }
- }
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()){
- for (y = 0; y < newHeight; y++){
- y2=newHeight-y-1;
- for (x = 0; x < newWidth; x++){
- imgDest.AlphaSet(x,y,BlindAlphaGet(y2, x));
- }
- }
- }
-#endif //CXIMAGE_SUPPORT_ALPHA
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (SelectionIsValid()){
- imgDest.info.rSelectionBox.left = info.rSelectionBox.bottom;
- imgDest.info.rSelectionBox.right = info.rSelectionBox.top;
- imgDest.info.rSelectionBox.bottom = newHeight-info.rSelectionBox.right;
- imgDest.info.rSelectionBox.top = newHeight-info.rSelectionBox.left;
- for (y = 0; y < newHeight; y++){
- y2=newHeight-y-1;
- for (x = 0; x < newWidth; x++){
- imgDest.SelectionSet(x,y,BlindSelectionGet(y2, x));
- }
- }
- }
-#endif //CXIMAGE_SUPPORT_SELECTION
-
- } else {
- //anything else but BW
- uint8_t *srcPtr, *dstPtr; //source and destionation for 24-bit version
- int32_t xs, ys; //x-segment and y-segment
- for (xs = 0; xs < newWidth; xs+=RBLOCK) {
- for (ys = 0; ys < newHeight; ys+=RBLOCK) {
- if (head.biBitCount==24) {
- //RGB24 optimized pixel access:
- for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
- info.nProgress = (int32_t)(100*y/newHeight); //<Anatoly Ivasyuk>
- y2=newHeight-y-1;
- dstPtr = (uint8_t*) imgDest.BlindGetPixelPointer(xs,y);
- srcPtr = (uint8_t*) BlindGetPixelPointer(y2, xs);
- for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
- //imgDest.SetPixelColor(x, y, GetPixelColor(y2, x));
- *(dstPtr) = *(srcPtr);
- *(dstPtr+1) = *(srcPtr+1);
- *(dstPtr+2) = *(srcPtr+2);
- dstPtr += 3;
- srcPtr += info.dwEffWidth;
- }//for x
- }//for y
- } else {
- //anything else than BW & RGB24: palette
- for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
- info.nProgress = (int32_t)(100*y/newHeight); //<Anatoly Ivasyuk>
- y2=newHeight-y-1;
- for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
- imgDest.SetPixelIndex(x, y, BlindGetPixelIndex(y2, x));
- }//for x
- }//for y
- }//if
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()){
- for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
- y2=newHeight-y-1;
- for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
- imgDest.AlphaSet(x,y,BlindAlphaGet(y2, x));
- }//for x
- }//for y
- }//if (has alpha)
-#endif //CXIMAGE_SUPPORT_ALPHA
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (SelectionIsValid()){
- imgDest.info.rSelectionBox.left = info.rSelectionBox.bottom;
- imgDest.info.rSelectionBox.right = info.rSelectionBox.top;
- imgDest.info.rSelectionBox.bottom = newHeight-info.rSelectionBox.right;
- imgDest.info.rSelectionBox.top = newHeight-info.rSelectionBox.left;
- for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
- y2=newHeight-y-1;
- for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
- imgDest.SelectionSet(x,y,BlindSelectionGet(y2, x));
- }//for x
- }//for y
- }//if (has alpha)
-#endif //CXIMAGE_SUPPORT_SELECTION
- }//for ys
- }//for xs
- }//if
-
- //select the destination
- if (iDst) iDst->Transfer(imgDest);
- else Transfer(imgDest);
- return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::Negative()
-{
- if (!pDib) return false;
-
- if (head.biBitCount<=8){
- if (IsGrayScale()){ //GRAYSCALE, selection
- if (pSelection){
- for(int32_t y=info.rSelectionBox.bottom; y<info.rSelectionBox.top; y++){
- for(int32_t x=info.rSelectionBox.left; x<info.rSelectionBox.right; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- BlindSetPixelIndex(x,y,(uint8_t)(255-BlindGetPixelIndex(x,y)));
- }
- }
- }
- } else {
- uint8_t *iSrc=info.pImage;
- for(uint32_t i=0; i < head.biSizeImage; i++){
- *iSrc=(uint8_t)~(*(iSrc));
- iSrc++;
- }
- }
- } else { //PALETTE, full image
- RGBQUAD* ppal=GetPalette();
- for(uint32_t i=0;i<head.biClrUsed;i++){
- ppal[i].rgbBlue =(uint8_t)(255-ppal[i].rgbBlue);
- ppal[i].rgbGreen =(uint8_t)(255-ppal[i].rgbGreen);
- ppal[i].rgbRed =(uint8_t)(255-ppal[i].rgbRed);
- }
- }
- } else {
- if (pSelection==NULL){ //RGB, full image
- uint8_t *iSrc=info.pImage;
- for(uint32_t i=0; i < head.biSizeImage; i++){
- *iSrc=(uint8_t)~(*(iSrc));
- iSrc++;
- }
- } else { // RGB with selection
- RGBQUAD color;
- for(int32_t y=info.rSelectionBox.bottom; y<info.rSelectionBox.top; y++){
- for(int32_t x=info.rSelectionBox.left; x<info.rSelectionBox.right; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- color = BlindGetPixelColor(x,y);
- color.rgbRed = (uint8_t)(255-color.rgbRed);
- color.rgbGreen = (uint8_t)(255-color.rgbGreen);
- color.rgbBlue = (uint8_t)(255-color.rgbBlue);
- BlindSetPixelColor(x,y,color);
- }
- }
- }
- }
- //<DP> invert transparent color too
- info.nBkgndColor.rgbBlue = (uint8_t)(255-info.nBkgndColor.rgbBlue);
- info.nBkgndColor.rgbGreen = (uint8_t)(255-info.nBkgndColor.rgbGreen);
- info.nBkgndColor.rgbRed = (uint8_t)(255-info.nBkgndColor.rgbRed);
- }
- return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_BASICTRANSFORMATIONS
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_TRANSFORMATION
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_EXIF
-bool CxImage::RotateExif(int32_t orientation /* = 0 */)
-{
- bool ret = true;
- if (orientation <= 0)
- orientation = info.ExifInfo.Orientation;
- if (orientation == 3)
- ret = Rotate180();
- else if (orientation == 6)
- ret = RotateRight();
- else if (orientation == 8)
- ret = RotateLeft();
- else if (orientation == 5)
- ret = RotateLeft();
-
- info.ExifInfo.Orientation = 1;
- return ret;
-}
-#endif //CXIMAGE_SUPPORT_EXIF
-
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::Rotate(float angle, CxImage* iDst)
-{
- if (!pDib) return false;
-
- if (fmod(angle,180.0f)==0.0f && fmod(angle,360.0f)!=0.0f)
- return Rotate180(iDst);
-
- // Copyright (c) 1996-1998 Ulrich von Zadow
-
- // Negative the angle, because the y-axis is negative.
- double ang = -angle*acos((float)0)/90;
- int32_t newWidth, newHeight;
- int32_t nWidth = GetWidth();
- int32_t nHeight= GetHeight();
- double cos_angle = cos(ang);
- double sin_angle = sin(ang);
-
- // Calculate the size of the new bitmap
- POINT p1={0,0};
- POINT p2={nWidth,0};
- POINT p3={0,nHeight};
- POINT p4={nWidth,nHeight};
- CxPoint2 newP1,newP2,newP3,newP4, leftTop, rightTop, leftBottom, rightBottom;
-
- newP1.x = (float)p1.x;
- newP1.y = (float)p1.y;
- newP2.x = (float)(p2.x*cos_angle - p2.y*sin_angle);
- newP2.y = (float)(p2.x*sin_angle + p2.y*cos_angle);
- newP3.x = (float)(p3.x*cos_angle - p3.y*sin_angle);
- newP3.y = (float)(p3.x*sin_angle + p3.y*cos_angle);
- newP4.x = (float)(p4.x*cos_angle - p4.y*sin_angle);
- newP4.y = (float)(p4.x*sin_angle + p4.y*cos_angle);
-
- leftTop.x = min(min(newP1.x,newP2.x),min(newP3.x,newP4.x));
- leftTop.y = min(min(newP1.y,newP2.y),min(newP3.y,newP4.y));
- rightBottom.x = max(max(newP1.x,newP2.x),max(newP3.x,newP4.x));
- rightBottom.y = max(max(newP1.y,newP2.y),max(newP3.y,newP4.y));
- leftBottom.x = leftTop.x;
- leftBottom.y = rightBottom.y;
- rightTop.x = rightBottom.x;
- rightTop.y = leftTop.y;
-
- newWidth = (int32_t) floor(0.5f + rightTop.x - leftTop.x);
- newHeight= (int32_t) floor(0.5f + leftBottom.y - leftTop.y);
- CxImage imgDest;
- imgDest.CopyInfo(*this);
- imgDest.Create(newWidth,newHeight,GetBpp(),GetType());
- imgDest.SetPalette(GetPalette());
-
-#if CXIMAGE_SUPPORT_ALPHA
- if(AlphaIsValid()) //MTA: Fix for rotation problem when the image has an alpha channel
- {
- imgDest.AlphaCreate();
- imgDest.AlphaClear();
- }
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- int32_t x,y,newX,newY,oldX,oldY;
-
- if (head.biClrUsed==0){ //RGB
- for (y = (int32_t)leftTop.y, newY = 0; y<=(int32_t)leftBottom.y; y++,newY++){
- info.nProgress = (int32_t)(100*newY/newHeight);
- if (info.nEscape) break;
- for (x = (int32_t)leftTop.x, newX = 0; x<=(int32_t)rightTop.x; x++,newX++){
- oldX = (int32_t)(x*cos_angle + y*sin_angle + 0.5);
- oldY = (int32_t)(y*cos_angle - x*sin_angle + 0.5);
- imgDest.SetPixelColor(newX,newY,GetPixelColor(oldX,oldY));
-#if CXIMAGE_SUPPORT_ALPHA
- imgDest.AlphaSet(newX,newY,AlphaGet(oldX,oldY)); //MTA: copy the alpha value
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- }
- } else { //PALETTE
- for (y = (int32_t)leftTop.y, newY = 0; y<=(int32_t)leftBottom.y; y++,newY++){
- info.nProgress = (int32_t)(100*newY/newHeight);
- if (info.nEscape) break;
- for (x = (int32_t)leftTop.x, newX = 0; x<=(int32_t)rightTop.x; x++,newX++){
- oldX = (int32_t)(x*cos_angle + y*sin_angle + 0.5);
- oldY = (int32_t)(y*cos_angle - x*sin_angle + 0.5);
- imgDest.SetPixelIndex(newX,newY,GetPixelIndex(oldX,oldY));
-#if CXIMAGE_SUPPORT_ALPHA
- imgDest.AlphaSet(newX,newY,AlphaGet(oldX,oldY)); //MTA: copy the alpha value
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- }
- }
- //select the destination
- if (iDst) iDst->Transfer(imgDest);
- else Transfer(imgDest);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Rotates image around it's center.
- * Method can use interpolation with paletted images, but does not change pallete, so results vary.
- * (If you have only four colours in a palette, there's not much room for interpolation.)
- *
- * \param angle - angle in degrees (positive values rotate clockwise)
- * \param *iDst - destination image (if null, this image is changed)
- * \param inMethod - interpolation method used
- * (IM_NEAREST_NEIGHBOUR produces aliasing (fast), IM_BILINEAR softens picture a bit (slower)
- * IM_SHARPBICUBIC is slower and produces some halos...)
- * \param ofMethod - overflow method (how to choose colour of pixels that have no source)
- * \param replColor - replacement colour to use (OM_COLOR, OM_BACKGROUND with no background colour...)
- * \param optimizeRightAngles - call faster methods for 90, 180, and 270 degree rotations. Faster methods
- * are called for angles, where error (in location of corner pixels) is less
- * than 0.25 pixels.
- * \param bKeepOriginalSize - rotates the image without resizing.
- *
- * \author ***bd*** 2.2004
- */
-bool CxImage::Rotate2(float angle,
- CxImage *iDst,
- InterpolationMethod inMethod,
- OverflowMethod ofMethod,
- RGBQUAD *replColor,
- bool const optimizeRightAngles,
- bool const bKeepOriginalSize)
-{
- if (!pDib) return false; //no dib no go
-
- if (fmod(angle,180.0f)==0.0f && fmod(angle,360.0f)!=0.0f)
- return Rotate180(iDst);
-
- double ang = -angle*acos(0.0f)/90.0f; //convert angle to radians and invert (positive angle performs clockwise rotation)
- float cos_angle = (float) cos(ang); //these two are needed later (to rotate)
- float sin_angle = (float) sin(ang);
-
- //Calculate the size of the new bitmap (rotate corners of image)
- CxPoint2 p[4]; //original corners of the image
- p[0]=CxPoint2(-0.5f,-0.5f);
- p[1]=CxPoint2(GetWidth()-0.5f,-0.5f);
- p[2]=CxPoint2(-0.5f,GetHeight()-0.5f);
- p[3]=CxPoint2(GetWidth()-0.5f,GetHeight()-0.5f);
- CxPoint2 newp[4]; //rotated positions of corners
- //(rotate corners)
- if (bKeepOriginalSize){
- for (int32_t i=0; i<4; i++) {
- newp[i].x = p[i].x;
- newp[i].y = p[i].y;
- }//for
- } else {
- for (int32_t i=0; i<4; i++) {
- newp[i].x = (p[i].x*cos_angle - p[i].y*sin_angle);
- newp[i].y = (p[i].x*sin_angle + p[i].y*cos_angle);
- }//for i
-
- if (optimizeRightAngles) {
- //For rotations of 90, -90 or 180 or 0 degrees, call faster routines
- if (newp[3].Distance(CxPoint2(GetHeight()-0.5f, 0.5f-GetWidth())) < 0.25)
- //rotation right for circa 90 degrees (diagonal pixels less than 0.25 pixel away from 90 degree rotation destination)
- return RotateRight(iDst);
- if (newp[3].Distance(CxPoint2(0.5f-GetHeight(), -0.5f+GetWidth())) < 0.25)
- //rotation left for ~90 degrees
- return RotateLeft(iDst);
- if (newp[3].Distance(CxPoint2(0.5f-GetWidth(), 0.5f-GetHeight())) < 0.25)
- //rotation left for ~180 degrees
- return Rotate180(iDst);
- if (newp[3].Distance(p[3]) < 0.25) {
- //rotation not significant
- if (iDst) iDst->Copy(*this); //copy image to iDst, if required
- return true; //and we're done
- }//if
- }//if
- }//if
-
- //(read new dimensions from location of corners)
- float minx = (float) min(min(newp[0].x,newp[1].x),min(newp[2].x,newp[3].x));
- float miny = (float) min(min(newp[0].y,newp[1].y),min(newp[2].y,newp[3].y));
- float maxx = (float) max(max(newp[0].x,newp[1].x),max(newp[2].x,newp[3].x));
- float maxy = (float) max(max(newp[0].y,newp[1].y),max(newp[2].y,newp[3].y));
- int32_t newWidth = (int32_t) floor(maxx-minx+0.5f);
- int32_t newHeight= (int32_t) floor(maxy-miny+0.5f);
- float ssx=((maxx+minx)- ((float) newWidth-1))/2.0f; //start for x
- float ssy=((maxy+miny)- ((float) newHeight-1))/2.0f; //start for y
-
- float newxcenteroffset = 0.5f * newWidth;
- float newycenteroffset = 0.5f * newHeight;
- if (bKeepOriginalSize){
- ssx -= 0.5f * GetWidth();
- ssy -= 0.5f * GetHeight();
- }
-
- //create destination image
- CxImage imgDest;
- imgDest.CopyInfo(*this);
- imgDest.Create(newWidth,newHeight,GetBpp(),GetType());
- imgDest.SetPalette(GetPalette());
-#if CXIMAGE_SUPPORT_ALPHA
- if(AlphaIsValid()) imgDest.AlphaCreate(); //MTA: Fix for rotation problem when the image has an alpha channel
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- RGBQUAD rgb; //pixel colour
- RGBQUAD rc;
- if (replColor!=0)
- rc=*replColor;
- else {
- rc.rgbRed=255; rc.rgbGreen=255; rc.rgbBlue=255; rc.rgbReserved=0;
- }//if
- float x,y; //destination location (float, with proper offset)
- float origx, origy; //origin location
- int32_t destx, desty; //destination location
-
- y=ssy; //initialize y
- if (!IsIndexed()){ //RGB24
- //optimized RGB24 implementation (direct write to destination):
- uint8_t *pxptr;
-#if CXIMAGE_SUPPORT_ALPHA
- uint8_t *pxptra=0;
-#endif //CXIMAGE_SUPPORT_ALPHA
- for (desty=0; desty<newHeight; desty++) {
- info.nProgress = (int32_t)(100*desty/newHeight);
- if (info.nEscape) break;
- //initialize x
- x=ssx;
- //calculate pointer to first byte in row
- pxptr=(uint8_t *)imgDest.BlindGetPixelPointer(0, desty);
-#if CXIMAGE_SUPPORT_ALPHA
- //calculate pointer to first byte in row
- if (AlphaIsValid()) pxptra=imgDest.AlphaGetPointer(0, desty);
-#endif //CXIMAGE_SUPPORT_ALPHA
- for (destx=0; destx<newWidth; destx++) {
- //get source pixel coordinate for current destination point
- //origx = (cos_angle*(x-head.biWidth/2)+sin_angle*(y-head.biHeight/2))+newWidth/2;
- //origy = (cos_angle*(y-head.biHeight/2)-sin_angle*(x-head.biWidth/2))+newHeight/2;
- origx = cos_angle*x+sin_angle*y;
- origy = cos_angle*y-sin_angle*x;
- if (bKeepOriginalSize){
- origx += newxcenteroffset;
- origy += newycenteroffset;
- }
- rgb = GetPixelColorInterpolated(origx, origy, inMethod, ofMethod, &rc); //get interpolated colour value
- //copy alpha and colour value to destination
-#if CXIMAGE_SUPPORT_ALPHA
- if (pxptra) *pxptra++ = rgb.rgbReserved;
-#endif //CXIMAGE_SUPPORT_ALPHA
- *pxptr++ = rgb.rgbBlue;
- *pxptr++ = rgb.rgbGreen;
- *pxptr++ = rgb.rgbRed;
- x++;
- }//for destx
- y++;
- }//for desty
- } else {
- //non-optimized implementation for paletted images
- for (desty=0; desty<newHeight; desty++) {
- info.nProgress = (int32_t)(100*desty/newHeight);
- if (info.nEscape) break;
- x=ssx;
- for (destx=0; destx<newWidth; destx++) {
- //get source pixel coordinate for current destination point
- origx=(cos_angle*x+sin_angle*y);
- origy=(cos_angle*y-sin_angle*x);
- if (bKeepOriginalSize){
- origx += newxcenteroffset;
- origy += newycenteroffset;
- }
- rgb = GetPixelColorInterpolated(origx, origy, inMethod, ofMethod, &rc);
- //***!*** SetPixelColor is slow for palleted images
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid())
- imgDest.SetPixelColor(destx,desty,rgb,true);
- else
-#endif //CXIMAGE_SUPPORT_ALPHA
- imgDest.SetPixelColor(destx,desty,rgb,false);
- x++;
- }//for destx
- y++;
- }//for desty
- }
- //select the destination
-
- if (iDst) iDst->Transfer(imgDest);
- else Transfer(imgDest);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::Rotate180(CxImage* iDst)
-{
- if (!pDib) return false;
-
- int32_t wid = GetWidth();
- int32_t ht = GetHeight();
-
- CxImage imgDest;
- imgDest.CopyInfo(*this);
- imgDest.Create(wid,ht,GetBpp(),GetType());
- imgDest.SetPalette(GetPalette());
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) imgDest.AlphaCreate();
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- int32_t x,y,y2;
- for (y = 0; y < ht; y++){
- info.nProgress = (int32_t)(100*y/ht); //<Anatoly Ivasyuk>
- y2=ht-y-1;
- for (x = 0; x < wid; x++){
- if(head.biClrUsed==0)//RGB
- imgDest.SetPixelColor(wid-x-1, y2, BlindGetPixelColor(x, y));
- else //PALETTE
- imgDest.SetPixelIndex(wid-x-1, y2, BlindGetPixelIndex(x, y));
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) imgDest.AlphaSet(wid-x-1, y2,BlindAlphaGet(x, y));
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- }
- }
-
- //select the destination
- if (iDst) iDst->Transfer(imgDest);
- else Transfer(imgDest);
- return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Resizes the image. mode can be 0 for slow (bilinear) method ,
- * 1 for fast (nearest pixel) method, or 2 for accurate (bicubic spline interpolation) method.
- * The function is faster with 24 and 1 bpp images, slow for 4 bpp images and slowest for 8 bpp images.
- */
-bool CxImage::Resample(int32_t newx, int32_t newy, int32_t mode, CxImage* iDst)
-{
- if (newx==0 || newy==0) return false;
-
- if (head.biWidth==newx && head.biHeight==newy){
- if (iDst) iDst->Copy(*this);
- return true;
- }
-
- float xScale, yScale, fX, fY;
- xScale = (float)head.biWidth / (float)newx;
- yScale = (float)head.biHeight / (float)newy;
-
- CxImage newImage;
- newImage.CopyInfo(*this);
- newImage.Create(newx,newy,head.biBitCount,GetType());
- newImage.SetPalette(GetPalette());
- if (!newImage.IsValid()){
- strcpy(info.szLastError,newImage.GetLastError());
- return false;
- }
-
- switch (mode) {
- case 1: // nearest pixel
- {
- for(int32_t y=0; y<newy; y++){
- info.nProgress = (int32_t)(100*y/newy);
- if (info.nEscape) break;
- fY = y * yScale;
- for(int32_t x=0; x<newx; x++){
- fX = x * xScale;
- newImage.SetPixelColor(x,y,GetPixelColor((int32_t)fX,(int32_t)fY));
- }
- }
- break;
- }
- case 2: // bicubic interpolation by Blake L. Carlson <blake-carlson(at)uiowa(dot)edu
- {
- float f_x, f_y, a, b, rr, gg, bb, r1, r2;
- int32_t i_x, i_y, xx, yy;
- RGBQUAD rgb;
- uint8_t* iDst;
- for(int32_t y=0; y<newy; y++){
- info.nProgress = (int32_t)(100*y/newy);
- if (info.nEscape) break;
- f_y = (float) y * yScale - 0.5f;
- i_y = (int32_t) floor(f_y);
- a = f_y - (float)floor(f_y);
- for(int32_t x=0; x<newx; x++){
- f_x = (float) x * xScale - 0.5f;
- i_x = (int32_t) floor(f_x);
- b = f_x - (float)floor(f_x);
-
- rr = gg = bb = 0.0f;
- for(int32_t m=-1; m<3; m++) {
- r1 = KernelBSpline((float) m - a);
- yy = i_y+m;
- if (yy<0) yy=0;
- if (yy>=head.biHeight) yy = head.biHeight-1;
- for(int32_t n=-1; n<3; n++) {
- r2 = r1 * KernelBSpline(b - (float)n);
- xx = i_x+n;
- if (xx<0) xx=0;
- if (xx>=head.biWidth) xx=head.biWidth-1;
-
- if (head.biClrUsed){
- rgb = GetPixelColor(xx,yy);
- } else {
- iDst = info.pImage + yy*info.dwEffWidth + xx*3;
- rgb.rgbBlue = *iDst++;
- rgb.rgbGreen= *iDst++;
- rgb.rgbRed = *iDst;
- }
-
- rr += rgb.rgbRed * r2;
- gg += rgb.rgbGreen * r2;
- bb += rgb.rgbBlue * r2;
- }
- }
-
- if (head.biClrUsed)
- newImage.SetPixelColor(x,y,RGB(rr,gg,bb));
- else {
- iDst = newImage.info.pImage + y*newImage.info.dwEffWidth + x*3;
- *iDst++ = (uint8_t)bb;
- *iDst++ = (uint8_t)gg;
- *iDst = (uint8_t)rr;
- }
-
- }
- }
- break;
- }
- default: // bilinear interpolation
- if (!(head.biWidth>newx && head.biHeight>newy && head.biBitCount==24)) {
- // (c) 1999 Steve McMahon (steve@dogma.demon.co.uk)
- int32_t ifX, ifY, ifX1, ifY1, xmax, ymax;
- float ir1, ir2, ig1, ig2, ib1, ib2, dx, dy;
- uint8_t r,g,b;
- RGBQUAD rgb1, rgb2, rgb3, rgb4;
- xmax = head.biWidth-1;
- ymax = head.biHeight-1;
- for(int32_t y=0; y<newy; y++){
- info.nProgress = (int32_t)(100*y/newy);
- if (info.nEscape) break;
- fY = y * yScale;
- ifY = (int32_t)fY;
- ifY1 = min(ymax, ifY+1);
- dy = fY - ifY;
- for(int32_t x=0; x<newx; x++){
- fX = x * xScale;
- ifX = (int32_t)fX;
- ifX1 = min(xmax, ifX+1);
- dx = fX - ifX;
- // Interpolate using the four nearest pixels in the source
- if (head.biClrUsed){
- rgb1=GetPaletteColor(GetPixelIndex(ifX,ifY));
- rgb2=GetPaletteColor(GetPixelIndex(ifX1,ifY));
- rgb3=GetPaletteColor(GetPixelIndex(ifX,ifY1));
- rgb4=GetPaletteColor(GetPixelIndex(ifX1,ifY1));
- }
- else {
- uint8_t* iDst;
- iDst = info.pImage + ifY*info.dwEffWidth + ifX*3;
- rgb1.rgbBlue = *iDst++; rgb1.rgbGreen= *iDst++; rgb1.rgbRed =*iDst;
- iDst = info.pImage + ifY*info.dwEffWidth + ifX1*3;
- rgb2.rgbBlue = *iDst++; rgb2.rgbGreen= *iDst++; rgb2.rgbRed =*iDst;
- iDst = info.pImage + ifY1*info.dwEffWidth + ifX*3;
- rgb3.rgbBlue = *iDst++; rgb3.rgbGreen= *iDst++; rgb3.rgbRed =*iDst;
- iDst = info.pImage + ifY1*info.dwEffWidth + ifX1*3;
- rgb4.rgbBlue = *iDst++; rgb4.rgbGreen= *iDst++; rgb4.rgbRed =*iDst;
- }
- // Interplate in x direction:
- ir1 = rgb1.rgbRed + (rgb3.rgbRed - rgb1.rgbRed) * dy;
- ig1 = rgb1.rgbGreen + (rgb3.rgbGreen - rgb1.rgbGreen) * dy;
- ib1 = rgb1.rgbBlue + (rgb3.rgbBlue - rgb1.rgbBlue) * dy;
- ir2 = rgb2.rgbRed + (rgb4.rgbRed - rgb2.rgbRed) * dy;
- ig2 = rgb2.rgbGreen + (rgb4.rgbGreen - rgb2.rgbGreen) * dy;
- ib2 = rgb2.rgbBlue + (rgb4.rgbBlue - rgb2.rgbBlue) * dy;
- // Interpolate in y:
- r = (uint8_t)(ir1 + (ir2-ir1) * dx);
- g = (uint8_t)(ig1 + (ig2-ig1) * dx);
- b = (uint8_t)(ib1 + (ib2-ib1) * dx);
- // Set output
- newImage.SetPixelColor(x,y,RGB(r,g,b));
- }
- }
- } else {
- //high resolution shrink, thanks to Henrik Stellmann <henrik.stellmann@volleynet.de>
- const int32_t ACCURACY = 1000;
- int32_t i,j; // index for faValue
- int32_t x,y; // coordinates in source image
- uint8_t* pSource;
- uint8_t* pDest = newImage.info.pImage;
- int32_t* naAccu = new int32_t[3 * newx + 3];
- int32_t* naCarry = new int32_t[3 * newx + 3];
- int32_t* naTemp;
- int32_t nWeightX,nWeightY;
- float fEndX;
- int32_t nScale = (int32_t)(ACCURACY * xScale * yScale);
-
- memset(naAccu, 0, sizeof(int32_t) * 3 * newx);
- memset(naCarry, 0, sizeof(int32_t) * 3 * newx);
-
- int32_t u, v = 0; // coordinates in dest image
- float fEndY = yScale - 1.0f;
- for (y = 0; y < head.biHeight; y++){
- info.nProgress = (int32_t)(100*y/head.biHeight); //<Anatoly Ivasyuk>
- if (info.nEscape) break;
- pSource = info.pImage + y * info.dwEffWidth;
- u = i = 0;
- fEndX = xScale - 1.0f;
- if ((float)y < fEndY) { // complete source row goes into dest row
- for (x = 0; x < head.biWidth; x++){
- if ((float)x < fEndX){ // complete source pixel goes into dest pixel
- for (j = 0; j < 3; j++) naAccu[i + j] += (*pSource++) * ACCURACY;
- } else { // source pixel is splitted for 2 dest pixels
- nWeightX = (int32_t)(((float)x - fEndX) * ACCURACY);
- for (j = 0; j < 3; j++){
- naAccu[i] += (ACCURACY - nWeightX) * (*pSource);
- naAccu[3 + i++] += nWeightX * (*pSource++);
- }
- fEndX += xScale;
- u++;
- }
- }
- } else { // source row is splitted for 2 dest rows
- nWeightY = (int32_t)(((float)y - fEndY) * ACCURACY);
- for (x = 0; x < head.biWidth; x++){
- if ((float)x < fEndX){ // complete source pixel goes into 2 pixel
- for (j = 0; j < 3; j++){
- naAccu[i + j] += ((ACCURACY - nWeightY) * (*pSource));
- naCarry[i + j] += nWeightY * (*pSource++);
- }
- } else { // source pixel is splitted for 4 dest pixels
- nWeightX = (int32_t)(((float)x - fEndX) * ACCURACY);
- for (j = 0; j < 3; j++) {
- naAccu[i] += ((ACCURACY - nWeightY) * (ACCURACY - nWeightX)) * (*pSource) / ACCURACY;
- *pDest++ = (uint8_t)(naAccu[i] / nScale);
- naCarry[i] += (nWeightY * (ACCURACY - nWeightX) * (*pSource)) / ACCURACY;
- naAccu[i + 3] += ((ACCURACY - nWeightY) * nWeightX * (*pSource)) / ACCURACY;
- naCarry[i + 3] = (nWeightY * nWeightX * (*pSource)) / ACCURACY;
- i++;
- pSource++;
- }
- fEndX += xScale;
- u++;
- }
- }
- if (u < newx){ // possibly not completed due to rounding errors
- for (j = 0; j < 3; j++) *pDest++ = (uint8_t)(naAccu[i++] / nScale);
- }
- naTemp = naCarry;
- naCarry = naAccu;
- naAccu = naTemp;
- memset(naCarry, 0, sizeof(int32_t) * 3); // need only to set first pixel zero
- pDest = newImage.info.pImage + (++v * newImage.info.dwEffWidth);
- fEndY += yScale;
- }
- }
- if (v < newy){ // possibly not completed due to rounding errors
- for (i = 0; i < 3 * newx; i++) *pDest++ = (uint8_t)(naAccu[i] / nScale);
- }
- delete [] naAccu;
- delete [] naCarry;
- }
- }
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()){
- if (1 == mode){
- newImage.AlphaCreate();
- for(int32_t y=0; y<newy; y++){
- fY = y * yScale;
- for(int32_t x=0; x<newx; x++){
- fX = x * xScale;
- newImage.AlphaSet(x,y,AlphaGet((int32_t)fX,(int32_t)fY));
- }
- }
- } else {
- CxImage newAlpha;
- AlphaSplit(&newAlpha);
- newAlpha.Resample(newx, newy, mode);
- newImage.AlphaSet(newAlpha);
- }
- }
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- //select the destination
- if (iDst) iDst->Transfer(newImage);
- else Transfer(newImage);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * New simpler resample. Adds new interpolation methods and simplifies code (using GetPixelColorInterpolated
- * and GetAreaColorInterpolated). It also (unlike old method) interpolates alpha layer.
- *
- * \param newx, newy - size of resampled image
- * \param inMethod - interpolation method to use (see comments at GetPixelColorInterpolated)
- * If image size is being reduced, averaging is used instead (or simultaneously with) inMethod.
- * \param ofMethod - what to replace outside pixels by (only significant for bordering pixels of enlarged image)
- * \param iDst - pointer to destination CxImage or NULL.
- * \param disableAveraging - force no averaging when shrinking images (Produces aliasing.
- * You probably just want to leave this off...)
- *
- * \author ***bd*** 2.2004
- */
-bool CxImage::Resample2(
- int32_t newx, int32_t newy,
- InterpolationMethod const inMethod,
- OverflowMethod const ofMethod,
- CxImage* const iDst,
- bool const disableAveraging)
-{
- if (newx<=0 || newy<=0 || !pDib) return false;
-
- if (head.biWidth==newx && head.biHeight==newy) {
- //image already correct size (just copy and return)
- if (iDst) iDst->Copy(*this);
- return true;
- }//if
-
- //calculate scale of new image (less than 1 for enlarge)
- float xScale, yScale;
- xScale = (float)head.biWidth / (float)newx;
- yScale = (float)head.biHeight / (float)newy;
-
- //create temporary destination image
- CxImage newImage;
- newImage.CopyInfo(*this);
- newImage.Create(newx,newy,head.biBitCount,GetType());
- newImage.SetPalette(GetPalette());
- if (!newImage.IsValid()){
- strcpy(info.szLastError,newImage.GetLastError());
- return false;
- }
-
- //and alpha channel if required
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) newImage.AlphaCreate();
- uint8_t *pxptra = 0; // destination alpha data
-#endif
-
- float sX, sY; //source location
- int32_t dX,dY; //destination pixel (int32_t value)
- if ((xScale<=1 && yScale<=1) || disableAveraging) {
- //image is being enlarged (or interpolation on demand)
- if (!IsIndexed()) {
- //RGB24 image (optimized version with direct writes)
- RGBQUAD q; //pixel colour
- uint8_t *pxptr; //pointer to destination pixel
- for(dY=0; dY<newy; dY++){
- info.nProgress = (int32_t)(100*dY/newy);
- if (info.nEscape) break;
- sY = (dY + 0.5f) * yScale - 0.5f;
- pxptr=(uint8_t*)(newImage.BlindGetPixelPointer(0,dY));
-#if CXIMAGE_SUPPORT_ALPHA
- pxptra=newImage.AlphaGetPointer(0,dY);
-#endif
- for(dX=0; dX<newx; dX++){
- sX = (dX + 0.5f) * xScale - 0.5f;
- q=GetPixelColorInterpolated(sX,sY,inMethod,ofMethod,0);
- *pxptr++=q.rgbBlue;
- *pxptr++=q.rgbGreen;
- *pxptr++=q.rgbRed;
-#if CXIMAGE_SUPPORT_ALPHA
- if (pxptra) *pxptra++=q.rgbReserved;
-#endif
- }//for dX
- }//for dY
- } else {
- //enlarge paletted image. Slower method.
- for(dY=0; dY<newy; dY++){
- info.nProgress = (int32_t)(100*dY/newy);
- if (info.nEscape) break;
- sY = (dY + 0.5f) * yScale - 0.5f;
- for(dX=0; dX<newx; dX++){
- sX = (dX + 0.5f) * xScale - 0.5f;
- newImage.SetPixelColor(dX,dY,GetPixelColorInterpolated(sX,sY,inMethod,ofMethod,0),true);
- }//for x
- }//for y
- }//if
- } else {
- //image size is being reduced (averaging enabled)
- for(dY=0; dY<newy; dY++){
- info.nProgress = (int32_t)(100*dY/newy); if (info.nEscape) break;
- sY = (dY+0.5f) * yScale - 0.5f;
- for(dX=0; dX<newx; dX++){
- sX = (dX+0.5f) * xScale - 0.5f;
- newImage.SetPixelColor(dX,dY,GetAreaColorInterpolated(sX, sY, xScale, yScale, inMethod, ofMethod,0),true);
- }//for x
- }//for y
- }//if
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid() && pxptra == 0){
- for(int32_t y=0; y<newy; y++){
- dY = (int32_t)(y * yScale);
- for(int32_t x=0; x<newx; x++){
- dX = (int32_t)(x * xScale);
- newImage.AlphaSet(x,y,AlphaGet(dX,dY));
- }
- }
- }
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- //copy new image to the destination
- if (iDst)
- iDst->Transfer(newImage);
- else
- Transfer(newImage);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Reduces the number of bits per pixel to nbit (1, 4 or 8).
- * ppal points to a valid palette for the final image; if not supplied the function will use a standard palette.
- * ppal is not necessary for reduction to 1 bpp.
- */
-bool CxImage::DecreaseBpp(uint32_t nbit, bool errordiffusion, RGBQUAD* ppal, uint32_t clrimportant)
-{
- if (!pDib) return false;
- if (head.biBitCount < nbit){
- strcpy(info.szLastError,"DecreaseBpp: target BPP greater than source BPP");
- return false;
- }
- if (head.biBitCount == nbit){
- if (clrimportant==0) return true;
- if (head.biClrImportant && (head.biClrImportant<clrimportant)) return true;
- }
-
- int32_t er,eg,eb;
- RGBQUAD c,ce;
-
- CxImage tmp;
- tmp.CopyInfo(*this);
- tmp.Create(head.biWidth,head.biHeight,(uint16_t)nbit,info.dwType);
- if (clrimportant) tmp.SetClrImportant(clrimportant);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
-#if CXIMAGE_SUPPORT_SELECTION
- tmp.SelectionCopy(*this);
-#endif //CXIMAGE_SUPPORT_SELECTION
-
-#if CXIMAGE_SUPPORT_ALPHA
- tmp.AlphaCopy(*this);
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- if (ppal) {
- if (clrimportant) {
- tmp.SetPalette(ppal,clrimportant);
- } else {
- tmp.SetPalette(ppal,1<<tmp.head.biBitCount);
- }
- } else {
- tmp.SetStdPalette();
- }
-
- for (int32_t y=0;y<head.biHeight;y++){
- if (info.nEscape) break;
- info.nProgress = (int32_t)(100*y/head.biHeight);
- for (int32_t x=0;x<head.biWidth;x++){
- if (!errordiffusion){
- tmp.BlindSetPixelColor(x,y,BlindGetPixelColor(x,y));
- } else {
- c = BlindGetPixelColor(x,y);
- tmp.BlindSetPixelColor(x,y,c);
-
- ce = tmp.BlindGetPixelColor(x,y);
- er=(int32_t)c.rgbRed - (int32_t)ce.rgbRed;
- eg=(int32_t)c.rgbGreen - (int32_t)ce.rgbGreen;
- eb=(int32_t)c.rgbBlue - (int32_t)ce.rgbBlue;
-
- c = GetPixelColor(x+1,y);
- c.rgbRed = (uint8_t)min(255L,max(0L,(int32_t)c.rgbRed + ((er*7)/16)));
- c.rgbGreen = (uint8_t)min(255L,max(0L,(int32_t)c.rgbGreen + ((eg*7)/16)));
- c.rgbBlue = (uint8_t)min(255L,max(0L,(int32_t)c.rgbBlue + ((eb*7)/16)));
- SetPixelColor(x+1,y,c);
- int32_t coeff=1;
- for(int32_t i=-1; i<2; i++){
- switch(i){
- case -1:
- coeff=2; break;
- case 0:
- coeff=4; break;
- case 1:
- coeff=1; break;
- }
- c = GetPixelColor(x+i,y+1);
- c.rgbRed = (uint8_t)min(255L,max(0L,(int32_t)c.rgbRed + ((er * coeff)/16)));
- c.rgbGreen = (uint8_t)min(255L,max(0L,(int32_t)c.rgbGreen + ((eg * coeff)/16)));
- c.rgbBlue = (uint8_t)min(255L,max(0L,(int32_t)c.rgbBlue + ((eb * coeff)/16)));
- SetPixelColor(x+i,y+1,c);
- }
- }
- }
- }
-
- Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Converts the image to B&W using the desired method :
- * - 0 = Floyd-Steinberg
- * - 1 = Ordered-Dithering (4x4)
- * - 2 = Burkes
- * - 3 = Stucki
- * - 4 = Jarvis-Judice-Ninke
- * - 5 = Sierra
- * - 6 = Stevenson-Arce
- * - 7 = Bayer (4x4 ordered dithering)
- * - 8 = Bayer (8x8 ordered dithering)
- * - 9 = Bayer (16x16 ordered dithering)
- */
-bool CxImage::Dither(int32_t method)
-{
- if (!pDib) return false;
- if (head.biBitCount == 1) return true;
-
- GrayScale();
-
- CxImage tmp;
- tmp.CopyInfo(*this);
- tmp.Create(head.biWidth, head.biHeight, 1, info.dwType);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
-#if CXIMAGE_SUPPORT_SELECTION
- tmp.SelectionCopy(*this);
-#endif //CXIMAGE_SUPPORT_SELECTION
-
-#if CXIMAGE_SUPPORT_ALPHA
- tmp.AlphaCopy(*this);
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- switch (method){
- case 1:
- {
- // Multi-Level Ordered-Dithering by Kenny Hoff (Oct. 12, 1995)
- #define dth_NumRows 4
- #define dth_NumCols 4
- #define dth_NumIntensityLevels 2
- #define dth_NumRowsLessOne (dth_NumRows-1)
- #define dth_NumColsLessOne (dth_NumCols-1)
- #define dth_RowsXCols (dth_NumRows*dth_NumCols)
- #define dth_MaxIntensityVal 255
- #define dth_MaxDitherIntensityVal (dth_NumRows*dth_NumCols*(dth_NumIntensityLevels-1))
-
- int32_t DitherMatrix[dth_NumRows][dth_NumCols] = {{0,8,2,10}, {12,4,14,6}, {3,11,1,9}, {15,7,13,5} };
-
- uint8_t Intensity[dth_NumIntensityLevels] = { 0,1 }; // 2 LEVELS B/W
- //uint8_t Intensity[NumIntensityLevels] = { 0,255 }; // 2 LEVELS
- //uint8_t Intensity[NumIntensityLevels] = { 0,127,255 }; // 3 LEVELS
- //uint8_t Intensity[NumIntensityLevels] = { 0,85,170,255 }; // 4 LEVELS
- //uint8_t Intensity[NumIntensityLevels] = { 0,63,127,191,255 }; // 5 LEVELS
- //uint8_t Intensity[NumIntensityLevels] = { 0,51,102,153,204,255 }; // 6 LEVELS
- //uint8_t Intensity[NumIntensityLevels] = { 0,42,85,127,170,213,255 }; // 7 LEVELS
- //uint8_t Intensity[NumIntensityLevels] = { 0,36,73,109,145,182,219,255 }; // 8 LEVELS
- int32_t DitherIntensity, DitherMatrixIntensity, Offset, DeviceIntensity;
- uint8_t DitherValue;
-
- for (int32_t y=0;y<head.biHeight;y++){
- info.nProgress = (int32_t)(100*y/head.biHeight);
- if (info.nEscape) break;
- for (int32_t x=0;x<head.biWidth;x++){
-
- DeviceIntensity = BlindGetPixelIndex(x,y);
- DitherIntensity = DeviceIntensity*dth_MaxDitherIntensityVal/dth_MaxIntensityVal;
- DitherMatrixIntensity = DitherIntensity % dth_RowsXCols;
- Offset = DitherIntensity / dth_RowsXCols;
- if (DitherMatrix[y&dth_NumRowsLessOne][x&dth_NumColsLessOne] < DitherMatrixIntensity)
- DitherValue = Intensity[1+Offset];
- else
- DitherValue = Intensity[0+Offset];
-
- tmp.BlindSetPixelIndex(x,y,DitherValue);
- }
- }
- break;
- }
- case 2:
- {
- //Burkes error diffusion (Thanks to Franco Gerevini)
- int32_t TotalCoeffSum = 32;
- int32_t error, nlevel, coeff=1;
- uint8_t level;
-
- for (int32_t y = 0; y < head.biHeight; y++) {
- info.nProgress = (int32_t)(100 * y / head.biHeight);
- if (info.nEscape)
- break;
- for (int32_t x = 0; x < head.biWidth; x++) {
- level = BlindGetPixelIndex(x, y);
- if (level > 128) {
- tmp.SetPixelIndex(x, y, 1);
- error = level - 255;
- } else {
- tmp.SetPixelIndex(x, y, 0);
- error = level;
- }
-
- nlevel = GetPixelIndex(x + 1, y) + (error * 8) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + 1, y, level);
- nlevel = GetPixelIndex(x + 2, y) + (error * 4) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + 2, y, level);
- int32_t i;
- for (i = -2; i < 3; i++) {
- switch (i) {
- case -2:
- coeff = 2;
- break;
- case -1:
- coeff = 4;
- break;
- case 0:
- coeff = 8;
- break;
- case 1:
- coeff = 4;
- break;
- case 2:
- coeff = 2;
- break;
- }
- nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + i, y + 1, level);
- }
- }
- }
- break;
- }
- case 3:
- {
- //Stucki error diffusion (Thanks to Franco Gerevini)
- int32_t TotalCoeffSum = 42;
- int32_t error, nlevel, coeff=1;
- uint8_t level;
-
- for (int32_t y = 0; y < head.biHeight; y++) {
- info.nProgress = (int32_t)(100 * y / head.biHeight);
- if (info.nEscape)
- break;
- for (int32_t x = 0; x < head.biWidth; x++) {
- level = BlindGetPixelIndex(x, y);
- if (level > 128) {
- tmp.SetPixelIndex(x, y, 1);
- error = level - 255;
- } else {
- tmp.SetPixelIndex(x, y, 0);
- error = level;
- }
-
- nlevel = GetPixelIndex(x + 1, y) + (error * 8) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + 1, y, level);
- nlevel = GetPixelIndex(x + 2, y) + (error * 4) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + 2, y, level);
- int32_t i;
- for (i = -2; i < 3; i++) {
- switch (i) {
- case -2:
- coeff = 2;
- break;
- case -1:
- coeff = 4;
- break;
- case 0:
- coeff = 8;
- break;
- case 1:
- coeff = 4;
- break;
- case 2:
- coeff = 2;
- break;
- }
- nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + i, y + 1, level);
- }
- for (i = -2; i < 3; i++) {
- switch (i) {
- case -2:
- coeff = 1;
- break;
- case -1:
- coeff = 2;
- break;
- case 0:
- coeff = 4;
- break;
- case 1:
- coeff = 2;
- break;
- case 2:
- coeff = 1;
- break;
- }
- nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + i, y + 2, level);
- }
- }
- }
- break;
- }
- case 4:
- {
- //Jarvis, Judice and Ninke error diffusion (Thanks to Franco Gerevini)
- int32_t TotalCoeffSum = 48;
- int32_t error, nlevel, coeff=1;
- uint8_t level;
-
- for (int32_t y = 0; y < head.biHeight; y++) {
- info.nProgress = (int32_t)(100 * y / head.biHeight);
- if (info.nEscape)
- break;
- for (int32_t x = 0; x < head.biWidth; x++) {
- level = BlindGetPixelIndex(x, y);
- if (level > 128) {
- tmp.SetPixelIndex(x, y, 1);
- error = level - 255;
- } else {
- tmp.SetPixelIndex(x, y, 0);
- error = level;
- }
-
- nlevel = GetPixelIndex(x + 1, y) + (error * 7) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + 1, y, level);
- nlevel = GetPixelIndex(x + 2, y) + (error * 5) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + 2, y, level);
- int32_t i;
- for (i = -2; i < 3; i++) {
- switch (i) {
- case -2:
- coeff = 3;
- break;
- case -1:
- coeff = 5;
- break;
- case 0:
- coeff = 7;
- break;
- case 1:
- coeff = 5;
- break;
- case 2:
- coeff = 3;
- break;
- }
- nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + i, y + 1, level);
- }
- for (i = -2; i < 3; i++) {
- switch (i) {
- case -2:
- coeff = 1;
- break;
- case -1:
- coeff = 3;
- break;
- case 0:
- coeff = 5;
- break;
- case 1:
- coeff = 3;
- break;
- case 2:
- coeff = 1;
- break;
- }
- nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + i, y + 2, level);
- }
- }
- }
- break;
- }
- case 5:
- {
- //Sierra error diffusion (Thanks to Franco Gerevini)
- int32_t TotalCoeffSum = 32;
- int32_t error, nlevel, coeff=1;
- uint8_t level;
-
- for (int32_t y = 0; y < head.biHeight; y++) {
- info.nProgress = (int32_t)(100 * y / head.biHeight);
- if (info.nEscape)
- break;
- for (int32_t x = 0; x < head.biWidth; x++) {
- level = BlindGetPixelIndex(x, y);
- if (level > 128) {
- tmp.SetPixelIndex(x, y, 1);
- error = level - 255;
- } else {
- tmp.SetPixelIndex(x, y, 0);
- error = level;
- }
-
- nlevel = GetPixelIndex(x + 1, y) + (error * 5) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + 1, y, level);
- nlevel = GetPixelIndex(x + 2, y) + (error * 3) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + 2, y, level);
- int32_t i;
- for (i = -2; i < 3; i++) {
- switch (i) {
- case -2:
- coeff = 2;
- break;
- case -1:
- coeff = 4;
- break;
- case 0:
- coeff = 5;
- break;
- case 1:
- coeff = 4;
- break;
- case 2:
- coeff = 2;
- break;
- }
- nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + i, y + 1, level);
- }
- for (i = -1; i < 2; i++) {
- switch (i) {
- case -1:
- coeff = 2;
- break;
- case 0:
- coeff = 3;
- break;
- case 1:
- coeff = 2;
- break;
- }
- nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(x + i, y + 2, level);
- }
- }
- }
- break;
- }
- case 6:
- {
- //Stevenson and Arce error diffusion (Thanks to Franco Gerevini)
- int32_t TotalCoeffSum = 200;
- int32_t error, nlevel;
- uint8_t level;
-
- for (int32_t y = 0; y < head.biHeight; y++) {
- info.nProgress = (int32_t)(100 * y / head.biHeight);
- if (info.nEscape)
- break;
- for (int32_t x = 0; x < head.biWidth; x++) {
- level = BlindGetPixelIndex(x, y);
- if (level > 128) {
- tmp.SetPixelIndex(x, y, 1);
- error = level - 255;
- } else {
- tmp.SetPixelIndex(x, y, 0);
- error = level;
- }
-
- int32_t tmp_index_x = x + 2;
- int32_t tmp_index_y = y;
- int32_t tmp_coeff = 32;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
-
- tmp_index_x = x - 3;
- tmp_index_y = y + 1;
- tmp_coeff = 12;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
-
- tmp_index_x = x - 1;
- tmp_coeff = 26;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
-
- tmp_index_x = x + 1;
- tmp_coeff = 30;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
-
- tmp_index_x = x + 3;
- tmp_coeff = 16;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
-
- tmp_index_x = x - 2;
- tmp_index_y = y + 2;
- tmp_coeff = 12;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
-
- tmp_index_x = x;
- tmp_coeff = 26;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
-
- tmp_index_x = x + 2;
- tmp_coeff = 12;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
-
- tmp_index_x = x - 3;
- tmp_index_y = y + 3;
- tmp_coeff = 5;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
-
- tmp_index_x = x - 1;
- tmp_coeff = 12;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
-
- tmp_index_x = x + 1;
- tmp_coeff = 12;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
-
- tmp_index_x = x + 3;
- tmp_coeff = 5;
- nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
- level = (uint8_t)min(255, max(0, (int32_t)nlevel));
- SetPixelIndex(tmp_index_x, tmp_index_y, level);
- }
- }
- break;
- }
- case 7:
- {
- // Bayer ordered dither
- int32_t order = 4;
- //create Bayer matrix
- if (order>4) order = 4;
- int32_t size = (1 << (2*order));
- uint8_t* Bmatrix = (uint8_t*) malloc(size * sizeof(uint8_t));
- for(int32_t i = 0; i < size; i++) {
- int32_t n = order;
- int32_t x = i / n;
- int32_t y = i % n;
- int32_t dither = 0;
- while (n-- > 0){
- dither = (((dither<<1)|((x&1) ^ (y&1)))<<1) | (y&1);
- x >>= 1;
- y >>= 1;
- }
- Bmatrix[i] = (uint8_t)(dither);
- }
-
- int32_t scale = max(0,(8-2*order));
- int32_t level;
- for (int32_t y=0;y<head.biHeight;y++){
- info.nProgress = (int32_t)(100*y/head.biHeight);
- if (info.nEscape) break;
- for (int32_t x=0;x<head.biWidth;x++){
- level = BlindGetPixelIndex(x,y) >> scale;
- if(level > Bmatrix[ (x % order) + order * (y % order) ]){
- tmp.SetPixelIndex(x,y,1);
- } else {
- tmp.SetPixelIndex(x,y,0);
- }
- }
- }
-
- free(Bmatrix);
-
- break;
- }
- case 8:
- {
- // 8x8 Bayer ordered dither
- int32_t const pattern8x8[8][8] = {
- { 0, 32, 8, 40, 2, 34, 10, 42}, /* 8x8 Bayer ordered dithering */
- {48, 16, 56, 24, 50, 18, 58, 26}, /* pattern. Each input pixel */
- {12, 44, 4, 36, 14, 46, 6, 38}, /* is scaled to the 0..63 range */
- {60, 28, 52, 20, 62, 30, 54, 22}, /* before looking in this table */
- { 3, 35, 11, 43, 1, 33, 9, 41}, /* to determine the action. */
- {51, 19, 59, 27, 49, 17, 57, 25},
- {15, 47, 7, 39, 13, 45, 5, 37},
- {63, 31, 55, 23, 61, 29, 53, 21} };
-
- for (int32_t y=0;y<head.biHeight;y++){
- info.nProgress = (int32_t)(100*y/head.biHeight);
- if (info.nEscape) break;
- for (int32_t x=0;x<head.biWidth;x++){
- int32_t level = BlindGetPixelIndex(x,y) >> 2;
- if(level && level >= pattern8x8[x & 7][y & 7]){
- tmp.SetPixelIndex(x,y,1);
- } else {
- tmp.SetPixelIndex(x,y,0);
- }
- }
- }
- break;
- }
- case 9:
- {
- // 16x16 Bayer ordered dither
- int32_t const pattern16x16[16][16] = {
- { 1,235, 59,219, 15,231, 55,215, 2,232, 56,216, 12,228, 52,212},
- { 129, 65,187,123,143, 79,183,119,130, 66,184,120,140, 76,180,116},
- { 33,193, 17,251, 47,207, 31,247, 34,194, 18,248, 44,204, 28,244},
- { 161, 97,145, 81,175,111,159, 95,162, 98,146, 82,172,108,156, 92},
- { 9,225, 49,209, 5,239, 63,223, 10,226, 50,210, 6,236, 60,220},
- { 137, 73,177,113,133, 69,191,127,138, 74,178,114,134, 70,188,124},
- { 41,201, 25,241, 37,197, 21,255, 42,202, 26,242, 38,198, 22,252},
- { 169,105,153, 89,165,101,149, 85,170,106,154, 90,166,102,150, 86},
- { 3,233, 57,217, 13,229, 53,213, 0,234, 58,218, 14,230, 54,214},
- { 131, 67,185,121,141, 77,181,117,128, 64,186,122,142, 78,182,118},
- { 35,195, 19,249, 45,205, 29,245, 32,192, 16,250, 46,206, 30,246},
- { 163, 99,147, 83,173,109,157, 93,160, 96,144, 80,174,110,158, 94},
- { 11,227, 51,211, 7,237, 61,221, 8,224, 48,208, 4,238, 62,222},
- { 139, 75,179,115,135, 71,189,125,136, 72,176,112,132, 68,190,126},
- { 43,203, 27,243, 39,199, 23,253, 40,200, 24,240, 36,196, 20,254},
- { 171,107,155, 91,167,103,151, 87,168,104,152, 88,164,100,148, 84}
- };
-
- for (int32_t y=0;y<head.biHeight;y++){
- info.nProgress = (int32_t)(100*y/head.biHeight);
- if (info.nEscape) break;
- for (int32_t x=0;x<head.biWidth;x++){
- if (BlindGetPixelIndex(x,y) > pattern16x16[x & 15][y & 15]){
- tmp.SetPixelIndex(x,y,1);
- } else {
- tmp.SetPixelIndex(x,y,0);
- }
- }
- }
- break;
- }
- default:
- {
- // Floyd-Steinberg error diffusion (Thanks to Steve McMahon)
- int32_t error,nlevel,coeff=1;
- uint8_t level;
-
- for (int32_t y=0;y<head.biHeight;y++){
- info.nProgress = (int32_t)(100*y/head.biHeight);
- if (info.nEscape) break;
- for (int32_t x=0;x<head.biWidth;x++){
-
- level = BlindGetPixelIndex(x,y);
- if (level > 128){
- tmp.SetPixelIndex(x,y,1);
- error = level-255;
- } else {
- tmp.SetPixelIndex(x,y,0);
- error = level;
- }
-
- nlevel = GetPixelIndex(x+1,y) + (error * 7)/16;
- level = (uint8_t)min(255,max(0,(int32_t)nlevel));
- SetPixelIndex(x+1,y,level);
- for(int32_t i=-1; i<2; i++){
- switch(i){
- case -1:
- coeff=3; break;
- case 0:
- coeff=5; break;
- case 1:
- coeff=1; break;
- }
- nlevel = GetPixelIndex(x+i,y+1) + (error * coeff)/16;
- level = (uint8_t)min(255,max(0,(int32_t)nlevel));
- SetPixelIndex(x+i,y+1,level);
- }
- }
- }
- }
- }
-
- tmp.SetPaletteColor(0,0,0,0);
- tmp.SetPaletteColor(1,255,255,255);
- Transfer(tmp);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * CropRotatedRectangle
- * \param topx,topy : topmost and leftmost point of the rectangle
- (topmost, and if there are 2 topmost points, the left one)
- * \param width : size of the right hand side of rect, from (topx,topy) roundwalking clockwise
- * \param height : size of the left hand side of rect, from (topx,topy) roundwalking clockwise
- * \param angle : angle of the right hand side of rect, from (topx,topy)
- * \param iDst : pointer to destination image (if 0, this image is modified)
- * \author [VATI]
- */
-bool CxImage::CropRotatedRectangle( int32_t topx, int32_t topy, int32_t width, int32_t height, float angle, CxImage* iDst)
-{
- if (!pDib) return false;
-
-
- int32_t startx,starty,endx,endy;
- double cos_angle = cos(angle/*/57.295779513082320877*/);
- double sin_angle = sin(angle/*/57.295779513082320877*/);
-
- // if there is nothing special, call the original Crop():
- if ( fabs(angle)<0.0002 )
- return Crop( topx, topy, topx+width, topy+height, iDst);
-
- startx = min(topx, topx - (int32_t)(sin_angle*(double)height));
- endx = topx + (int32_t)(cos_angle*(double)width);
- endy = topy + (int32_t)(cos_angle*(double)height + sin_angle*(double)width);
- // check: corners of the rectangle must be inside
- if ( IsInside( startx, topy )==false ||
- IsInside( endx, endy ) == false )
- return false;
-
- // first crop to bounding rectangle
- CxImage tmp(*this, true, false, true);
- // tmp.Copy(*this, true, false, true);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
- if (!tmp.Crop( startx, topy, endx, endy)){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- // the midpoint of the image now became the same as the midpoint of the rectangle
- // rotate new image with minus angle amount
- if ( false == tmp.Rotate( (float)(-angle*57.295779513082320877) ) ) // Rotate expects angle in degrees
- return false;
-
- // crop rotated image to the original selection rectangle
- endx = (tmp.head.biWidth+width)/2;
- startx = (tmp.head.biWidth-width)/2;
- starty = (tmp.head.biHeight+height)/2;
- endy = (tmp.head.biHeight-height)/2;
- if ( false == tmp.Crop( startx, starty, endx, endy ) )
- return false;
-
- if (iDst) iDst->Transfer(tmp);
- else Transfer(tmp);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::Crop(const RECT& rect, CxImage* iDst)
-{
- return Crop(rect.left, rect.top, rect.right, rect.bottom, iDst);
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::Crop(int32_t left, int32_t top, int32_t right, int32_t bottom, CxImage* iDst)
-{
- if (!pDib) return false;
-
- int32_t startx = max(0L,min(left,head.biWidth));
- int32_t endx = max(0L,min(right,head.biWidth));
- int32_t starty = head.biHeight - max(0L,min(top,head.biHeight));
- int32_t endy = head.biHeight - max(0L,min(bottom,head.biHeight));
-
- if (startx==endx || starty==endy) return false;
-
- if (startx>endx) {int32_t tmp=startx; startx=endx; endx=tmp;}
- if (starty>endy) {int32_t tmp=starty; starty=endy; endy=tmp;}
-
- CxImage tmp;
- tmp.CopyInfo(*this);
- tmp.Create(endx-startx,endy-starty,head.biBitCount,info.dwType);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- tmp.SetPalette(GetPalette(),head.biClrUsed);
- tmp.info.nBkgndIndex = info.nBkgndIndex;
- tmp.info.nBkgndColor = info.nBkgndColor;
-
- switch (head.biBitCount) {
- case 1:
- case 4:
- {
- for(int32_t y=starty, yd=0; y<endy; y++, yd++){
- info.nProgress = (int32_t)(100*(y-starty)/(endy-starty)); //<Anatoly Ivasyuk>
- for(int32_t x=startx, xd=0; x<endx; x++, xd++){
- tmp.SetPixelIndex(xd,yd,GetPixelIndex(x,y));
- }
- }
- break;
- }
- case 8:
- case 24:
- {
- int32_t linelen = tmp.head.biWidth * tmp.head.biBitCount >> 3;
- uint8_t* pDest = tmp.info.pImage;
- uint8_t* pSrc = info.pImage + starty * info.dwEffWidth + (startx*head.biBitCount >> 3);
- for(int32_t y=starty; y<endy; y++){
- info.nProgress = (int32_t)(100*(y-starty)/(endy-starty)); //<Anatoly Ivasyuk>
- memcpy(pDest,pSrc,linelen);
- pDest+=tmp.info.dwEffWidth;
- pSrc+=info.dwEffWidth;
- }
- }
- }
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()){ //<oboolo>
- tmp.AlphaCreate();
- if (!tmp.AlphaIsValid()) return false;
- uint8_t* pDest = tmp.pAlpha;
- uint8_t* pSrc = pAlpha + startx + starty*head.biWidth;
- for (int32_t y=starty; y<endy; y++){
- memcpy(pDest,pSrc,endx-startx);
- pDest+=tmp.head.biWidth;
- pSrc+=head.biWidth;
- }
- }
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- //select the destination
- if (iDst) iDst->Transfer(tmp);
- else Transfer(tmp);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * \param xgain, ygain : can be from 0 to 1.
- * \param xpivot, ypivot : is the center of the transformation.
- * \param bEnableInterpolation : if true, enables bilinear interpolation.
- * \return true if everything is ok
- */
-bool CxImage::Skew(float xgain, float ygain, int32_t xpivot, int32_t ypivot, bool bEnableInterpolation)
-{
- if (!pDib) return false;
- float nx,ny;
-
- CxImage tmp(*this);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- int32_t xmin,xmax,ymin,ymax;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- nx = x + (xgain*(y - ypivot));
- ny = y + (ygain*(x - xpivot));
-#if CXIMAGE_SUPPORT_INTERPOLATION
- if (bEnableInterpolation){
- tmp.SetPixelColor(x,y,GetPixelColorInterpolated(nx, ny, CxImage::IM_BILINEAR, CxImage::OM_BACKGROUND),true);
- } else
-#endif //CXIMAGE_SUPPORT_INTERPOLATION
- {
- if (head.biClrUsed==0){
- tmp.SetPixelColor(x,y,GetPixelColor((int32_t)nx,(int32_t)ny));
- } else {
- tmp.SetPixelIndex(x,y,GetPixelIndex((int32_t)nx,(int32_t)ny));
- }
-#if CXIMAGE_SUPPORT_ALPHA
- tmp.AlphaSet(x,y,AlphaGet((int32_t)nx,(int32_t)ny));
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- }
- }
- }
- Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Expands the borders.
- * \param left, top, right, bottom = additional dimensions, should be greater than 0.
- * \param canvascolor = border color. canvascolor.rgbReserved will set the alpha channel (if any) in the border.
- * \param iDst = pointer to destination image (if it's 0, this image is modified)
- * \return true if everything is ok
- * \author [Colin Urquhart]; changes [DP]
- */
-bool CxImage::Expand(int32_t left, int32_t top, int32_t right, int32_t bottom, RGBQUAD canvascolor, CxImage* iDst)
-{
- if (!pDib) return false;
-
- if ((left < 0) || (right < 0) || (bottom < 0) || (top < 0)) return false;
-
- int32_t newWidth = head.biWidth + left + right;
- int32_t newHeight = head.biHeight + top + bottom;
-
- right = left + head.biWidth - 1;
- top = bottom + head.biHeight - 1;
-
- CxImage tmp;
- tmp.CopyInfo(*this);
- if (!tmp.Create(newWidth, newHeight, head.biBitCount, info.dwType)){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- tmp.SetPalette(GetPalette(),head.biClrUsed);
-
- switch (head.biBitCount) {
- case 1:
- case 4:
- {
- uint8_t pixel = tmp.GetNearestIndex(canvascolor);
- for(int32_t y=0; y < newHeight; y++){
- info.nProgress = (int32_t)(100*y/newHeight);
- for(int32_t x=0; x < newWidth; x++){
- if ((y < bottom) || (y > top) || (x < left) || (x > right)) {
- tmp.SetPixelIndex(x,y, pixel);
- } else {
- tmp.SetPixelIndex(x,y,GetPixelIndex(x-left,y-bottom));
- }
- }
- }
- break;
- }
- case 8:
- case 24:
- {
- if (head.biBitCount == 8) {
- uint8_t pixel = tmp.GetNearestIndex( canvascolor);
- memset(tmp.info.pImage, pixel, + (tmp.info.dwEffWidth * newHeight));
- } else {
- for (int32_t y = 0; y < newHeight; ++y) {
- uint8_t *pDest = tmp.info.pImage + (y * tmp.info.dwEffWidth);
- for (int32_t x = 0; x < newWidth; ++x) {
- *pDest++ = canvascolor.rgbBlue;
- *pDest++ = canvascolor.rgbGreen;
- *pDest++ = canvascolor.rgbRed;
- }
- }
- }
-
- uint8_t* pDest = tmp.info.pImage + (tmp.info.dwEffWidth * bottom) + (left*(head.biBitCount >> 3));
- uint8_t* pSrc = info.pImage;
- for(int32_t y=bottom; y <= top; y++){
- info.nProgress = (int32_t)(100*y/(1 + top - bottom));
- memcpy(pDest,pSrc,(head.biBitCount >> 3) * (right - left + 1));
- pDest+=tmp.info.dwEffWidth;
- pSrc+=info.dwEffWidth;
- }
- }
- }
-
-#if CXIMAGE_SUPPORT_SELECTION
- if (SelectionIsValid()){
- if (!tmp.SelectionCreate())
- return false;
- uint8_t* pSrc = SelectionGetPointer();
- uint8_t* pDst = tmp.SelectionGetPointer(left,bottom);
- for(int32_t y=bottom; y <= top; y++){
- memcpy(pDst,pSrc, (right - left + 1));
- pSrc+=head.biWidth;
- pDst+=tmp.head.biWidth;
- }
- tmp.info.rSelectionBox.left = info.rSelectionBox.left + left;
- tmp.info.rSelectionBox.right = info.rSelectionBox.right + left;
- tmp.info.rSelectionBox.top = info.rSelectionBox.top + bottom;
- tmp.info.rSelectionBox.bottom = info.rSelectionBox.bottom + bottom;
- }
-#endif //CXIMAGE_SUPPORT_SELECTION
-
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()){
- if (!tmp.AlphaCreate())
- return false;
- tmp.AlphaSet(canvascolor.rgbReserved);
- uint8_t* pSrc = AlphaGetPointer();
- uint8_t* pDst = tmp.AlphaGetPointer(left,bottom);
- for(int32_t y=bottom; y <= top; y++){
- memcpy(pDst,pSrc, (right - left + 1));
- pSrc+=head.biWidth;
- pDst+=tmp.head.biWidth;
- }
- }
-#endif //CXIMAGE_SUPPORT_ALPHA
-
- //select the destination
- if (iDst) iDst->Transfer(tmp);
- else Transfer(tmp);
-
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImage::Expand(int32_t newx, int32_t newy, RGBQUAD canvascolor, CxImage* iDst)
-{
- //thanks to <Colin Urquhart>
-
- if (!pDib) return false;
-
- if ((newx < head.biWidth) || (newy < head.biHeight)) return false;
-
- int32_t nAddLeft = (newx - head.biWidth) / 2;
- int32_t nAddTop = (newy - head.biHeight) / 2;
-
- return Expand(nAddLeft, nAddTop, newx - (head.biWidth + nAddLeft), newy - (head.biHeight + nAddTop), canvascolor, iDst);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Resamples the image with the correct aspect ratio, and fills the borders.
- * \param newx, newy = thumbnail size.
- * \param canvascolor = border color.
- * \param iDst = pointer to destination image (if it's 0, this image is modified).
- * \return true if everything is ok.
- * \author [Colin Urquhart]
- */
-bool CxImage::Thumbnail(int32_t newx, int32_t newy, RGBQUAD canvascolor, CxImage* iDst)
-{
- if (!pDib) return false;
-
- if ((newx <= 0) || (newy <= 0)) return false;
-
- CxImage tmp(*this);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- // determine whether we need to shrink the image
- if ((head.biWidth > newx) || (head.biHeight > newy)) {
- float fScale;
- float fAspect = (float) newx / (float) newy;
- if (fAspect * head.biHeight > head.biWidth) {
- fScale = (float) newy / head.biHeight;
- } else {
- fScale = (float) newx / head.biWidth;
- }
- tmp.Resample((int32_t) (fScale * head.biWidth), (int32_t) (fScale * head.biHeight), 0);
- }
-
- // expand the frame
- tmp.Expand(newx, newy, canvascolor);
-
- //select the destination
- if (iDst) iDst->Transfer(tmp);
- else Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Perform circle_based transformations.
- * \param type - for different transformations
- * - 0 for normal (proturberant) FishEye
- * - 1 for reverse (concave) FishEye
- * - 2 for Swirle
- * - 3 for Cilinder mirror
- * - 4 for bathroom
- *
- * \param rmax - effect radius. If 0, the whole image is processed
- * \param Koeff - only for swirle
- * \author Arkadiy Olovyannikov ark(at)msun(dot)ru
- */
-bool CxImage::CircleTransform(int32_t type,int32_t rmax,float Koeff)
-{
- if (!pDib) return false;
-
- int32_t nx,ny;
- double angle,radius,rnew;
-
- CxImage tmp(*this);
- if (!tmp.IsValid()){
- strcpy(info.szLastError,tmp.GetLastError());
- return false;
- }
-
- int32_t xmin,xmax,ymin,ymax,xmid,ymid;
- if (pSelection){
- xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
- ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
- } else {
- xmin = ymin = 0;
- xmax = head.biWidth; ymax=head.biHeight;
- }
-
- xmid = (int32_t) (tmp.GetWidth()/2);
- ymid = (int32_t) (tmp.GetHeight()/2);
-
- if (!rmax) rmax=(int32_t)sqrt((float)((xmid-xmin)*(xmid-xmin)+(ymid-ymin)*(ymid-ymin)));
- if (Koeff==0.0f) Koeff=1.0f;
-
- for(int32_t y=ymin; y<ymax; y++){
- info.nProgress = (int32_t)(100*(y-ymin)/(ymax-ymin));
- if (info.nEscape) break;
- for(int32_t x=xmin; x<xmax; x++){
-#if CXIMAGE_SUPPORT_SELECTION
- if (BlindSelectionIsInside(x,y))
-#endif //CXIMAGE_SUPPORT_SELECTION
- {
- nx=xmid-x;
- ny=ymid-y;
- radius=sqrt((float)(nx*nx+ny*ny));
- if (radius<rmax) {
- angle=atan2((double)ny,(double)nx);
- if (type==0) rnew=radius*radius/rmax;
- else if (type==1) rnew=sqrt(radius*rmax);
- else if (type==2) {rnew=radius;angle += radius / Koeff;}
- else rnew = 1; // potentially uninitialized
- if (type<3){
- nx = xmid + (int32_t)(rnew * cos(angle));
- ny = ymid - (int32_t)(rnew * sin(angle));
- }
- else if (type==3){
- nx = (int32_t)fabs((angle*xmax/6.2831852));
- ny = (int32_t)fabs((radius*ymax/rmax));
- }
- else {
- nx=x+(x%32)-16;
- ny=y;
- }
-// nx=max(xmin,min(nx,xmax));
-// ny=max(ymin,min(ny,ymax));
- }
- else { nx=-1;ny=-1;}
- if (head.biClrUsed==0){
- tmp.SetPixelColor(x,y,GetPixelColor(nx,ny));
- } else {
- tmp.SetPixelIndex(x,y,GetPixelIndex(nx,ny));
- }
-#if CXIMAGE_SUPPORT_ALPHA
- tmp.AlphaSet(x,y,AlphaGet(nx,ny));
-#endif //CXIMAGE_SUPPORT_ALPHA
- }
- }
- }
- Transfer(tmp);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Faster way to almost properly shrink image. Algorithm produces results comparable with "high resoultion shrink"
- * when resulting image is much smaller (that would be 3 times or more) than original. When
- * resulting image is only slightly smaller, results are closer to nearest pixel.
- * This algorithm works by averaging, but it does not calculate fractions of pixels. It adds whole
- * source pixels to the best destionation. It is not geometrically "correct".
- * It's main advantage over "high" resulution shrink is speed, so it's useful, when speed is most
- * important (preview thumbnails, "map" view, ...).
- * Method is optimized for RGB24 images.
- *
- * \param newx, newy - size of destination image (must be smaller than original!)
- * \param iDst - pointer to destination image (if it's 0, this image is modified)
- * \param bChangeBpp - flag points to change result image bpp (if it's true, this result image bpp = 24 (useful for B/W image thumbnails))
- *
- * \return true if everything is ok
- * \author [bd], 9.2004; changes [Artiom Mirolubov], 1.2005
- */
-bool CxImage::QIShrink(int32_t newx, int32_t newy, CxImage* const iDst, bool bChangeBpp)
-{
- if (!pDib) return false;
-
- if (newx>head.biWidth || newy>head.biHeight) {
- //let me repeat... this method can't enlarge image
- strcpy(info.szLastError,"QIShrink can't enlarge image");
- return false;
- }
-
- if (newx==head.biWidth && newy==head.biHeight) {
- //image already correct size (just copy and return)
- if (iDst) iDst->Copy(*this);
- return true;
- }//if
-
- //create temporary destination image
- CxImage newImage;
- newImage.CopyInfo(*this);
- newImage.Create(newx,newy,(bChangeBpp)?24:head.biBitCount,GetType());
- newImage.SetPalette(GetPalette());
- if (!newImage.IsValid()){
- strcpy(info.szLastError,newImage.GetLastError());
- return false;
- }
-
- //and alpha channel if required
-#if CXIMAGE_SUPPORT_ALPHA
- if (AlphaIsValid()) newImage.AlphaCreate();
-#endif
-
- const int32_t oldx = head.biWidth;
- const int32_t oldy = head.biHeight;
-
- int32_t accuCellSize = 4;
-#if CXIMAGE_SUPPORT_ALPHA
- uint8_t *alphaPtr;
- if (AlphaIsValid()) accuCellSize=5;
-#endif
-
- uint32_t *accu = new uint32_t[newx*accuCellSize]; //array for suming pixels... one pixel for every destination column
- uint32_t *accuPtr; //pointer for walking through accu
- //each cell consists of blue, red, green component and count of pixels summed in this cell
- memset(accu, 0, newx * accuCellSize * sizeof(uint32_t)); //clear accu
-
- if (!IsIndexed()) {
- //RGB24 version with pointers
- uint8_t *destPtr, *srcPtr, *destPtrS, *srcPtrS; //destination and source pixel, and beginnings of current row
- srcPtrS=(uint8_t*)BlindGetPixelPointer(0,0);
- destPtrS=(uint8_t*)newImage.BlindGetPixelPointer(0,0);
- int32_t ex=0, ey=0; //ex and ey replace division...
- int32_t dy=0;
- //(we just add pixels, until by adding newx or newy we get a number greater than old size... then
- // it's time to move to next pixel)
-
- for(int32_t y=0; y<oldy; y++){ //for all source rows
- info.nProgress = (int32_t)(100*y/oldy); if (info.nEscape) break;
- ey += newy;
- ex = 0; //restart with ex = 0
- accuPtr=accu; //restart from beginning of accu
- srcPtr=srcPtrS; //and from new source line
-#if CXIMAGE_SUPPORT_ALPHA
- alphaPtr = AlphaGetPointer(0, y);
-#endif
-
- for(int32_t x=0; x<oldx; x++){ //for all source columns
- ex += newx;
- *accuPtr += *(srcPtr++); //add current pixel to current accu slot
- *(accuPtr+1) += *(srcPtr++);
- *(accuPtr+2) += *(srcPtr++);
- (*(accuPtr+3)) ++;
-#if CXIMAGE_SUPPORT_ALPHA
- if (alphaPtr) *(accuPtr+4) += *(alphaPtr++);
-#endif
- if (ex>oldx) { //when we reach oldx, it's time to move to new slot
- accuPtr += accuCellSize;
- ex -= oldx; //(substract oldx from ex and resume from there on)
- }//if (ex overflow)
- }//for x
-
- if (ey>=oldy) { //now when this happens
- ey -= oldy; //it's time to move to new destination row
- destPtr = destPtrS; //reset pointers to proper initial values
- accuPtr = accu;
-#if CXIMAGE_SUPPORT_ALPHA
- alphaPtr = newImage.AlphaGetPointer(0, dy++);
-#endif
- for (int32_t k=0; k<newx; k++) { //copy accu to destination row (divided by number of pixels in each slot)
- *(destPtr++) = (uint8_t)(*(accuPtr) / *(accuPtr+3));
- *(destPtr++) = (uint8_t)(*(accuPtr+1) / *(accuPtr+3));
- *(destPtr++) = (uint8_t)(*(accuPtr+2) / *(accuPtr+3));
-#if CXIMAGE_SUPPORT_ALPHA
- if (alphaPtr) *(alphaPtr++) = (uint8_t)(*(accuPtr+4) / *(accuPtr+3));
-#endif
- accuPtr += accuCellSize;
- }//for k
- memset(accu, 0, newx * accuCellSize * sizeof(uint32_t)); //clear accu
- destPtrS += newImage.info.dwEffWidth;
- }//if (ey overflow)
-
- srcPtrS += info.dwEffWidth; //next round we start from new source row
- }//for y
- } else {
- //standard version with GetPixelColor...
- int32_t ex=0, ey=0; //ex and ey replace division...
- int32_t dy=0;
- //(we just add pixels, until by adding newx or newy we get a number greater than old size... then
- // it's time to move to next pixel)
- RGBQUAD rgb;
-
- for(int32_t y=0; y<oldy; y++){ //for all source rows
- info.nProgress = (int32_t)(100*y/oldy); if (info.nEscape) break;
- ey += newy;
- ex = 0; //restart with ex = 0
- accuPtr=accu; //restart from beginning of accu
- for(int32_t x=0; x<oldx; x++){ //for all source columns
- ex += newx;
- rgb = GetPixelColor(x, y, true);
- *accuPtr += rgb.rgbBlue; //add current pixel to current accu slot
- *(accuPtr+1) += rgb.rgbRed;
- *(accuPtr+2) += rgb.rgbGreen;
- (*(accuPtr+3)) ++;
-#if CXIMAGE_SUPPORT_ALPHA
- if (pAlpha) *(accuPtr+4) += rgb.rgbReserved;
-#endif
- if (ex>oldx) { //when we reach oldx, it's time to move to new slot
- accuPtr += accuCellSize;
- ex -= oldx; //(substract oldx from ex and resume from there on)
- }//if (ex overflow)
- }//for x
-
- if (ey>=oldy) { //now when this happens
- ey -= oldy; //it's time to move to new destination row
- accuPtr = accu;
- for (int32_t dx=0; dx<newx; dx++) { //copy accu to destination row (divided by number of pixels in each slot)
- rgb.rgbBlue = (uint8_t)(*(accuPtr) / *(accuPtr+3));
- rgb.rgbRed = (uint8_t)(*(accuPtr+1) / *(accuPtr+3));
- rgb.rgbGreen= (uint8_t)(*(accuPtr+2) / *(accuPtr+3));
-#if CXIMAGE_SUPPORT_ALPHA
- if (pAlpha) rgb.rgbReserved = (uint8_t)(*(accuPtr+4) / *(accuPtr+3));
-#endif
- newImage.SetPixelColor(dx, dy, rgb, pAlpha!=0);
- accuPtr += accuCellSize;
- }//for dx
- memset(accu, 0, newx * accuCellSize * sizeof(uint32_t)); //clear accu
- dy++;
- }//if (ey overflow)
- }//for y
- }//if
-
- delete [] accu; //delete helper array
-
- //copy new image to the destination
- if (iDst)
- iDst->Transfer(newImage);
- else
- Transfer(newImage);
- return true;
-
-}
-
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_TRANSFORMATION
diff --git a/smelt/sdl/CxImage/ximawbmp.cpp b/smelt/sdl/CxImage/ximawbmp.cpp deleted file mode 100644 index 7ba5d00..0000000 --- a/smelt/sdl/CxImage/ximawbmp.cpp +++ /dev/null @@ -1,134 +0,0 @@ -/*
- * File: ximawbmp.cpp
- * Purpose: Platform Independent WBMP Image Class Loader and Writer
- * 12/Jul/2002 Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximawbmp.h"
-
-#if CXIMAGE_SUPPORT_WBMP
-
-#include "ximaiter.h"
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageWBMP::Decode(CxFile *hFile)
-{
- if (hFile == NULL) return false;
-
- WBMPHEADER wbmpHead;
-
- cx_try
- {
- ReadOctet(hFile, &wbmpHead.Type);
-
- uint32_t dat;
- ReadOctet(hFile, &dat);
- wbmpHead.FixHeader = (uint8_t)dat;
-
- ReadOctet(hFile, &wbmpHead.ImageWidth);
- ReadOctet(hFile, &wbmpHead.ImageHeight);
-
- if (hFile->Eof())
- cx_throw("Not a WBMP");
-
- if (wbmpHead.Type != 0)
- cx_throw("Unsupported WBMP type");
-
- head.biWidth = wbmpHead.ImageWidth;
- head.biHeight= wbmpHead.ImageHeight;
-
- if (head.biWidth<=0 || head.biHeight<=0)
- cx_throw("Corrupted WBMP");
-
- if (info.nEscape == -1){
- info.dwType = CXIMAGE_FORMAT_WBMP;
- return true;
- }
-
- Create(head.biWidth, head.biHeight, 1, CXIMAGE_FORMAT_WBMP);
- if (!IsValid()) cx_throw("WBMP Create failed");
- SetGrayPalette();
-
- int32_t linewidth=(head.biWidth+7)/8;
- CImageIterator iter(this);
- iter.Upset();
- for (int32_t y=0; y < head.biHeight; y++){
- hFile->Read(iter.GetRow(),linewidth,1);
- iter.PrevRow();
- }
-
- } cx_catch {
- if (strcmp(message,"")) strncpy(info.szLastError,message,255);
- return FALSE;
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageWBMP::ReadOctet(CxFile * hFile, uint32_t *data)
-{
- uint8_t c;
- *data = 0;
- do {
- if (hFile->Eof()) return false;
- c = (uint8_t)hFile->GetC();
- *data <<= 7;
- *data |= (c & 0x7F);
- } while ((c&0x80)!=0);
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageWBMP::Encode(CxFile * hFile)
-{
- if (EncodeSafeCheck(hFile)) return false;
-
- //check format limits
- if (head.biBitCount!=1){
- strcpy(info.szLastError,"Can't save this image as WBMP");
- return false;
- }
-
- WBMPHEADER wbmpHead;
- wbmpHead.Type=0;
- wbmpHead.FixHeader=0;
- wbmpHead.ImageWidth=head.biWidth;
- wbmpHead.ImageHeight=head.biHeight;
-
- // Write the file header
- hFile->PutC('\0');
- hFile->PutC('\0');
- WriteOctet(hFile,wbmpHead.ImageWidth);
- WriteOctet(hFile,wbmpHead.ImageHeight);
- // Write the pixels
- int32_t linewidth=(wbmpHead.ImageWidth+7)/8;
- CImageIterator iter(this);
- iter.Upset();
- for (uint32_t y=0; y < wbmpHead.ImageHeight; y++){
- hFile->Write(iter.GetRow(),linewidth,1);
- iter.PrevRow();
- }
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageWBMP::WriteOctet(CxFile * hFile, const uint32_t data)
-{
- int32_t ns = 0;
- while (data>>(ns+7)) ns+=7;
- while (ns>0){
- if (!hFile->PutC(0x80 | (uint8_t)(data>>ns))) return false;
- ns-=7;
- }
- if (!(hFile->PutC((uint8_t)(0x7F & data)))) return false;
- return true;
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_ENCODE
-////////////////////////////////////////////////////////////////////////////////
-#endif // CXIMAGE_SUPPORT_WBMP
-
diff --git a/smelt/sdl/CxImage/ximawbmp.h b/smelt/sdl/CxImage/ximawbmp.h deleted file mode 100644 index 9a7837e..0000000 --- a/smelt/sdl/CxImage/ximawbmp.h +++ /dev/null @@ -1,49 +0,0 @@ -/*
- * File: ximawbmp.h
- * Purpose: WBMP Image Class Loader and Writer
- */
-/* ==========================================================
- * CxImageWBMP (c) 12/Jul/2002 Davide Pizzolato - www.xdp.it
- * For conditions of distribution and use, see copyright notice in ximage.h
- * ==========================================================
- */
-#if !defined(__ximaWBMP_h)
-#define __ximaWBMP_h
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_WBMP
-
-class CxImageWBMP: public CxImage
-{
-#pragma pack(1)
-typedef struct tagWbmpHeader
-{
- uint32_t Type; // 0
- uint8_t FixHeader; // 0
- uint32_t ImageWidth; // Image Width
- uint32_t ImageHeight; // Image Height
-} WBMPHEADER;
-#pragma pack()
-public:
- CxImageWBMP(): CxImage(CXIMAGE_FORMAT_WBMP) {}
-
-// bool Load(const TCHAR * imageFileName){ return CxImage::Load(imageFileName,CXIMAGE_FORMAT_WBMP);}
-// bool Save(const TCHAR * imageFileName){ return CxImage::Save(imageFileName,CXIMAGE_FORMAT_WBMP);}
- bool Decode(CxFile * hFile);
- bool Decode(FILE *hFile) { CxIOFile file(hFile); return Decode(&file); }
-protected:
- bool ReadOctet(CxFile * hFile, uint32_t *data);
-
-public:
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
-protected:
- bool WriteOctet(CxFile * hFile, const uint32_t data);
-#endif // CXIMAGE_SUPPORT_ENCODE
-};
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximawmf.cpp b/smelt/sdl/CxImage/ximawmf.cpp deleted file mode 100644 index a1057f5..0000000 --- a/smelt/sdl/CxImage/ximawmf.cpp +++ /dev/null @@ -1,483 +0,0 @@ -/*
-*********************************************************************
- * File: ximawmf.cpp
- * Purpose: Windows Metafile Class Loader and Writer
- * Author: Volker Horch - vhorch@gmx.de
- * created: 13-Jun-2002
- *
- * Note: If the code below works, i wrote it.
- * If it doesn't work, i don't know who wrote it.
-*********************************************************************
- */
-
-/*
-*********************************************************************
- Note by Author:
-*********************************************************************
-
- Metafile Formats:
- =================
-
- There are 2 kinds of Windows Metafiles:
- - Standard Windows Metafile
- - Placeable Windows Metafile
-
- A StandardWindows Metafile looks like:
- - Metafile Header (MEATAHEADER)
- - Metafile Records
-
- A Placeable Metafile looks like:
- - Aldus Header (METAFILEHEADER)
- - Metafile Header (METAHEADER)
- - Metafile Records
-
- The "Metafile Header" and the "Metafile Records" are the same
- for both formats. However, the Standard Metafile does not contain any
- information about the original dimensions or x/y ratio of the Metafile.
-
- I decided, to allow only placeable Metafiles here. If you also want to
- enable Standard Metafiles, you will have to guess the dimensions of
- the image.
-
-*********************************************************************
- Limitations: see ximawmf.h
- you may configure some stuff there
-*********************************************************************
-*/
-
-#include "ximawmf.h"
-
-#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-bool CxImageWMF::Decode(CxFile *hFile, int32_t nForceWidth, int32_t nForceHeight)
-{
- if (hFile == NULL) return false;
-
- HENHMETAFILE hMeta;
- HDC hDC;
- int32_t cx,cy;
-
- //save the current position of the file
- int32_t pos = hFile->Tell();
-
- // Read the Metafile and convert to an Enhanced Metafile
- METAFILEHEADER mfh;
- hMeta = ConvertWmfFiletoEmf(hFile, &mfh);
- if (hMeta) { // ok, it's a WMF
-
-/////////////////////////////////////////////////////////////////////
-// We use the original WMF size information, because conversion to
-// EMF adjusts the Metafile to Full Screen or does not set rclBounds at all
-// ENHMETAHEADER emh;
-// uint32_t uRet;
-// uRet = GetEnhMetaFileHeader(hMeta, // handle of enhanced metafile
-// sizeof(ENHMETAHEADER), // size of buffer, in bytes
-// &emh); // address of buffer to receive data
-// if (!uRet){
-// DeleteEnhMetaFile(hMeta);
-// return false;
-// }
-// // calculate size
-// cx = emh.rclBounds.right - emh.rclBounds.left;
-// cy = emh.rclBounds.bottom - emh.rclBounds.top;
-/////////////////////////////////////////////////////////////////////
-
- // calculate size
- // scale the metafile (pixels/inch of metafile => pixels/inch of display)
- // mfh.inch already checked to be <> 0
-
- hDC = ::GetDC(0);
- int32_t cx1 = ::GetDeviceCaps(hDC, LOGPIXELSX);
- int32_t cy1 = ::GetDeviceCaps(hDC, LOGPIXELSY);
- ::ReleaseDC(0, hDC);
-
- cx = (mfh.inch/2 + (mfh.bbox.right - mfh.bbox.left) * cx1) / mfh.inch;
- cy = (mfh.inch/2 + (mfh.bbox.bottom - mfh.bbox.top) * cy1) / mfh.inch;
-
- } else { // maybe it's an EMF...
-
- hFile->Seek(pos,SEEK_SET);
-
- ENHMETAHEADER emh;
- hMeta = ConvertEmfFiletoEmf(hFile, &emh);
-
- if (!hMeta){
- strcpy(info.szLastError,"corrupted WMF");
- return false; // definitively give up
- }
-
- // ok, it's an EMF; calculate canvas size
- cx = emh.rclBounds.right - emh.rclBounds.left;
- cy = emh.rclBounds.bottom - emh.rclBounds.top;
-
- // alternative methods, sometime not so reliable... [DP]
- //cx = emh.szlDevice.cx;
- //cy = emh.szlDevice.cy;
- //
- //hDC = ::GetDC(0);
- //float hscale = (float)GetDeviceCaps(hDC, HORZRES)/(100.0f * GetDeviceCaps(hDC, HORZSIZE));
- //float vscale = (float)GetDeviceCaps(hDC, VERTRES)/(100.0f * GetDeviceCaps(hDC, VERTSIZE));
- //::ReleaseDC(0, hDC);
- //cx = (int32_t)((emh.rclFrame.right - emh.rclFrame.left) * hscale);
- //cy = (int32_t)((emh.rclFrame.bottom - emh.rclFrame.top) * vscale);
- }
-
- if (info.nEscape == -1) { // Check if cancelled
- head.biWidth = cx;
- head.biHeight= cy;
- info.dwType = CXIMAGE_FORMAT_WMF;
- DeleteEnhMetaFile(hMeta);
- strcpy(info.szLastError,"output dimensions returned");
- return true;
- }
-
- if (!cx || !cy) {
- DeleteEnhMetaFile(hMeta);
- strcpy(info.szLastError,"empty WMF");
- return false;
- }
-
- if (nForceWidth) cx=nForceWidth;
- if (nForceHeight) cy=nForceHeight;
- ShrinkMetafile(cx, cy); // !! Otherwise Bitmap may have bombastic size
-
- HDC hDC0 = ::GetDC(0); // DC of screen
- HBITMAP hBitmap = CreateCompatibleBitmap(hDC0, cx, cy); // has # colors of display
- hDC = CreateCompatibleDC(hDC0); // memory dc compatible with screen
- ::ReleaseDC(0, hDC0); // don't need anymore. get rid of it.
-
- if (hDC){
- if (hBitmap){
- RECT rc = {0,0,cx,cy};
- int32_t bpp = ::GetDeviceCaps(hDC, BITSPIXEL);
-
- HBITMAP hBitmapOld = (HBITMAP)SelectObject(hDC, hBitmap);
-
- // clear out the entire bitmap with windows background
- // because the MetaFile may not contain background information
- uint32_t dwBack = XMF_COLOR_BACK;
-#if XMF_SUPPORT_TRANSPARENCY
- if (bpp == 24) dwBack = XMF_COLOR_TRANSPARENT;
-#endif
- uint32_t OldColor = SetBkColor(hDC, dwBack);
- ExtTextOut(hDC, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
- SetBkColor(hDC, OldColor);
-
- //retrieves optional palette entries from the specified enhanced metafile
- PLOGPALETTE plogPal;
- PBYTE pjTmp;
- HPALETTE hPal;
- int32_t iEntries = GetEnhMetaFilePaletteEntries(hMeta, 0, NULL);
- if (iEntries) {
- if ((plogPal = (PLOGPALETTE)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT,
- sizeof(uint32_t) + sizeof(PALETTEENTRY)*iEntries )) == NULL) {
- DeleteObject(hBitmap);
- DeleteDC(hDC);
- DeleteEnhMetaFile(hMeta);
- strcpy(info.szLastError,"Cancelled");
- return false;
- }
-
- plogPal->palVersion = 0x300;
- plogPal->palNumEntries = (uint16_t) iEntries;
- pjTmp = (PBYTE) plogPal;
- pjTmp += 4;
-
- GetEnhMetaFilePaletteEntries(hMeta, iEntries, (PPALETTEENTRY)pjTmp);
- hPal = CreatePalette(plogPal);
- GlobalFree(plogPal);
-
- SelectPalette(hDC, hPal, FALSE);
- RealizePalette(hDC);
- }
-
- // Play the Metafile into Memory DC
- BOOL bRet = PlayEnhMetaFile(hDC, // handle to a device context
- hMeta, // handle to an enhanced metafile
- &rc); // pointer to bounding rectangle
-
- SelectObject(hDC, hBitmapOld);
- DeleteEnhMetaFile(hMeta); // we are done with this one
-
- if (info.nEscape) { // Check if cancelled
- DeleteObject(hBitmap);
- DeleteDC(hDC);
- strcpy(info.szLastError,"Cancelled");
- return false;
- }
-
- // the Bitmap now has the image.
- // Create our DIB and convert the DDB into DIB
- if (!Create(cx, cy, bpp, CXIMAGE_FORMAT_WMF)) {
- DeleteObject(hBitmap);
- DeleteDC(hDC);
- return false;
- }
-
-#if XMF_SUPPORT_TRANSPARENCY
- if (bpp == 24) {
- RGBQUAD rgbTrans = { XMF_RGBQUAD_TRANSPARENT };
- SetTransColor(rgbTrans);
- }
-#endif
- // We're finally ready to get the DIB. Call the driver and let
- // it party on our bitmap. It will fill in the color table,
- // and bitmap bits of our global memory block.
- bRet = GetDIBits(hDC, hBitmap, 0,
- (uint32_t)cy, GetBits(), (LPBITMAPINFO)pDib, DIB_RGB_COLORS);
-
- DeleteObject(hBitmap);
- DeleteDC(hDC);
-
- return (bRet!=0);
- } else {
- DeleteDC(hDC);
- }
- } else {
- if (hBitmap) DeleteObject(hBitmap);
- }
-
- DeleteEnhMetaFile(hMeta);
-
- return false;
-}
-
-/**********************************************************************
- Function: CheckMetafileHeader
- Purpose: Check if the Metafileheader of a file is valid
-**********************************************************************/
-BOOL CxImageWMF::CheckMetafileHeader(METAFILEHEADER *metafileheader)
-{
- uint16_t *pw;
- uint16_t cs;
- int32_t i;
-
- // check magic #
- if (metafileheader->key != 0x9ac6cdd7L) return false;
-
- // test checksum of header
- pw = (uint16_t *)metafileheader;
- cs = *pw;
- pw++;
- for (i = 0; i < 9; i++) {
- cs ^= *pw;
- pw++;
- }
-
- if (cs != metafileheader->checksum) return false;
-
- // check resolution
- if ((metafileheader->inch <= 0) || (metafileheader->inch > 2540)) return false;
-
- return true;
-}
-
-/**********************************************************************
- Function: ConvertWmfFiletoEmf
- Purpose: Converts a Windows Metafile into an Enhanced Metafile
-**********************************************************************/
-HENHMETAFILE CxImageWMF::ConvertWmfFiletoEmf(CxFile *fp, METAFILEHEADER *metafileheader)
-{
- HENHMETAFILE hMeta;
- uint32_t lenFile;
- uint32_t len;
- uint8_t *p;
- METAHEADER mfHeader;
- uint32_t seekpos;
-
- hMeta = 0;
-
- // get length of the file
- lenFile = fp->Size();
-
- // a placeable metafile starts with a METAFILEHEADER
- // read it and check metafileheader
- len = fp->Read(metafileheader, 1, sizeof(METAFILEHEADER));
- if (len < sizeof(METAFILEHEADER)) return (hMeta);
-
- if (CheckMetafileHeader(metafileheader)) {
- // This is a placeable metafile
- // Convert the placeable format into something that can
- // be used with GDI metafile functions
- seekpos = sizeof(METAFILEHEADER);
- } else {
- // Not a placeable wmf. A windows metafile?
- // at least not scaleable.
- // we could try to convert, but would loose ratio. don't allow this
- return (hMeta);
-
- //metafileheader->bbox.right = ?;
- //metafileheader->bbox.left = ?;
- //metafileheader->bbox.bottom = ?;
- //metafileheader->bbox.top = ?;
- //metafileheader->inch = ?;
- //
- //seekpos = 0;
- // fp->Seek(0, SEEK_SET); // rewind
- }
-
- // At this point we have a metaheader regardless of whether
- // the metafile was a windows metafile or a placeable metafile
- // so check to see if it is valid. There is really no good
- // way to do this so just make sure that the mtType is either
- // 1 or 2 (memory or disk file)
- // in addition we compare the length of the METAHEADER against
- // the length of the file. if filelength < len => no Metafile
-
- len = fp->Read(&mfHeader, 1, sizeof(METAHEADER));
- if (len < sizeof(METAHEADER)) return (hMeta);
-
- if ((mfHeader.mtType != 1) && (mfHeader.mtType != 2)) return (hMeta);
-
- // Length in Bytes from METAHEADER
- len = mfHeader.mtSize * 2;
- if (len > lenFile) return (hMeta);
-
- // Allocate memory for the metafile bits
- p = (uint8_t *)malloc(len);
- if (!p) return (hMeta);
-
- // seek back to METAHEADER and read all the stuff at once
- fp->Seek(seekpos, SEEK_SET);
- lenFile = fp->Read(p, 1, len);
- if (lenFile != len) {
- free(p);
- return (hMeta);
- }
-
- // the following (commented code) works, but adjusts rclBound of the
- // Enhanced Metafile to full screen.
- // the METAFILEHEADER from above is needed to scale the image
-
-// hMeta = SetWinMetaFileBits(len, p, NULL, NULL);
-
- // scale the metafile (pixels/inch of metafile => pixels/inch of display)
-
- METAFILEPICT mfp;
- int32_t cx1, cy1;
- HDC hDC;
-
- hDC = ::GetDC(0);
- cx1 = ::GetDeviceCaps(hDC, LOGPIXELSX);
- cy1 = ::GetDeviceCaps(hDC, LOGPIXELSY);
-
- memset(&mfp, 0, sizeof(mfp));
-
- mfp.mm = MM_ANISOTROPIC;
- mfp.xExt = 10000; //(metafileheader->bbox.right - metafileheader->bbox.left) * cx1 / metafileheader->inch;
- mfp.yExt = 10000; //(metafileheader->bbox.bottom - metafileheader->bbox.top) * cy1 / metafileheader->inch;
- mfp.hMF = 0;
-
- // in MM_ANISOTROPIC mode xExt and yExt are in MM_HIENGLISH
- // MM_HIENGLISH means: Each logical unit is converted to 0.001 inch
- //mfp.xExt *= 1000;
- //mfp.yExt *= 1000;
- // ????
- //int32_t k = 332800 / ::GetSystemMetrics(SM_CXSCREEN);
- //mfp.xExt *= k; mfp.yExt *= k;
-
- // fix for Win9x
- while ((mfp.xExt < 6554) && (mfp.yExt < 6554))
- {
- mfp.xExt *= 10;
- mfp.yExt *= 10;
- }
-
- hMeta = SetWinMetaFileBits(len, p, hDC, &mfp);
-
- if (!hMeta){ //try 2nd conversion using a different mapping
- mfp.mm = MM_TEXT;
- hMeta = SetWinMetaFileBits(len, p, hDC, &mfp);
- }
-
- ::ReleaseDC(0, hDC);
-
- // Free Memory
- free(p);
-
- return (hMeta);
-}
-/////////////////////////////////////////////////////////////////////
-HENHMETAFILE CxImageWMF::ConvertEmfFiletoEmf(CxFile *pFile, ENHMETAHEADER *pemfh)
-{
- HENHMETAFILE hMeta;
- int32_t iLen = pFile->Size();
-
- // Check the header first: <km>
- int32_t pos = pFile->Tell();
- int32_t iLenRead = pFile->Read(pemfh, 1, sizeof(ENHMETAHEADER));
- if (iLenRead < sizeof(ENHMETAHEADER)) return NULL;
- if (pemfh->iType != EMR_HEADER) return NULL;
- if (pemfh->dSignature != ENHMETA_SIGNATURE) return NULL;
- //if (pemfh->nBytes != (uint32_t)iLen) return NULL;
- pFile->Seek(pos,SEEK_SET);
-
- uint8_t* pBuff = (uint8_t *)malloc(iLen);
- if (!pBuff) return (FALSE);
-
- // Read the Enhanced Metafile
- iLenRead = pFile->Read(pBuff, 1, iLen);
- if (iLenRead != iLen) {
- free(pBuff);
- return NULL;
- }
-
- // Make it a Memory Metafile
- hMeta = SetEnhMetaFileBits(iLen, pBuff);
-
- free(pBuff); // finished with this one
-
- if (!hMeta) return NULL; // oops.
-
- // Get the Enhanced Metafile Header
- uint32_t uRet = GetEnhMetaFileHeader(hMeta, // handle of enhanced metafile
- sizeof(ENHMETAHEADER), // size of buffer, in bytes
- pemfh); // address of buffer to receive data
-
- if (!uRet) {
- DeleteEnhMetaFile(hMeta);
- return NULL;
- }
-
- return (hMeta);
-}
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_DECODE
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_ENCODE
-/////////////////////////////////////////////////////////////////////
-bool CxImageWMF::Encode(CxFile * hFile)
-{
- if (hFile == NULL) return false;
- strcpy(info.szLastError, "Save WMF not supported");
- return false;
-}
-#endif // CXIMAGE_SUPPORT_ENCODE
-/////////////////////////////////////////////////////////////////////
-
-/**********************************************************************
-Function: ShrinkMetafile
-Purpose: Shrink the size of a metafile to be not larger than
- the definition
-**********************************************************************/
-void CxImageWMF::ShrinkMetafile(int32_t &cx, int32_t &cy)
-{
- int32_t xScreen = XMF_MAXSIZE_CX;
- int32_t yScreen = XMF_MAXSIZE_CY;
-
- if (cx > xScreen){
- cy = cy * xScreen / cx;
- cx = xScreen;
- }
-
- if (cy > yScreen){
- cx = cx * yScreen / cy;
- cy = yScreen;
- }
-}
-
-#endif // CIMAGE_SUPPORT_WMF
-
diff --git a/smelt/sdl/CxImage/ximawmf.h b/smelt/sdl/CxImage/ximawmf.h deleted file mode 100644 index 94fb168..0000000 --- a/smelt/sdl/CxImage/ximawmf.h +++ /dev/null @@ -1,154 +0,0 @@ -/*
-*********************************************************************
- * File: ximawmf.h
- * Purpose: Windows Metafile Class Loader and Writer
- * Author: Volker Horch - vhorch@gmx.de
- * created: 13-Jun-2002
-*********************************************************************
- */
-
-/*
-*********************************************************************
- Notes by Author:
-*********************************************************************
-
- Limitations:
- ============
-
- a) Transparency:
-
- A Metafile is vector graphics, which has transparency by design.
- This class always converts into a Bitmap format. Transparency is
- supported, but there is no good way to find out, which parts
- of the Metafile are transparent. There are two ways how we can
- handle this:
-
- - Clear the Background of the Bitmap with the background color
- you like (i have used COLOR_WINDOW) and don't support transparency.
-
- below #define XMF_SUPPORT_TRANSPARENCY 0
- #define XMF_COLOR_BACK RGB(Background color you like)
-
- - Clear the Background of the Bitmap with a very unusual color
- (which one ?) and use this color as the transparent color
-
- below #define XMF_SUPPORT_TRANSPARENCY 1
- #define XMF_COLOR_TRANSPARENT_R ...
- #define XMF_COLOR_TRANSPARENT_G ...
- #define XMF_COLOR_TRANSPARENT_B ...
-
- b) Resolution
-
- Once we have converted the Metafile into a Bitmap and we zoom in
- or out, the image may not look very good. If we still had the
- original Metafile, zooming would produce good results always.
-
- c) Size
-
- Although the filesize of a Metafile may be very small, it might
- produce a Bitmap with a bombastic size. Assume you have a Metafile
- with an image size of 6000*4000, which contains just one Metafile
- record ((e.g. a line from (0,0) to (6000, 4000)). The filesize
- of this Metafile would be let's say 100kB. If we convert it to
- a 6000*4000 Bitmap with 24 Bits/Pixes, the Bitmap would consume
- about 68MB of memory.
-
- I have choosen, to limit the size of the Bitmap to max.
- screensize, to avoid memory problems.
-
- If you want something else,
- modify #define XMF_MAXSIZE_CX / XMF_MAXSIZE_CY below
-
-*********************************************************************
-*/
-
-#ifndef _XIMAWMF_H
-#define _XIMAWMF_H
-
-#include "ximage.h"
-
-#if CXIMAGE_SUPPORT_WMF && CXIMAGE_SUPPORT_WINDOWS
-
-class CxImageWMF: public CxImage
-{
-
-#pragma pack(1)
-
-typedef struct tagRECT16
-{
- int16_t left;
- int16_t top;
- int16_t right;
- int16_t bottom;
-} RECT16;
-
-// taken from Windos 3.11 SDK Documentation (Programmer's Reference Volume 4: Resources)
-typedef struct tagMETAFILEHEADER
-{
- uint32_t key; // always 0x9ac6cdd7
- uint16_t reserved1; // reserved = 0
- RECT16 bbox; // bounding rectangle in metafile units as defined in "inch"
- uint16_t inch; // number of metafile units per inch (should be < 1440)
- uint32_t reserved2; // reserved = 0
- uint16_t checksum; // sum of the first 10 WORDS (using XOR operator)
-} METAFILEHEADER;
-
-#pragma pack()
-
-public:
- CxImageWMF(): CxImage(CXIMAGE_FORMAT_WMF) { }
-
- bool Decode(CxFile * hFile, int32_t nForceWidth=0, int32_t nForceHeight=0);
- bool Decode(FILE *hFile, int32_t nForceWidth=0, int32_t nForceHeight=0)
- { CxIOFile file(hFile); return Decode(&file,nForceWidth,nForceHeight); }
-
-#if CXIMAGE_SUPPORT_ENCODE
- bool Encode(CxFile * hFile);
- bool Encode(FILE *hFile) { CxIOFile file(hFile); return Encode(&file); }
-#endif // CXIMAGE_SUPPORT_ENCODE
-
-protected:
- void ShrinkMetafile(int32_t &cx, int32_t &cy);
- BOOL CheckMetafileHeader(METAFILEHEADER *pmetafileheader);
- HENHMETAFILE ConvertWmfFiletoEmf(CxFile *pFile, METAFILEHEADER *pmetafileheader);
- HENHMETAFILE ConvertEmfFiletoEmf(CxFile *pFile, ENHMETAHEADER *pemfh);
-
-};
-
-#define METAFILEKEY 0x9ac6cdd7L
-
-// Background color definition (if no transparency). see Notes above
-#define XMF_COLOR_BACK GetSysColor(COLOR_WINDOW)
-// alternatives
-//#define XMF_COLOR_BACK RGB(192, 192, 192) // lite gray
-//#define XMF_COLOR_BACK RGB( 0, 0, 0) // black
-//#define XMF_COLOR_BACK RGB(255, 255, 255) // white
-
-
-// transparency support. see Notes above
-#define XMF_SUPPORT_TRANSPARENCY 0
-#define XMF_COLOR_TRANSPARENT_R 211
-#define XMF_COLOR_TRANSPARENT_G 121
-#define XMF_COLOR_TRANSPARENT_B 112
-// don't change
-#define XMF_COLOR_TRANSPARENT RGB (XMF_COLOR_TRANSPARENT_R, \
- XMF_COLOR_TRANSPARENT_G, \
- XMF_COLOR_TRANSPARENT_B)
-// don't change
-#define XMF_RGBQUAD_TRANSPARENT XMF_COLOR_TRANSPARENT_B, \
- XMF_COLOR_TRANSPARENT_G, \
- XMF_COLOR_TRANSPARENT_R, \
- 0
-// max. size. see Notes above
-// alternatives
-//#define XMF_MAXSIZE_CX (GetSystemMetrics(SM_CXSCREEN)-10)
-//#define XMF_MAXSIZE_CY (GetSystemMetrics(SM_CYSCREEN)-50)
-//#define XMF_MAXSIZE_CX (2*GetSystemMetrics(SM_CXSCREEN)/3)
-//#define XMF_MAXSIZE_CY (2*GetSystemMetrics(SM_CYSCREEN)/3)
-#define XMF_MAXSIZE_CX 4000
-#define XMF_MAXSIZE_CY 4000
-
-
-#endif
-
-#endif
diff --git a/smelt/sdl/CxImage/ximawnd.cpp b/smelt/sdl/CxImage/ximawnd.cpp deleted file mode 100644 index 7f23f8f..0000000 --- a/smelt/sdl/CxImage/ximawnd.cpp +++ /dev/null @@ -1,1900 +0,0 @@ -// xImaWnd.cpp : Windows functions
-/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
- * CxImage version 7.0.0 31/Dec/2010
- */
-
-#include "ximage.h"
-
-#include "ximaiter.h"
-#include "ximabmp.h"
-
-////////////////////////////////////////////////////////////////////////////////
-#if defined (_WIN32_WCE)
-
-#ifndef DEFAULT_GUI_FONT
-#define DEFAULT_GUI_FONT 17
-#endif
-
-#ifndef PROOF_QUALITY
-#define PROOF_QUALITY 2
-#endif
-
-struct DIBINFO : public BITMAPINFO
-{
- RGBQUAD arColors[255]; // Color table info - adds an extra 255 entries to palette
- operator LPBITMAPINFO() { return (LPBITMAPINFO) this; }
- operator LPBITMAPINFOHEADER() { return &bmiHeader; }
- RGBQUAD* ColorTable() { return bmiColors; }
-};
-
-int32_t BytesPerLine(int32_t nWidth, int32_t nBitsPerPixel)
-{
- return ( (nWidth * nBitsPerPixel + 31) & (~31) ) / 8;
-}
-
-int32_t NumColorEntries(int32_t nBitsPerPixel, int32_t nCompression, uint32_t biClrUsed)
-{
- int32_t nColors = 0;
- switch (nBitsPerPixel)
- {
- case 1:
- nColors = 2; break;
- case 2:
- nColors = 4; break; // winCE only
- case 4:
- nColors = 16; break;
- case 8:
- nColors =256; break;
- case 24:
- nColors = 0; break;
- case 16:
- case 32:
- nColors = 3; break; // I've found that PocketPCs need this regardless of BI_RGB or BI_BITFIELDS
- default:
- ASSERT(FALSE);
- }
- // If biClrUsed is provided, and it is a legal value, use it
- if (biClrUsed > 0 && biClrUsed <= (uint32_t)nColors)
- return biClrUsed;
-
- return nColors;
-}
-
-int32_t GetDIBits(
- HDC hdc, // handle to DC
- HBITMAP hbmp, // handle to bitmap
- uint32_t uStartScan, // first scan line to set
- uint32_t cScanLines, // number of scan lines to copy
- LPVOID lpvBits, // array for bitmap bits
- LPBITMAPINFO lpbi, // bitmap data buffer
- uint32_t uUsage // RGB or palette index
-)
-{
- uint32_t iColorTableSize = 0;
-
- if (!hbmp)
- return 0;
-
- // Get dimensions of bitmap
- BITMAP bm;
- if (!::GetObject(hbmp, sizeof(bm),(LPVOID)&bm))
- return 0;
-
- //3. Creating new bitmap and receive pointer to it's bits.
- HBITMAP hTargetBitmap;
- void *pBuffer;
-
- //3.1 Initilize DIBINFO structure
- DIBINFO dibInfo;
- dibInfo.bmiHeader.biBitCount = 24;
- dibInfo.bmiHeader.biClrImportant = 0;
- dibInfo.bmiHeader.biClrUsed = 0;
- dibInfo.bmiHeader.biCompression = 0;
- dibInfo.bmiHeader.biHeight = bm.bmHeight;
- dibInfo.bmiHeader.biPlanes = 1;
- dibInfo.bmiHeader.biSize = 40;
- dibInfo.bmiHeader.biSizeImage = bm.bmHeight*BytesPerLine(bm.bmWidth,24);
- dibInfo.bmiHeader.biWidth = bm.bmWidth;
- dibInfo.bmiHeader.biXPelsPerMeter = 3780;
- dibInfo.bmiHeader.biYPelsPerMeter = 3780;
- dibInfo.bmiColors[0].rgbBlue = 0;
- dibInfo.bmiColors[0].rgbGreen = 0;
- dibInfo.bmiColors[0].rgbRed = 0;
- dibInfo.bmiColors[0].rgbReserved = 0;
-
- //3.2 Create bitmap and receive pointer to points into pBuffer
- HDC hDC = ::GetDC(NULL);
- ASSERT(hDC);
- hTargetBitmap = CreateDIBSection(
- hDC,
- (const BITMAPINFO*)dibInfo,
- DIB_RGB_COLORS,
- (void**)&pBuffer,
- NULL,
- 0);
-
- ::ReleaseDC(NULL, hDC);
-
- //4. Copy source bitmap into the target bitmap.
-
- //4.1 Create 2 device contexts
- HDC memDc = CreateCompatibleDC(NULL);
- if (!memDc) {
- ASSERT(FALSE);
- }
-
- HDC targetDc = CreateCompatibleDC(NULL);
- if (!targetDc) {
- ASSERT(FALSE);
- }
-
- //4.2 Select source bitmap into one DC, target into another
- HBITMAP hOldBitmap1 = (HBITMAP)::SelectObject(memDc, hbmp);
- HBITMAP hOldBitmap2 = (HBITMAP)::SelectObject(targetDc, hTargetBitmap);
-
- //4.3 Copy source bitmap into the target one
- BitBlt(targetDc, 0, 0, bm.bmWidth, bm.bmHeight, memDc, 0, 0, SRCCOPY);
-
- //4.4 Restore device contexts
- ::SelectObject(memDc, hOldBitmap1);
- ::SelectObject(targetDc, hOldBitmap2);
- DeleteDC(memDc);
- DeleteDC(targetDc);
-
- //Here we can bitmap bits: pBuffer. Note:
- // 1. pBuffer contains 3 bytes per point
- // 2. Lines ane from the bottom to the top!
- // 3. Points in the line are from the left to the right
- // 4. Bytes in one point are BGR (blue, green, red) not RGB
- // 5. Don't delete pBuffer, it will be automatically deleted
- // when delete hTargetBitmap
- lpvBits = pBuffer;
-
- DeleteObject(hbmp);
- //DeleteObject(hTargetBitmap);
-
- return 1;
-}
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-#if CXIMAGE_SUPPORT_WINDOWS
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImage::Blt(HDC pDC, int32_t x, int32_t y)
-{
- if((pDib==0)||(pDC==0)||(!info.bEnabled)) return 0;
-
- HBRUSH brImage = CreateDIBPatternBrushPt(pDib, DIB_RGB_COLORS);
- POINT pt;
- SetBrushOrgEx(pDC,x,y,&pt); //<RT>
- HBRUSH brOld = (HBRUSH) SelectObject(pDC, brImage);
- PatBlt(pDC, x, y, head.biWidth, head.biHeight, PATCOPY);
- SelectObject(pDC, brOld);
- SetBrushOrgEx(pDC,pt.x,pt.y,NULL);
- DeleteObject(brImage);
- return 1;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Transfer the image in a global bitmap handle (clipboard copy)
- */
-HANDLE CxImage::CopyToHandle()
-{
- HANDLE hMem=NULL;
- if (pDib){
- hMem= GlobalAlloc(GHND, GetSize());
- if (hMem){
- uint8_t* pDst=(uint8_t*)GlobalLock(hMem);
- if (pDst){
- memcpy(pDst,pDib,GetSize());
- }
- GlobalUnlock(hMem);
- }
- }
- return hMem;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Global object (clipboard paste) constructor
- * \param hMem: source bitmap object, the clipboard format must be CF_DIB
- * \return true if everything is ok
- */
-bool CxImage::CreateFromHANDLE(HANDLE hMem)
-{
- if (!Destroy())
- return false;
-
- uint32_t dwSize = GlobalSize(hMem);
- if (!dwSize) return false;
-
- uint8_t *lpVoid; //pointer to the bitmap
- lpVoid = (uint8_t *)GlobalLock(hMem);
- BITMAPINFOHEADER *pHead; //pointer to the bitmap header
- pHead = (BITMAPINFOHEADER *)lpVoid;
- if (lpVoid){
-
- //CxMemFile hFile(lpVoid,dwSize);
-
- //copy the bitmap header
- memcpy(&head,pHead,sizeof(BITMAPINFOHEADER));
- //check if it's a top-down bitmap
- bool bTopDownDib = head.biHeight<0;
- if (bTopDownDib) head.biHeight=-head.biHeight;
- //create the image
- if(!Create(head.biWidth,head.biHeight,head.biBitCount)){
- GlobalUnlock(hMem);
- return false;
- }
- //preserve DPI
- SetXDPI((int32_t)floor(head.biXPelsPerMeter * 254.0 / 10000.0 + 0.5));
- SetYDPI((int32_t)floor(head.biYPelsPerMeter * 254.0 / 10000.0 + 0.5));
-
- /*//copy the pixels (old way)
- if((pHead->biCompression != BI_RGB) || (pHead->biBitCount == 32)){ //<Jörgen Alfredsson>
- // BITFIELD case
- // set the internal header in the dib
- memcpy(pDib,&head,sizeof(head));
- // get the bitfield masks
- uint32_t bf[3];
- memcpy(bf,lpVoid+pHead->biSize,12);
- // transform into RGB
- Bitfield2RGB(lpVoid+pHead->biSize+12,bf[0],bf[1],bf[2],(uint8_t)pHead->biBitCount);
- } else { //normal bitmap
- memcpy(pDib,lpVoid,GetSize());
- }*/
-
- // <Michael Gandyra>
- // fill in color map
- bool bIsOldBmp = (head.biSize == sizeof(BITMAPCOREHEADER));
- RGBQUAD *pRgb = GetPalette();
- if (pRgb) {
- // number of colors to fill in
- int32_t nColors = DibNumColors(pHead);
- if (bIsOldBmp) {
- /* get pointer to BITMAPCOREINFO (old style 1.x) */
- LPBITMAPCOREINFO lpbmc = (LPBITMAPCOREINFO)lpVoid;
- for (int32_t i = nColors - 1; i >= 0; i--) {
- pRgb[i].rgbRed = lpbmc->bmciColors[i].rgbtRed;
- pRgb[i].rgbGreen = lpbmc->bmciColors[i].rgbtGreen;
- pRgb[i].rgbBlue = lpbmc->bmciColors[i].rgbtBlue;
- pRgb[i].rgbReserved = (uint8_t)0;
- }
- } else {
- /* get pointer to BITMAPINFO (new style 3.x) */
- LPBITMAPINFO lpbmi = (LPBITMAPINFO)lpVoid;
- for (int32_t i = nColors - 1; i >= 0; i--) {
- pRgb[i].rgbRed = lpbmi->bmiColors[i].rgbRed;
- pRgb[i].rgbGreen = lpbmi->bmiColors[i].rgbGreen;
- pRgb[i].rgbBlue = lpbmi->bmiColors[i].rgbBlue;
- pRgb[i].rgbReserved = (uint8_t)0;
- }
- }
- }
-
- // <Michael Gandyra>
- uint32_t dwCompression = pHead->biCompression;
- // compressed bitmap ?
- if(dwCompression!=BI_RGB || pHead->biBitCount==32 || pHead->biBitCount ==16) {
- // get the bitmap bits
- LPSTR lpDIBBits = (LPSTR)((uint8_t*)pHead + *(uint32_t*)pHead + (uint16_t)(GetNumColors() * sizeof(RGBQUAD)));
- // decode and copy them to our image
- switch (pHead->biBitCount) {
- case 32 :
- {
- // BITFIELD case
- if (dwCompression == BI_BITFIELDS || dwCompression == BI_RGB) {
- // get the bitfield masks
- uint32_t bf[3];
- memcpy(bf,lpVoid+pHead->biSize,12);
- // transform into RGB
- Bitfield2RGB(lpVoid+pHead->biSize+12,bf[0],bf[1],bf[2],(uint8_t)pHead->biBitCount);
- } else {
- // "unknown compression";
- GlobalUnlock(hMem);
- return false;
- }
- }
- break;
- case 16 :
- {
- // get the bitfield masks
- int32_t offset=0;
- uint32_t bf[3];
- if (dwCompression == BI_BITFIELDS) {
- memcpy(bf,lpVoid+pHead->biSize,12);
- offset= 12;
- } else {
- bf[0] = 0x7C00;
- bf[1] = 0x3E0;
- bf[2] = 0x1F; // RGB555
- }
- // copy the pixels
- memcpy(info.pImage, lpDIBBits + offset, head.biHeight*((head.biWidth+1)/2)*4);
- // transform into RGB
- Bitfield2RGB(info.pImage, bf[0], bf[1], bf[2], 16);
- }
- break;
- case 8 :
- case 4 :
- case 1 :
- {
- switch (dwCompression) {
- case BI_RLE4:
- {
- uint8_t status_byte = 0;
- uint8_t second_byte = 0;
- int32_t scanline = 0;
- int32_t bits = 0;
- BOOL low_nibble = FALSE;
- CImageIterator iter(this);
-
- for (BOOL bContinue = TRUE; bContinue; ) {
- status_byte = *(lpDIBBits++);
- switch (status_byte) {
- case RLE_COMMAND :
- status_byte = *(lpDIBBits++);
- switch (status_byte) {
- case RLE_ENDOFLINE :
- bits = 0;
- scanline++;
- low_nibble = FALSE;
- break;
- case RLE_ENDOFBITMAP :
- bContinue = FALSE;
- break;
- case RLE_DELTA :
- {
- // read the delta values
- uint8_t delta_x;
- uint8_t delta_y;
- delta_x = *(lpDIBBits++);
- delta_y = *(lpDIBBits++);
- // apply them
- bits += delta_x / 2;
- scanline += delta_y;
- break;
- }
- default :
- second_byte = *(lpDIBBits++);
- uint8_t* sline = iter.GetRow(scanline);
- for (int32_t i = 0; i < status_byte; i++) {
- if ((uint8_t*)(sline+bits) < (uint8_t*)(info.pImage+head.biSizeImage)){
- if (low_nibble) {
- if (i&1)
- *(sline + bits) |= (second_byte & 0x0f);
- else
- *(sline + bits) |= (second_byte & 0xf0)>>4;
- bits++;
- } else {
- if (i&1)
- *(sline + bits) = (uint8_t)(second_byte & 0x0f)<<4;
- else
- *(sline + bits) = (uint8_t)(second_byte & 0xf0);
- }
- }
-
- if ((i & 1) && (i != (status_byte - 1)))
- second_byte = *(lpDIBBits++);
-
- low_nibble = !low_nibble;
- }
- if ((((status_byte+1) >> 1) & 1 ) == 1)
- second_byte = *(lpDIBBits++);
- break;
- };
- break;
- default :
- {
- uint8_t* sline = iter.GetRow(scanline);
- second_byte = *(lpDIBBits++);
- for (unsigned i = 0; i < status_byte; i++) {
- if ((uint8_t*)(sline+bits) < (uint8_t*)(info.pImage+head.biSizeImage)){
- if (low_nibble) {
- if (i&1)
- *(sline + bits) |= (second_byte & 0x0f);
- else
- *(sline + bits) |= (second_byte & 0xf0)>>4;
- bits++;
- } else {
- if (i&1)
- *(sline + bits) = (uint8_t)(second_byte & 0x0f)<<4;
- else
- *(sline + bits) = (uint8_t)(second_byte & 0xf0);
- }
- }
- low_nibble = !low_nibble;
- }
- }
- break;
- };
- }
- }
- break;
- case BI_RLE8 :
- {
- uint8_t status_byte = 0;
- uint8_t second_byte = 0;
- int32_t scanline = 0;
- int32_t bits = 0;
- CImageIterator iter(this);
-
- for (BOOL bContinue = TRUE; bContinue; ) {
- status_byte = *(lpDIBBits++);
- if (status_byte==RLE_COMMAND) {
- status_byte = *(lpDIBBits++);
- switch (status_byte) {
- case RLE_ENDOFLINE :
- bits = 0;
- scanline++;
- break;
- case RLE_ENDOFBITMAP :
- bContinue = FALSE;
- break;
- case RLE_DELTA :
- {
- // read the delta values
- uint8_t delta_x;
- uint8_t delta_y;
- delta_x = *(lpDIBBits++);
- delta_y = *(lpDIBBits++);
- // apply them
- bits += delta_x;
- scanline += delta_y;
- }
- break;
- default :
- int32_t nNumBytes = sizeof(uint8_t) * status_byte;
- memcpy((void *)(iter.GetRow(scanline) + bits), lpDIBBits, nNumBytes);
- lpDIBBits += nNumBytes;
- // align run length to even number of bytes
- if ((status_byte & 1) == 1)
- second_byte = *(lpDIBBits++);
- bits += status_byte;
- break;
- };
- } else {
- uint8_t *sline = iter.GetRow(scanline);
- second_byte = *(lpDIBBits++);
- for (unsigned i = 0; i < status_byte; i++) {
- if ((uint8_t*)(sline+bits) < (uint8_t*)(info.pImage+head.biSizeImage)){
- *(sline + bits) = second_byte;
- bits++;
- } else {
- bContinue = FALSE; //don't delete: we are in memory, it is not as with files
- break;
- }
- }
- }
- }
- }
- break;
- default :
- {
- // "compression type not supported";
- GlobalUnlock(hMem);
- return false;
- }
- }
- }
- }
- } else {
- //normal bitmap (not compressed)
- memcpy(pDib,lpVoid,GetSize());
- }
-
- GlobalUnlock(hMem);
-
- if (bTopDownDib) Flip();
-
- return true;
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Transfer the image in a icon handle, with transparency.
- * \param hdc: target device context (the screen, usually)
- * \param bTransparency : (optional) exports trancparency
- * \return icon handle, or NULL if an error occurs.
- * \sa MakeBitmap
- * \author [brunom]
- */
-HICON CxImage::MakeIcon(HDC hdc, bool bTransparency)
-{
- HICON hDestIcon = 0;
-
- ICONINFO csDest;
-
- csDest.fIcon = TRUE;
- csDest.xHotspot = 0;
- csDest.yHotspot = 0;
-
- // Assign HBITMAP with Transparency to ICON Info structure
- csDest.hbmColor = MakeBitmap( hdc, bTransparency );
-
- // Create Mask just in case we need a Mask for the Icons
- CxImage a_Mask;
- GetTransparentMask(&a_Mask);
-
- // Assign Mask
- csDest.hbmMask = a_Mask.MakeBitmap();
-
- // Create Icon
- hDestIcon = ::CreateIconIndirect(&csDest);
-
- return hDestIcon;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Transfer the image in a bitmap handle
- * \param hdc: target device context (the screen, usually)
- * \param bTransparency : (optional) exports trancparency
- * \return bitmap handle, or NULL if an error occurs.
- * \sa Draw2HBITMAP, MakeIcon
- * \author []; changes [brunom]
- */
-HBITMAP CxImage::MakeBitmap(HDC hdc, bool bTransparency)
-{
- if (!pDib)
- return NULL;
-
- // Create HBITMAP with Trancparency
- if( (pAlpha!=0) && bTransparency )
- {
- HDC hMemDC;
- if (hdc)
- hMemDC = hdc;
- else
- hMemDC = CreateCompatibleDC(NULL);
-
- BITMAPINFO bi;
-
- // Fill in the BITMAPINFOHEADER
- bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
- bi.bmiHeader.biWidth = GetWidth();
- bi.bmiHeader.biHeight = GetHeight();
- bi.bmiHeader.biPlanes = 1;
- bi.bmiHeader.biBitCount = 32;
- bi.bmiHeader.biCompression = BI_RGB;
- bi.bmiHeader.biSizeImage = 4 * GetWidth() * GetHeight();
- bi.bmiHeader.biXPelsPerMeter = 0;
- bi.bmiHeader.biYPelsPerMeter = 0;
- bi.bmiHeader.biClrUsed = 0;
- bi.bmiHeader.biClrImportant = 0;
-
- COLORREF* pCrBits = NULL;
- HBITMAP hbmp = CreateDIBSection (
- hMemDC, &bi, DIB_RGB_COLORS, (void **)&pCrBits,
- NULL, NULL);
-
- if (!hdc)
- DeleteDC(hMemDC);
-
- DIBSECTION ds;
- if (::GetObject (hbmp, sizeof (DIBSECTION), &ds) == 0)
- {
- return 0;
- }
-
- // transfer Pixels from CxImage to Bitmap
- RGBQUAD* pBit = (RGBQUAD*) ds.dsBm.bmBits;
- int32_t lPx,lPy;
- for( lPy=0 ; lPy < bi.bmiHeader.biHeight ; ++lPy )
- {
- for( lPx=0 ; lPx < bi.bmiHeader.biWidth ; ++lPx )
- {
- RGBQUAD lPixel = GetPixelColor(lPx,lPy,true);
- *pBit = lPixel;
- pBit++;
- }
- }
-
- return hbmp;
- }
-
- // Create HBITMAP without Trancparency
- if (!hdc){
- // this call to CreateBitmap doesn't create a DIB <jaslet>
- // // Create a device-independent bitmap <CSC>
- // return CreateBitmap(head.biWidth,head.biHeight, 1, head.biBitCount, GetBits());
- // use instead this code
- HDC hMemDC = CreateCompatibleDC(NULL);
- LPVOID pBit32;
- HBITMAP bmp = CreateDIBSection(hMemDC,(LPBITMAPINFO)pDib,DIB_RGB_COLORS, &pBit32, NULL, 0);
- if (pBit32) memcpy(pBit32, GetBits(), head.biSizeImage);
- DeleteDC(hMemDC);
- return bmp;
- }
-
- // this single line seems to work very well
- //HBITMAP bmp = CreateDIBitmap(hdc, (LPBITMAPINFOHEADER)pDib, CBM_INIT,
- // GetBits(), (LPBITMAPINFO)pDib, DIB_RGB_COLORS);
- // this alternative works also with _WIN32_WCE
- LPVOID pBit32;
- HBITMAP bmp = CreateDIBSection(hdc, (LPBITMAPINFO)pDib, DIB_RGB_COLORS, &pBit32, NULL, 0);
- if (pBit32) memcpy(pBit32, GetBits(), head.biSizeImage);
-
- return bmp;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * check if the bitmap contains transparency data
- * \param hbmp : bitmap resource handle
- * \return true the bitmap has transparency
- * \author [brunom]
- */
-bool CxImage::IsHBITMAPAlphaValid( HBITMAP hbmp )
-{
- bool lbAlphaValid = false;
- if (hbmp)
- {
- BITMAP bm;
- // get informations about the bitmap
- GetObject(hbmp, sizeof(BITMAP), (LPSTR) &bm);
-
- // for alpha there must bee 32 Bit's per Pixel ??
- if( bm.bmBitsPixel == 32 )
- {
- BITMAPINFO l_BitmapInfo;
- l_BitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
- l_BitmapInfo.bmiHeader.biWidth = bm.bmWidth;
- l_BitmapInfo.bmiHeader.biHeight = bm.bmHeight;
- l_BitmapInfo.bmiHeader.biPlanes = bm.bmPlanes;
- l_BitmapInfo.bmiHeader.biBitCount = bm.bmBitsPixel;
- l_BitmapInfo.bmiHeader.biCompression = BI_RGB;
-
- // create Buffer for Image
- RGBQUAD * l_pRawBytes = new RGBQUAD[bm.bmWidth * bm.bmHeight];
-
- HDC dc = ::GetDC(NULL);
-
- if(dc)
- {
- // Get Pixel Data from Image
- if(GetDIBits(dc, hbmp, 0, bm.bmHeight, l_pRawBytes, &l_BitmapInfo, DIB_RGB_COLORS))
- {
- RGBQUAD * lpArray = l_pRawBytes;
- RGBQUAD * lpArrayEnd = l_pRawBytes + (bm.bmWidth * bm.bmHeight);
-
- // check if Alpha Channel is realy valid (anny value not zero)
- for( ;lpArray != lpArrayEnd ; ++lpArray )
- {
- // any alpha value not zero
- if( lpArray->rgbReserved != 0 )
- {
- // must be vaid alph channel
- lbAlphaValid = true;
- break;
- }
- }
- }
- ::ReleaseDC(NULL, dc);
- }
- // free temporary Memory
- delete [] l_pRawBytes;
- }
- }
-
- return lbAlphaValid;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Bitmap resource constructor
- * \param hbmp : bitmap resource handle
- * \param hpal : (optional) palette, useful for 8bpp DC
- * \param bTransparency : (optional) for 32bpp images only, imports trancparency
- * \return true if everything is ok
- * \author []; changes [brunom]
- */
-bool CxImage::CreateFromHBITMAP(HBITMAP hbmp, HPALETTE hpal, bool bTransparency)
-{
- if (!Destroy())
- return false;
-
- if (hbmp) {
- BITMAP bm;
- // get informations about the bitmap
- GetObject(hbmp, sizeof(BITMAP), (LPSTR) &bm);
-
- // Transparency in HBITMAP
- if(bTransparency && IsHBITMAPAlphaValid(hbmp))
- {
- bool l_bResult = true;
-
- BITMAPINFO l_BitmapInfo;
- l_BitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
- l_BitmapInfo.bmiHeader.biWidth = bm.bmWidth;
- l_BitmapInfo.bmiHeader.biHeight = bm.bmHeight;
- l_BitmapInfo.bmiHeader.biPlanes = bm.bmPlanes;
- l_BitmapInfo.bmiHeader.biBitCount = bm.bmBitsPixel;
- l_BitmapInfo.bmiHeader.biCompression = BI_RGB;
-
- RGBQUAD *l_pRawBytes = new RGBQUAD[bm.bmWidth * bm.bmHeight];
-
- HDC dc = ::GetDC(NULL);
-
- if(dc)
- {
- if(GetDIBits(dc, hbmp, 0, bm.bmHeight, l_pRawBytes, &l_BitmapInfo, DIB_RGB_COLORS))
- l_bResult = CreateFromArray((uint8_t*)l_pRawBytes, bm.bmWidth, bm.bmHeight, bm.bmBitsPixel, bm.bmWidthBytes, false);
- else
- l_bResult = false;
-
- ::ReleaseDC(NULL, dc);
- }
- else
- l_bResult = false;
-
- delete [] l_pRawBytes;
-
- return l_bResult;
- }
- else
- {
- // create the image
- if (!Create(bm.bmWidth, bm.bmHeight, bm.bmBitsPixel, 0))
- return false;
- // create a device context for the bitmap
- HDC dc = ::GetDC(NULL);
- if (!dc)
- return false;
-
- if (hpal){
- SelectObject(dc,hpal); //the palette you should get from the user or have a stock one
- RealizePalette(dc);
- }
-
- // copy the pixels
- if (GetDIBits(dc, hbmp, 0, head.biHeight, info.pImage,
- (LPBITMAPINFO)pDib, DIB_RGB_COLORS) == 0){ //replace &head with pDib <Wil Stark>
- strcpy(info.szLastError,"GetDIBits failed");
- ::ReleaseDC(NULL, dc);
- return false;
- }
- ::ReleaseDC(NULL, dc);
- return true;
- }
- }
- return false;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * icon resource constructor
- * \param hico : icon resource handle
- * \param bTransparency : (optional) for 32bpp images only, imports trancparency
- * \return true if everything is ok
- * \author []; changes [Arlen Albert Keshabian], [brunom]
- */
-#if !defined (_WIN32_WCE)
-bool CxImage::CreateFromHICON(HICON hico, bool bTransparency)
-{
- if (!Destroy() || !hico)
- return false;
-
- bool l_bResult = true;
-
- ICONINFO iinfo;
- GetIconInfo(hico,&iinfo);
-
- //BITMAP l_Bitmap;
- //GetObject(iinfo.hbmColor, sizeof(BITMAP), &l_Bitmap);
-
- l_bResult = CreateFromHBITMAP( iinfo.hbmColor, NULL, bTransparency );
-
-#if CXIMAGE_SUPPORT_ALPHA
- if(l_bResult && ((!IsHBITMAPAlphaValid(iinfo.hbmColor)) || (!bTransparency)) )
- {
- CxImage mask;
- mask.CreateFromHBITMAP(iinfo.hbmMask);
- mask.GrayScale();
- mask.Negative();
- AlphaSet(mask);
- }
-#endif
-
- DeleteObject(iinfo.hbmColor); //<Sims>
- DeleteObject(iinfo.hbmMask); //<Sims>
-
- return l_bResult;
-}
-#endif //_WIN32_WCE
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImage::Draw(HDC hdc, const RECT& rect, RECT* pClipRect, bool bSmooth, bool bFlipY)
-{
- return Draw(hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, pClipRect,bSmooth, bFlipY);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Draws the image in the specified device context, with support for alpha channel, alpha palette, transparency, opacity.
- * \param hdc : destination device context
- * \param x,y : (optional) offset
- * \param cx,cy : (optional) size.
- * - If cx or cy are not specified (or less than 0), the normal width or height will be used
- * - If cx or cy are different than width or height, the image will be stretched
- *
- * \param pClipRect : limit the drawing operations inside a given rectangle in the output device context.
- * \param bSmooth : activates a bilinear filter that will enhance the appearence for zommed pictures.
- * Quite slow. Needs CXIMAGE_SUPPORT_INTERPOLATION.
- * \param bFlipY : draws a mirror image along the y-axis
- * \return true if everything is ok
- */
-int32_t CxImage::Draw(HDC hdc, int32_t x, int32_t y, int32_t cx, int32_t cy, RECT* pClipRect, bool bSmooth, bool bFlipY)
-{
- if((pDib==0)||(hdc==0)||(cx==0)||(cy==0)||(!info.bEnabled)) return 0;
-
- if (cx < 0) cx = head.biWidth;
- if (cy < 0) cy = head.biHeight;
- bool bTransparent = info.nBkgndIndex >= 0;
- bool bAlpha = pAlpha != 0;
-
- //required for MM_ANISOTROPIC, MM_HIENGLISH, and similar modes [Greg Peatfield]
- int32_t hdc_Restore = ::SaveDC(hdc);
- if (!hdc_Restore)
- return 0;
-
-#if !defined (_WIN32_WCE)
- RECT mainbox; // (experimental)
- if (pClipRect){
- GetClipBox(hdc,&mainbox);
- HRGN rgn = CreateRectRgnIndirect(pClipRect);
- ExtSelectClipRgn(hdc,rgn,RGN_AND);
- DeleteObject(rgn);
- }
-#endif
-
- //find the smallest area to paint
- RECT clipbox,paintbox;
- GetClipBox(hdc,&clipbox);
-
- paintbox.top = min(clipbox.bottom,max(clipbox.top,y));
- paintbox.left = min(clipbox.right,max(clipbox.left,x));
- paintbox.right = max(clipbox.left,min(clipbox.right,x+cx));
- paintbox.bottom = max(clipbox.top,min(clipbox.bottom,y+cy));
-
- int32_t destw = paintbox.right - paintbox.left;
- int32_t desth = paintbox.bottom - paintbox.top;
-
- if (!(bTransparent || bAlpha || info.bAlphaPaletteEnabled)){
- if (cx==head.biWidth && cy==head.biHeight){ //NORMAL
-#if !defined (_WIN32_WCE)
- SetStretchBltMode(hdc,COLORONCOLOR);
-#endif
- if (bFlipY){
- StretchDIBits(hdc, x, y+cy-1,
- cx, -cy, 0, 0, cx, cy,
- info.pImage,(BITMAPINFO*)pDib,DIB_RGB_COLORS,SRCCOPY);
- } else {
- SetDIBitsToDevice(hdc, x, y, cx, cy, 0, 0, 0, cy,
- info.pImage,(BITMAPINFO*)pDib,DIB_RGB_COLORS);
- }
- } else { //STRETCH
- //pixel informations
- RGBQUAD c={0,0,0,0};
- //Preparing Bitmap Info
- BITMAPINFO bmInfo;
- memset(&bmInfo.bmiHeader,0,sizeof(BITMAPINFOHEADER));
- bmInfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
- bmInfo.bmiHeader.biWidth=destw;
- bmInfo.bmiHeader.biHeight=desth;
- bmInfo.bmiHeader.biPlanes=1;
- bmInfo.bmiHeader.biBitCount=24;
- uint8_t *pbase; //points to the final dib
- uint8_t *pdst; //current pixel from pbase
- uint8_t *ppix; //current pixel from image
- //get the background
- HDC TmpDC=CreateCompatibleDC(hdc);
- HBITMAP TmpBmp=CreateDIBSection(hdc,&bmInfo,DIB_RGB_COLORS,(void**)&pbase,0,0);
- HGDIOBJ TmpObj=SelectObject(TmpDC,TmpBmp);
-
- if (pbase){
- int32_t xx,yy;
- int32_t sx,sy;
- float dx,dy;
- uint8_t *psrc;
-
- int32_t ew = ((((24 * destw) + 31) / 32) * 4);
- int32_t ymax = paintbox.bottom;
- int32_t xmin = paintbox.left;
- float fx=(float)head.biWidth/(float)cx;
- float fy=(float)head.biHeight/(float)cy;
-
- for(yy=0;yy<desth;yy++){
- dy = head.biHeight-(ymax-yy-y)*fy;
- sy = max(0L,(int32_t)floor(dy));
- psrc = info.pImage+sy*info.dwEffWidth;
- if (bFlipY){
- pdst = pbase+(desth-1-yy)*ew;
- } else {
- pdst = pbase+yy*ew;
- }
- for(xx=0;xx<destw;xx++){
- dx = (xx+xmin-x)*fx;
- sx = max(0L,(int32_t)floor(dx));
-#if CXIMAGE_SUPPORT_INTERPOLATION
- if (bSmooth){
- if (fx > 1 && fy > 1) {
- c = GetAreaColorInterpolated(dx - 0.5f, dy - 0.5f, fx, fy, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- } else {
- c = GetPixelColorInterpolated(dx - 0.5f, dy - 0.5f, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- }
- } else
-#endif //CXIMAGE_SUPPORT_INTERPOLATION
- {
- if (head.biClrUsed){
- c=GetPaletteColor(GetPixelIndex(sx,sy));
- } else {
- ppix = psrc + sx*3;
- c.rgbBlue = *ppix++;
- c.rgbGreen= *ppix++;
- c.rgbRed = *ppix;
- }
- }
- *pdst++=c.rgbBlue;
- *pdst++=c.rgbGreen;
- *pdst++=c.rgbRed;
- }
- }
- }
- //paint the image & cleanup
- SetDIBitsToDevice(hdc,paintbox.left,paintbox.top,destw,desth,0,0,0,desth,pbase,&bmInfo,0);
- DeleteObject(SelectObject(TmpDC,TmpObj));
- DeleteDC(TmpDC);
- }
- } else { // draw image with transparent/alpha blending
- //////////////////////////////////////////////////////////////////
- //Alpha blend - Thanks to Florian Egel
-
- //pixel informations
- RGBQUAD c={0,0,0,0};
- RGBQUAD ct = GetTransColor();
- int32_t* pc = (int32_t*)&c;
- int32_t* pct= (int32_t*)&ct;
- int32_t cit = GetTransIndex();
- int32_t ci = 0;
-
- //Preparing Bitmap Info
- BITMAPINFO bmInfo;
- memset(&bmInfo.bmiHeader,0,sizeof(BITMAPINFOHEADER));
- bmInfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
- bmInfo.bmiHeader.biWidth=destw;
- bmInfo.bmiHeader.biHeight=desth;
- bmInfo.bmiHeader.biPlanes=1;
- bmInfo.bmiHeader.biBitCount=24;
-
- uint8_t *pbase; //points to the final dib
- uint8_t *pdst; //current pixel from pbase
- uint8_t *ppix; //current pixel from image
-
- //get the background
- HDC TmpDC=CreateCompatibleDC(hdc);
- HBITMAP TmpBmp=CreateDIBSection(hdc,&bmInfo,DIB_RGB_COLORS,(void**)&pbase,0,0);
- HGDIOBJ TmpObj=SelectObject(TmpDC,TmpBmp);
- BitBlt(TmpDC,0,0,destw,desth,hdc,paintbox.left,paintbox.top,SRCCOPY);
-
- if (pbase){
- int32_t xx,yy,alphaoffset,ix,iy;
- uint8_t a,a1,*psrc;
- int32_t ew = ((((24 * destw) + 31) / 32) * 4);
- int32_t ymax = paintbox.bottom;
- int32_t xmin = paintbox.left;
-
- if (cx!=head.biWidth || cy!=head.biHeight){
- //STRETCH
- float fx=(float)head.biWidth/(float)cx;
- float fy=(float)head.biHeight/(float)cy;
- float dx,dy;
- int32_t sx,sy;
-
- for(yy=0;yy<desth;yy++){
- dy = head.biHeight-(ymax-yy-y)*fy;
- sy = max(0L,(int32_t)floor(dy));
-
- alphaoffset = sy*head.biWidth;
- if (bFlipY){
- pdst = pbase+(desth-1-yy)*ew;
- } else {
- pdst = pbase + yy*ew;
- }
- psrc = info.pImage + sy*info.dwEffWidth;
-
- for(xx=0;xx<destw;xx++){
- dx = (xx+xmin-x)*fx;
- sx = max(0L,(int32_t)floor(dx));
-
- if (bAlpha) a=pAlpha[alphaoffset+sx]; else a=255;
- a =(uint8_t)((a*(1+info.nAlphaMax))>>8);
-
- if (head.biClrUsed){
- ci = GetPixelIndex(sx,sy);
-#if CXIMAGE_SUPPORT_INTERPOLATION
- if (bSmooth){
- if (fx > 1 && fy > 1) {
- c = GetAreaColorInterpolated(dx - 0.5f, dy - 0.5f, fx, fy, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- } else {
- c = GetPixelColorInterpolated(dx - 0.5f, dy - 0.5f, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- }
- } else
-#endif //CXIMAGE_SUPPORT_INTERPOLATION
- {
- c = GetPaletteColor(GetPixelIndex(sx,sy));
- }
- if (info.bAlphaPaletteEnabled){
- a = (uint8_t)((a*(1+c.rgbReserved))>>8);
- }
- } else {
-#if CXIMAGE_SUPPORT_INTERPOLATION
- if (bSmooth){
- if (fx > 1 && fy > 1) {
- c = GetAreaColorInterpolated(dx - 0.5f, dy - 0.5f, fx, fy, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- } else {
- c = GetPixelColorInterpolated(dx - 0.5f, dy - 0.5f, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- }
- } else
-#endif //CXIMAGE_SUPPORT_INTERPOLATION
- {
- ppix = psrc + sx*3;
- c.rgbBlue = *ppix++;
- c.rgbGreen= *ppix++;
- c.rgbRed = *ppix;
- }
- }
- //if (*pc!=*pct || !bTransparent){
- //if ((head.biClrUsed && ci!=cit) || ((!head.biClrUsed||bSmooth) && *pc!=*pct) || !bTransparent){
- if ((head.biClrUsed && ci!=cit) || (!head.biClrUsed && *pc!=*pct) || !bTransparent){
- // DJT, assume many pixels are fully transparent or opaque and thus avoid multiplication
- if (a == 0) { // Transparent, retain dest
- pdst+=3;
- } else if (a == 255) { // opaque, ignore dest
- *pdst++= c.rgbBlue;
- *pdst++= c.rgbGreen;
- *pdst++= c.rgbRed;
- } else { // semi transparent
- a1=(uint8_t)~a;
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbBlue)>>8);
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbGreen)>>8);
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbRed)>>8);
- }
- } else {
- pdst+=3;
- }
- }
- }
- } else {
- //NORMAL
- iy=head.biHeight-ymax+y;
- for(yy=0;yy<desth;yy++,iy++){
- alphaoffset=iy*head.biWidth;
- ix=xmin-x;
- if (bFlipY){
- pdst = pbase+(desth-1-yy)*ew;
- } else {
- pdst = pbase+yy*ew;
- }
- ppix=info.pImage+iy*info.dwEffWidth+ix*3;
- for(xx=0;xx<destw;xx++,ix++){
-
- if (bAlpha) a=pAlpha[alphaoffset+ix]; else a=255;
- a = (uint8_t)((a*(1+info.nAlphaMax))>>8);
-
- if (head.biClrUsed){
- ci = GetPixelIndex(ix,iy);
- c = GetPaletteColor((uint8_t)ci);
- if (info.bAlphaPaletteEnabled){
- a = (uint8_t)((a*(1+c.rgbReserved))>>8);
- }
- } else {
- c.rgbBlue = *ppix++;
- c.rgbGreen= *ppix++;
- c.rgbRed = *ppix++;
- }
-
- //if (*pc!=*pct || !bTransparent){
- if ((head.biClrUsed && ci!=cit) || (!head.biClrUsed && *pc!=*pct) || !bTransparent){
- // DJT, assume many pixels are fully transparent or opaque and thus avoid multiplication
- if (a == 0) { // Transparent, retain dest
- pdst+=3;
- } else if (a == 255) { // opaque, ignore dest
- *pdst++= c.rgbBlue;
- *pdst++= c.rgbGreen;
- *pdst++= c.rgbRed;
- } else { // semi transparent
- a1=(uint8_t)~a;
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbBlue)>>8);
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbGreen)>>8);
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbRed)>>8);
- }
- } else {
- pdst+=3;
- }
- }
- }
- }
- }
- //paint the image & cleanup
- SetDIBitsToDevice(hdc,paintbox.left,paintbox.top,destw,desth,0,0,0,desth,pbase,&bmInfo,0);
- DeleteObject(SelectObject(TmpDC,TmpObj));
- DeleteDC(TmpDC);
- }
-
-#if !defined (_WIN32_WCE)
- if (pClipRect){ // (experimental)
- HRGN rgn = CreateRectRgnIndirect(&mainbox);
- ExtSelectClipRgn(hdc,rgn,RGN_OR);
- DeleteObject(rgn);
- }
-#endif
-
- ::RestoreDC(hdc,hdc_Restore);
- return 1;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * renders the image into a HBITMAP handle
- * \param hdc : destination device context
- * \param x,y : (optional) offset
- * \param cx,cy : (optional) size.
- * - If cx or cy are not specified (or less than 0), the normal width or height will be used
- * - If cx or cy are different than width or height, the image will be stretched
- * \param pClipRect : limit the drawing operations inside a given rectangle in the output device context.
- * \param bSmooth : activates a bilinear filter that will enhance the appearence for zommed pictures.
- * Quite slow. Needs CXIMAGE_SUPPORT_INTERPOLATION.
- * \return HBITMAP handle, NULL in case of error
- * \sa MakeBitmap
- */
-HBITMAP CxImage::Draw2HBITMAP(HDC hdc, int32_t x, int32_t y, int32_t cx, int32_t cy, RECT* pClipRect, bool bSmooth)
-{
- if((pDib==0)||(hdc==0)||(cx==0)||(cy==0)||(!info.bEnabled)) return 0;
-
- if (cx < 0) cx = head.biWidth;
- if (cy < 0) cy = head.biHeight;
- bool bTransparent = info.nBkgndIndex >= 0;
- bool bAlpha = pAlpha != 0;
-
- //required for MM_ANISOTROPIC, MM_HIENGLISH, and similar modes [Greg Peatfield]
- int32_t hdc_Restore = ::SaveDC(hdc);
- if (!hdc_Restore)
- return 0;
-
-#if !defined (_WIN32_WCE)
- RECT mainbox; // (experimental)
- if (pClipRect){
- GetClipBox(hdc,&mainbox);
- HRGN rgn = CreateRectRgnIndirect(pClipRect);
- ExtSelectClipRgn(hdc,rgn,RGN_AND);
- DeleteObject(rgn);
- }
-#endif
-
- HBITMAP TmpBmp;
-
- //find the smallest area to paint
- RECT clipbox,paintbox;
- GetClipBox(hdc,&clipbox);
-
- paintbox.top = min(clipbox.bottom,max(clipbox.top,y));
- paintbox.left = min(clipbox.right,max(clipbox.left,x));
- paintbox.right = max(clipbox.left,min(clipbox.right,x+cx));
- paintbox.bottom = max(clipbox.top,min(clipbox.bottom,y+cy));
-
- int32_t destw = paintbox.right - paintbox.left;
- int32_t desth = paintbox.bottom - paintbox.top;
-
- if (!(bTransparent || bAlpha || info.bAlphaPaletteEnabled)){
- if (cx==head.biWidth && cy==head.biHeight){ //NORMAL
-#if !defined (_WIN32_WCE)
- SetStretchBltMode(hdc,COLORONCOLOR);
-#endif
- SetDIBitsToDevice(hdc, x, y, cx, cy, 0, 0, 0, cy,
- info.pImage,(BITMAPINFO*)pDib,DIB_RGB_COLORS);
- } else { //STRETCH
- //pixel informations
- RGBQUAD c={0,0,0,0};
- //Preparing Bitmap Info
- BITMAPINFO bmInfo;
- memset(&bmInfo.bmiHeader,0,sizeof(BITMAPINFOHEADER));
- bmInfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
- bmInfo.bmiHeader.biWidth=destw;
- bmInfo.bmiHeader.biHeight=desth;
- bmInfo.bmiHeader.biPlanes=1;
- bmInfo.bmiHeader.biBitCount=24;
- uint8_t *pbase; //points to the final dib
- uint8_t *pdst; //current pixel from pbase
- uint8_t *ppix; //current pixel from image
- //get the background
- HDC TmpDC=CreateCompatibleDC(hdc);
- TmpBmp=CreateDIBSection(hdc,&bmInfo,DIB_RGB_COLORS,(void**)&pbase,0,0);
- HGDIOBJ TmpObj=SelectObject(TmpDC,TmpBmp);
-
- if (pbase){
- int32_t xx,yy;
- int32_t sx,sy;
- float dx,dy;
- uint8_t *psrc;
-
- int32_t ew = ((((24 * destw) + 31) / 32) * 4);
- int32_t ymax = paintbox.bottom;
- int32_t xmin = paintbox.left;
- float fx=(float)head.biWidth/(float)cx;
- float fy=(float)head.biHeight/(float)cy;
-
- for(yy=0;yy<desth;yy++){
- dy = head.biHeight-(ymax-yy-y)*fy;
- sy = max(0L,(int32_t)floor(dy));
- psrc = info.pImage+sy*info.dwEffWidth;
- pdst = pbase+yy*ew;
- for(xx=0;xx<destw;xx++){
- dx = (xx+xmin-x)*fx;
- sx = max(0L,(int32_t)floor(dx));
-#if CXIMAGE_SUPPORT_INTERPOLATION
- if (bSmooth){
- if (fx > 1 && fy > 1) {
- c = GetAreaColorInterpolated(dx - 0.5f, dy - 0.5f, fx, fy, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- } else {
- c = GetPixelColorInterpolated(dx - 0.5f, dy - 0.5f, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- }
- } else
-#endif //CXIMAGE_SUPPORT_INTERPOLATION
- {
- if (head.biClrUsed){
- c=GetPaletteColor(GetPixelIndex(sx,sy));
- } else {
- ppix = psrc + sx*3;
- c.rgbBlue = *ppix++;
- c.rgbGreen= *ppix++;
- c.rgbRed = *ppix;
- }
- }
- *pdst++=c.rgbBlue;
- *pdst++=c.rgbGreen;
- *pdst++=c.rgbRed;
- }
- }
- }
- //cleanup
- SelectObject(TmpDC,TmpObj);
- DeleteDC(TmpDC);
- }
- } else { // draw image with transparent/alpha blending
- //////////////////////////////////////////////////////////////////
- //Alpha blend - Thanks to Florian Egel
-
- //pixel informations
- RGBQUAD c={0,0,0,0};
- RGBQUAD ct = GetTransColor();
- int32_t* pc = (int32_t*)&c;
- int32_t* pct= (int32_t*)&ct;
- int32_t cit = GetTransIndex();
- int32_t ci = 0;
-
- //Preparing Bitmap Info
- BITMAPINFO bmInfo;
- memset(&bmInfo.bmiHeader,0,sizeof(BITMAPINFOHEADER));
- bmInfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
- bmInfo.bmiHeader.biWidth=destw;
- bmInfo.bmiHeader.biHeight=desth;
- bmInfo.bmiHeader.biPlanes=1;
- bmInfo.bmiHeader.biBitCount=24;
-
- uint8_t *pbase; //points to the final dib
- uint8_t *pdst; //current pixel from pbase
- uint8_t *ppix; //current pixel from image
-
- //get the background
- HDC TmpDC=CreateCompatibleDC(hdc);
- TmpBmp=CreateDIBSection(hdc,&bmInfo,DIB_RGB_COLORS,(void**)&pbase,0,0);
- HGDIOBJ TmpObj=SelectObject(TmpDC,TmpBmp);
- BitBlt(TmpDC,0,0,destw,desth,hdc,paintbox.left,paintbox.top,SRCCOPY);
-
- if (pbase){
- int32_t xx,yy,alphaoffset,ix,iy;
- uint8_t a,a1,*psrc;
- int32_t ew = ((((24 * destw) + 31) / 32) * 4);
- int32_t ymax = paintbox.bottom;
- int32_t xmin = paintbox.left;
-
- if (cx!=head.biWidth || cy!=head.biHeight){
- //STRETCH
- float fx=(float)head.biWidth/(float)cx;
- float fy=(float)head.biHeight/(float)cy;
- float dx,dy;
- int32_t sx,sy;
-
- for(yy=0;yy<desth;yy++){
- dy = head.biHeight-(ymax-yy-y)*fy;
- sy = max(0L,(int32_t)floor(dy));
-
- alphaoffset = sy*head.biWidth;
- pdst = pbase + yy*ew;
- psrc = info.pImage + sy*info.dwEffWidth;
-
- for(xx=0;xx<destw;xx++){
- dx = (xx+xmin-x)*fx;
- sx = max(0L,(int32_t)floor(dx));
-
- if (bAlpha) a=pAlpha[alphaoffset+sx]; else a=255;
- a =(uint8_t)((a*(1+info.nAlphaMax))>>8);
-
- if (head.biClrUsed){
- ci = GetPixelIndex(sx,sy);
-#if CXIMAGE_SUPPORT_INTERPOLATION
- if (bSmooth){
- if (fx > 1 && fy > 1) {
- c = GetAreaColorInterpolated(dx - 0.5f, dy - 0.5f, fx, fy, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- } else {
- c = GetPixelColorInterpolated(dx - 0.5f, dy - 0.5f, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- }
- } else
-#endif //CXIMAGE_SUPPORT_INTERPOLATION
- {
- c = GetPaletteColor(GetPixelIndex(sx,sy));
- }
- if (info.bAlphaPaletteEnabled){
- a = (uint8_t)((a*(1+c.rgbReserved))>>8);
- }
- } else {
-#if CXIMAGE_SUPPORT_INTERPOLATION
- if (bSmooth){
- if (fx > 1 && fy > 1) {
- c = GetAreaColorInterpolated(dx - 0.5f, dy - 0.5f, fx, fy, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- } else {
- c = GetPixelColorInterpolated(dx - 0.5f, dy - 0.5f, CxImage::IM_BILINEAR, CxImage::OM_REPEAT);
- }
- } else
-#endif //CXIMAGE_SUPPORT_INTERPOLATION
- {
- ppix = psrc + sx*3;
- c.rgbBlue = *ppix++;
- c.rgbGreen= *ppix++;
- c.rgbRed = *ppix;
- }
- }
- //if (*pc!=*pct || !bTransparent){
- //if ((head.biClrUsed && ci!=cit) || ((!head.biClrUsed||bSmooth) && *pc!=*pct) || !bTransparent){
- if ((head.biClrUsed && ci!=cit) || (!head.biClrUsed && *pc!=*pct) || !bTransparent){
- // DJT, assume many pixels are fully transparent or opaque and thus avoid multiplication
- if (a == 0) { // Transparent, retain dest
- pdst+=3;
- } else if (a == 255) { // opaque, ignore dest
- *pdst++= c.rgbBlue;
- *pdst++= c.rgbGreen;
- *pdst++= c.rgbRed;
- } else { // semi transparent
- a1=(uint8_t)~a;
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbBlue)>>8);
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbGreen)>>8);
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbRed)>>8);
- }
- } else {
- pdst+=3;
- }
- }
- }
- } else {
- //NORMAL
- iy=head.biHeight-ymax+y;
- for(yy=0;yy<desth;yy++,iy++){
- alphaoffset=iy*head.biWidth;
- ix=xmin-x;
- pdst=pbase+yy*ew;
- ppix=info.pImage+iy*info.dwEffWidth+ix*3;
- for(xx=0;xx<destw;xx++,ix++){
-
- if (bAlpha) a=pAlpha[alphaoffset+ix]; else a=255;
- a = (uint8_t)((a*(1+info.nAlphaMax))>>8);
-
- if (head.biClrUsed){
- ci = GetPixelIndex(ix,iy);
- c = GetPaletteColor((uint8_t)ci);
- if (info.bAlphaPaletteEnabled){
- a = (uint8_t)((a*(1+c.rgbReserved))>>8);
- }
- } else {
- c.rgbBlue = *ppix++;
- c.rgbGreen= *ppix++;
- c.rgbRed = *ppix++;
- }
-
- //if (*pc!=*pct || !bTransparent){
- if ((head.biClrUsed && ci!=cit) || (!head.biClrUsed && *pc!=*pct) || !bTransparent){
- // DJT, assume many pixels are fully transparent or opaque and thus avoid multiplication
- if (a == 0) { // Transparent, retain dest
- pdst+=3;
- } else if (a == 255) { // opaque, ignore dest
- *pdst++= c.rgbBlue;
- *pdst++= c.rgbGreen;
- *pdst++= c.rgbRed;
- } else { // semi transparent
- a1=(uint8_t)~a;
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbBlue)>>8);
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbGreen)>>8);
- *pdst++=(uint8_t)((*pdst * a1 + a * c.rgbRed)>>8);
- }
- } else {
- pdst+=3;
- }
- }
- }
- }
- }
- //cleanup
- SelectObject(TmpDC,TmpObj);
- DeleteDC(TmpDC);
- }
-
-#if !defined (_WIN32_WCE)
- if (pClipRect){ // (experimental)
- HRGN rgn = CreateRectRgnIndirect(&mainbox);
- ExtSelectClipRgn(hdc,rgn,RGN_OR);
- DeleteObject(rgn);
- }
-#endif
-
- ::RestoreDC(hdc,hdc_Restore);
- return TmpBmp;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImage::Draw2(HDC hdc, const RECT& rect)
-{
- return Draw2(hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Draws (stretch) the image with single transparency support
- * \param hdc : destination device context
- * \param x,y : (optional) offset
- * \param cx,cy : (optional) size.
- * - If cx or cy are not specified (or less than 0), the normal width or height will be used
- * - If cx or cy are different than width or height, the image will be stretched
- *
- * \return true if everything is ok
- */
-int32_t CxImage::Draw2(HDC hdc, int32_t x, int32_t y, int32_t cx, int32_t cy)
-{
- if((pDib==0)||(hdc==0)||(cx==0)||(cy==0)||(!info.bEnabled)) return 0;
- if (cx < 0) cx = head.biWidth;
- if (cy < 0) cy = head.biHeight;
- bool bTransparent = (info.nBkgndIndex >= 0);
-
- //required for MM_ANISOTROPIC, MM_HIENGLISH, and similar modes [Greg Peatfield]
- int32_t hdc_Restore = ::SaveDC(hdc);
- if (!hdc_Restore)
- return 0;
-
- if (!bTransparent){
-#if !defined (_WIN32_WCE)
- SetStretchBltMode(hdc,COLORONCOLOR);
-#endif
- StretchDIBits(hdc, x, y, cx, cy, 0, 0, head.biWidth, head.biHeight,
- info.pImage,(BITMAPINFO*)pDib, DIB_RGB_COLORS,SRCCOPY);
- } else {
- // draw image with transparent background
- const int32_t safe = 0; // or else GDI fails in the following - sometimes
- RECT rcDst = {x+safe, y+safe, x+cx, y+cy};
- if (RectVisible(hdc, &rcDst)){
- /////////////////////////////////////////////////////////////////
- // True Mask Method - Thanks to Paul Reynolds and Ron Gery
- int32_t nWidth = head.biWidth;
- int32_t nHeight = head.biHeight;
- // Create two memory dcs for the image and the mask
- HDC dcImage=CreateCompatibleDC(hdc);
- HDC dcTrans=CreateCompatibleDC(hdc);
- // Select the image into the appropriate dc
- HBITMAP bm = CreateCompatibleBitmap(hdc, nWidth, nHeight);
- HBITMAP pOldBitmapImage = (HBITMAP)SelectObject(dcImage,bm);
-#if !defined (_WIN32_WCE)
- SetStretchBltMode(dcImage,COLORONCOLOR);
-#endif
- StretchDIBits(dcImage, 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight,
- info.pImage,(BITMAPINFO*)pDib,DIB_RGB_COLORS,SRCCOPY);
-
- // Create the mask bitmap
- HBITMAP bitmapTrans = CreateBitmap(nWidth, nHeight, 1, 1, NULL);
- // Select the mask bitmap into the appropriate dc
- HBITMAP pOldBitmapTrans = (HBITMAP)SelectObject(dcTrans, bitmapTrans);
- // Build mask based on transparent colour
- RGBQUAD rgbBG;
- if (head.biBitCount<24) rgbBG = GetPaletteColor((uint8_t)info.nBkgndIndex);
- else rgbBG = info.nBkgndColor;
- COLORREF crColour = RGB(rgbBG.rgbRed, rgbBG.rgbGreen, rgbBG.rgbBlue);
- COLORREF crOldBack = SetBkColor(dcImage,crColour);
- BitBlt(dcTrans,0, 0, nWidth, nHeight, dcImage, 0, 0, SRCCOPY);
-
- // Do the work - True Mask method - cool if not actual display
- StretchBlt(hdc,x, y,cx,cy, dcImage, 0, 0, nWidth, nHeight, SRCINVERT);
- StretchBlt(hdc,x, y,cx,cy, dcTrans, 0, 0, nWidth, nHeight, SRCAND);
- StretchBlt(hdc,x, y,cx,cy, dcImage, 0, 0, nWidth, nHeight, SRCINVERT);
-
- // Restore settings
- SelectObject(dcImage,pOldBitmapImage);
- SelectObject(dcTrans,pOldBitmapTrans);
- SetBkColor(hdc,crOldBack);
- DeleteObject( bitmapTrans ); // RG 29/01/2002
- DeleteDC(dcImage);
- DeleteDC(dcTrans);
- DeleteObject(bm);
- }
- }
- ::RestoreDC(hdc,hdc_Restore);
- return 1;
-}
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImage::Stretch(HDC hdc, const RECT& rect, uint32_t dwRop)
-{
- return Stretch(hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, dwRop);
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Stretch the image. Obsolete: use Draw() or Draw2()
- * \param hdc : destination device context
- * \param xoffset,yoffset : (optional) offset
- * \param xsize,ysize : size.
- * \param dwRop : raster operation code (see BitBlt documentation)
- * \return true if everything is ok
- */
-int32_t CxImage::Stretch(HDC hdc, int32_t xoffset, int32_t yoffset, int32_t xsize, int32_t ysize, uint32_t dwRop)
-{
- if((pDib)&&(hdc)) {
- //palette must be correctly filled
-#if !defined (_WIN32_WCE)
- SetStretchBltMode(hdc,COLORONCOLOR);
-#endif
- StretchDIBits(hdc, xoffset, yoffset,
- xsize, ysize, 0, 0, head.biWidth, head.biHeight,
- info.pImage,(BITMAPINFO*)pDib,DIB_RGB_COLORS,dwRop);
- return 1;
- }
- return 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Tiles the device context in the specified rectangle with the image.
- * \param hdc : destination device context
- * \param rc : tiled rectangle in the output device context
- * \return true if everything is ok
- */
-int32_t CxImage::Tile(HDC hdc, RECT *rc)
-{
- if((pDib)&&(hdc)&&(rc)) {
- int32_t w = rc->right - rc->left;
- int32_t h = rc->bottom - rc->top;
- int32_t x,y,z;
- int32_t bx=head.biWidth;
- int32_t by=head.biHeight;
- for (y = 0 ; y < h ; y += by){
- if ((y+by)>h) by=h-y;
- z=bx;
- for (x = 0 ; x < w ; x += z){
- if ((x+z)>w) z=w-x;
- RECT r = {rc->left + x,rc->top + y,rc->left + x + z,rc->top + y + by};
- Draw(hdc,rc->left + x, rc->top + y,-1,-1,&r);
- }
- }
- return 1;
- }
- return 0;
-}
-////////////////////////////////////////////////////////////////////////////////
-// For UNICODE support: char -> TCHAR
-int32_t CxImage::DrawString(HDC hdc, int32_t x, int32_t y, const TCHAR* text, RGBQUAD color, const TCHAR* font, int32_t lSize, int32_t lWeight, uint8_t bItalic, uint8_t bUnderline, bool bSetAlpha)
-//int32_t CxImage::DrawString(HDC hdc, int32_t x, int32_t y, const char* text, RGBQUAD color, const char* font, int32_t lSize, int32_t lWeight, uint8_t bItalic, uint8_t bUnderline, bool bSetAlpha)
-{
- if (IsValid()){
- //get the background
- HDC pDC;
- if (hdc) pDC=hdc; else pDC = ::GetDC(0);
- if (pDC==NULL) return 0;
- HDC TmpDC=CreateCompatibleDC(pDC);
- if (hdc==NULL) ::ReleaseDC(0, pDC);
- if (TmpDC==NULL) return 0;
- //choose the font
- HFONT m_Font;
- LOGFONT* m_pLF;
- m_pLF=(LOGFONT*)calloc(1,sizeof(LOGFONT));
- _tcsncpy(m_pLF->lfFaceName,font,31); // For UNICODE support
- //strncpy(m_pLF->lfFaceName,font,31);
- m_pLF->lfHeight=lSize;
- m_pLF->lfWeight=lWeight;
- m_pLF->lfItalic=bItalic;
- m_pLF->lfUnderline=bUnderline;
- m_Font=CreateFontIndirect(m_pLF);
- //select the font in the dc
- HFONT pOldFont=NULL;
- if (m_Font)
- pOldFont = (HFONT)SelectObject(TmpDC,m_Font);
- else
- pOldFont = (HFONT)SelectObject(TmpDC,GetStockObject(DEFAULT_GUI_FONT));
-
- //Set text color
- SetTextColor(TmpDC,RGB(255,255,255));
- SetBkColor(TmpDC,RGB(0,0,0));
- //draw the text
- SetBkMode(TmpDC,OPAQUE);
- //Set text position;
- RECT pos = {0,0,0,0};
- //int32_t len = (int32_t)strlen(text);
- int32_t len = (int32_t)_tcslen(text); // For UNICODE support
- ::DrawText(TmpDC,text,len,&pos,DT_CALCRECT);
- pos.right+=pos.bottom; //for italics
-
- //Preparing Bitmap Info
- int32_t width=pos.right;
- int32_t height=pos.bottom;
- BITMAPINFO bmInfo;
- memset(&bmInfo.bmiHeader,0,sizeof(BITMAPINFOHEADER));
- bmInfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
- bmInfo.bmiHeader.biWidth=width;
- bmInfo.bmiHeader.biHeight=height;
- bmInfo.bmiHeader.biPlanes=1;
- bmInfo.bmiHeader.biBitCount=24;
- uint8_t *pbase; //points to the final dib
-
- HBITMAP TmpBmp=CreateDIBSection(TmpDC,&bmInfo,DIB_RGB_COLORS,(void**)&pbase,0,0);
- HGDIOBJ TmpObj=SelectObject(TmpDC,TmpBmp);
- memset(pbase,0,height*((((24 * width) + 31) / 32) * 4));
-
- ::DrawText(TmpDC,text,len,&pos,0);
-
- CxImage itext;
- itext.CreateFromHBITMAP(TmpBmp);
-
- y=head.biHeight-y-1;
- for (int32_t ix=0;ix<width;ix++){
- for (int32_t iy=0;iy<height;iy++){
- if (itext.GetPixelColor(ix,iy).rgbBlue) SetPixelColor(x+ix,y+iy,color,bSetAlpha);
- }
- }
-
- //cleanup
- if (pOldFont) SelectObject(TmpDC,pOldFont);
- DeleteObject(m_Font);
- free(m_pLF);
- DeleteObject(SelectObject(TmpDC,TmpObj));
- DeleteDC(TmpDC);
- }
-
- return 1;
-}
-////////////////////////////////////////////////////////////////////////////////
-// <VATI>
-int32_t CxImage::DrawStringEx(HDC hdc, int32_t x, int32_t y, CXTEXTINFO *pTextType, bool bSetAlpha )
-{
- if (!IsValid())
- return -1;
-
- //get the background
- HDC pDC;
- if (hdc) pDC=hdc; else pDC = ::GetDC(0);
- if (pDC==NULL) return 0;
- HDC TmpDC=CreateCompatibleDC(pDC);
- if (hdc==NULL) ::ReleaseDC(0, pDC);
- if (TmpDC==NULL) return 0;
-
- //choose the font
- HFONT m_Font;
- m_Font=CreateFontIndirect( &pTextType->lfont );
-
- // get colors in RGBQUAD
- RGBQUAD p_forecolor = RGBtoRGBQUAD(pTextType->fcolor);
- RGBQUAD p_backcolor = RGBtoRGBQUAD(pTextType->bcolor);
-
- // check alignment and re-set default if necessary
- if ( pTextType->align != DT_CENTER &&
- pTextType->align != DT_LEFT &&
- pTextType->align != DT_RIGHT )
- pTextType->align = DT_CENTER;
-
- // check rounding radius and re-set default if necessary
- if ( pTextType->b_round > 50 )
- pTextType->b_round = 10;
-
- // check opacity and re-set default if necessary
- if ( pTextType->b_opacity > 1. || pTextType->b_opacity < .0 )
- pTextType->b_opacity = 0.;
-
- //select the font in the dc
- HFONT pOldFont=NULL;
- if (m_Font)
- pOldFont = (HFONT)SelectObject(TmpDC,m_Font);
- else
- pOldFont = (HFONT)SelectObject(TmpDC,GetStockObject(DEFAULT_GUI_FONT));
-
- //Set text color
- SetTextColor(TmpDC,RGB(255,255,255));
- SetBkColor(TmpDC,RGB(0,0,0));
- SetBkMode(TmpDC,OPAQUE);
- //Set text position;
- RECT pos = {0,0,0,0};
-
- // get text length and number of lines
- int32_t i=0, numlines=1, len=(int32_t)_tcsclen(pTextType->text);
- while (i<len)
- {
- if ( pTextType->text[i++]==13 )
- numlines++;
- }
-
- ::DrawText(TmpDC, pTextType->text, len, &pos, /*DT_EDITCONTROL|DT_EXTERNALLEADING|*/DT_NOPREFIX | DT_CALCRECT );
-
- // increase only if it's really italics, and only one line height
- if ( pTextType->lfont.lfItalic )
- pos.right += pos.bottom/2/numlines;
-
- // background frame and rounding radius
- int32_t frame = 0, roundR = 0;
- if ( pTextType->opaque )
- {
- roundR= (int32_t)(pos.bottom/numlines * pTextType->b_round / 100 ) ;
- frame = (int32_t)(/*3.5 + */0.29289*roundR ) ;
- pos.right += pos.bottom/numlines/3 ; // JUST FOR BEAUTY
- }
-
- //Preparing Bitmap Info
- int32_t width=pos.right +frame*2;
- int32_t height=pos.bottom +frame*2;
- BITMAPINFO bmInfo;
- memset(&bmInfo.bmiHeader,0,sizeof(BITMAPINFOHEADER));
- bmInfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
- bmInfo.bmiHeader.biWidth=width;
- bmInfo.bmiHeader.biHeight=height;
- bmInfo.bmiHeader.biPlanes=1;
- bmInfo.bmiHeader.biBitCount=24;
- uint8_t *pbase; //points to the final dib
-
- HBITMAP TmpBmp=CreateDIBSection(TmpDC,&bmInfo,DIB_RGB_COLORS,(void**)&pbase,0,0);
- HGDIOBJ TmpObj=SelectObject(TmpDC,TmpBmp);
- memset(pbase,0,height*((((24 * width) + 31) / 32) * 4));
-
- ::DrawText(TmpDC,pTextType->text,len, &pos, /*DT_EDITCONTROL|DT_EXTERNALLEADING|*/DT_NOPREFIX| pTextType->align );
-
- CxImage itext;
- itext.CreateFromHBITMAP(TmpBmp);
- y=head.biHeight-y-1;
-
- itext.Negative();
-
-#if CXIMAGE_SUPPORT_DSP
- if (pTextType->smooth==FALSE){
- itext.Threshold(128);
- } else {
- //itext.TextBlur();
- }
-#endif
-
- //move the insertion point according to alignment type
- // DT_CENTER: cursor points to the center of text rectangle
- // DT_RIGHT: cursor points to right side end of text rectangle
- // DT_LEFT: cursor points to left end of text rectangle
- if ( pTextType->align == DT_CENTER )
- x -= width/2;
- else if ( pTextType->align == DT_RIGHT )
- x -= width;
- if (x<0) x=0;
-
- //draw the background first, if it exists
- int32_t ix,iy;
- if ( pTextType->opaque )
- {
- int32_t ixf=0;
- for (ix=0;ix<width;ix++)
- {
- if ( ix<=roundR )
- ixf = (int32_t)(.5+roundR-sqrt((float)(roundR*roundR-(ix-roundR)*(ix-roundR))));
- else if ( ix>=width-roundR-1 )
- ixf = (int32_t)(.5+roundR-sqrt((float)(roundR*roundR-(width-1-ix-roundR)*(width-1-ix-roundR))));
- else
- ixf=0;
-
- for (iy=0;iy<height;iy++)
- {
- if ( (ix<=roundR && ( iy > height-ixf-1 || iy < ixf )) ||
- (ix>=width-roundR-1 && ( iy > height-ixf-1 || iy < ixf )) )
- continue;
- else
- if ( pTextType->b_opacity > 0.0 && pTextType->b_opacity < 1.0 )
- {
- RGBQUAD bcolor, pcolor;
- // calculate a transition color from original image to background color:
- pcolor = GetPixelColor(x+ix,y+iy);
- bcolor.rgbBlue = (uint8_t)(pTextType->b_opacity * pcolor.rgbBlue + (1.0-pTextType->b_opacity) * p_backcolor.rgbBlue );
- bcolor.rgbRed = (uint8_t)(pTextType->b_opacity * pcolor.rgbRed + (1.0-pTextType->b_opacity) * p_backcolor.rgbRed ) ;
- bcolor.rgbGreen = (uint8_t)(pTextType->b_opacity * pcolor.rgbGreen + (1.0-pTextType->b_opacity) * p_backcolor.rgbGreen ) ;
- bcolor.rgbReserved = 0;
- SetPixelColor(x+ix,y+iy,bcolor,bSetAlpha);
- }
- else
- SetPixelColor(x+ix,y+iy,p_backcolor,bSetAlpha);
- }
- }
- }
-
- // draw the text itself
- for (ix=0;ix<width;ix++)
- {
- for (iy=0;iy<height;iy++)
- {
- RGBQUAD pcolor = GetPixelColor(x+ix,y+iy);
- RGBQUAD tcolor = itext.GetPixelColor(ix,iy);
- if (tcolor.rgbBlue!=255){
- float a = tcolor.rgbBlue/255.0f;
- pcolor.rgbBlue = (uint8_t)(a * (pcolor.rgbBlue - p_forecolor.rgbBlue) + p_forecolor.rgbBlue );
- pcolor.rgbRed = (uint8_t)(a * (pcolor.rgbRed - p_forecolor.rgbRed) + p_forecolor.rgbRed ) ;
- pcolor.rgbGreen = (uint8_t)(a * (pcolor.rgbGreen - p_forecolor.rgbGreen) + p_forecolor.rgbGreen );
- pcolor.rgbReserved = 0;
- SetPixelColor(x+ix+frame,y+iy-frame,pcolor,bSetAlpha);
- //SetPixelColor(x+ix+frame,y+iy-frame,p_forecolor,bSetAlpha);
- }
- }
- }
-
- //cleanup
- if (pOldFont) SelectObject(TmpDC,pOldFont);
- DeleteObject(m_Font);
- DeleteObject(SelectObject(TmpDC,TmpObj));
- DeleteDC(TmpDC);
- return 1;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-void CxImage::InitTextInfo( CXTEXTINFO *txt )
-{
-
- memset( txt, 0, sizeof(CXTEXTINFO));
-
- // LOGFONT defaults
- txt->lfont.lfHeight = -36;
- txt->lfont.lfCharSet = EASTEUROPE_CHARSET; // just for Central-European users
- txt->lfont.lfWeight = FW_NORMAL;
- txt->lfont.lfWidth = 0;
- txt->lfont.lfEscapement = 0;
- txt->lfont.lfOrientation = 0;
- txt->lfont.lfItalic = FALSE;
- txt->lfont.lfUnderline = FALSE;
- txt->lfont.lfStrikeOut = FALSE;
- txt->lfont.lfOutPrecision = OUT_DEFAULT_PRECIS;
- txt->lfont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
- txt->lfont.lfQuality = PROOF_QUALITY;
- txt->lfont.lfPitchAndFamily= DEFAULT_PITCH | FF_DONTCARE ;
- _stprintf( txt->lfont.lfFaceName, _T("Arial")); //use TCHAR mappings <Cesar M>
-
- // initial colors
- txt->fcolor = RGB( 255,255,160 ); // default foreground: light goldyellow
- txt->bcolor = RGB( 0, 80,160 ); // default background: light blue
-
- // background
- txt->opaque = TRUE; // text has a non-transparent background;
- txt->smooth = TRUE;
- txt->b_opacity = 0.0; // default: opaque background
- txt->b_outline = 0; // default: no outline (OUTLINE NOT IMPLEMENTED AT THIS TIME)
- txt->b_round = 20; // default: rounding radius is 20% of the rectangle height
- // the text
- _stprintf( txt->text, _T("Sample Text 01234õû")); // text use TCHAR mappings <Cesar M>
- txt->align = DT_CENTER;
- return;
-}
-
-#if CXIMAGE_SUPPORT_LAYERS
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImage::LayerDrawAll(HDC hdc, const RECT& rect, RECT* pClipRect, bool bSmooth)
-{
- return LayerDrawAll(hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, pClipRect,bSmooth);
-}
-////////////////////////////////////////////////////////////////////////////////
-int32_t CxImage::LayerDrawAll(HDC hdc, int32_t x, int32_t y, int32_t cx, int32_t cy, RECT* pClipRect, bool bSmooth)
-{
- int32_t n=0;
- CxImage* pLayer;
- while(pLayer=GetLayer(n++)){
- if (pLayer->Draw(hdc,x+pLayer->info.xOffset,y+pLayer->info.yOffset,cx,cy,pClipRect,bSmooth)==0)
- return 0;
- if (pLayer->LayerDrawAll(hdc,x+pLayer->info.xOffset,y+pLayer->info.yOffset,cx,cy,pClipRect,bSmooth)==0)
- return 0;
- }
- return 1;
-}
-#endif //CXIMAGE_SUPPORT_LAYERS
-
-////////////////////////////////////////////////////////////////////////////////
-#endif //CXIMAGE_SUPPORT_WINDOWS
-////////////////////////////////////////////////////////////////////////////////
diff --git a/smelt/sdl/CxImage/xiofile.h b/smelt/sdl/CxImage/xiofile.h deleted file mode 100644 index e05811e..0000000 --- a/smelt/sdl/CxImage/xiofile.h +++ /dev/null @@ -1,125 +0,0 @@ -#if !defined(__xiofile_h)
-#define __xiofile_h
-
-#include "xfile.h"
-//#include <TCHAR.h>
-
-class DLL_EXP CxIOFile : public CxFile
- {
-public:
- CxIOFile(FILE* fp = NULL)
- {
- m_fp = fp;
- m_bCloseFile = (bool)(fp==0);
- }
-
- ~CxIOFile()
- {
- Close();
- }
-//////////////////////////////////////////////////////////
- bool Open(const TCHAR * filename, const TCHAR * mode)
- {
- if (m_fp) return false; // Can't re-open without closing first
-
- m_fp = fopen(filename, mode);
- if (!m_fp) return false;
-
- m_bCloseFile = true;
-
- return true;
- }
-//////////////////////////////////////////////////////////
- virtual bool Close()
- {
- int32_t iErr = 0;
- if ( (m_fp) && (m_bCloseFile) ){
- iErr = fclose(m_fp);
- m_fp = NULL;
- }
- return (bool)(iErr==0);
- }
-//////////////////////////////////////////////////////////
- virtual size_t Read(void *buffer, size_t size, size_t count)
- {
- if (!m_fp) return 0;
- return fread(buffer, size, count, m_fp);
- }
-//////////////////////////////////////////////////////////
- virtual size_t Write(const void *buffer, size_t size, size_t count)
- {
- if (!m_fp) return 0;
- return fwrite(buffer, size, count, m_fp);
- }
-//////////////////////////////////////////////////////////
- virtual bool Seek(int32_t offset, int32_t origin)
- {
- if (!m_fp) return false;
- return (bool)(fseek(m_fp, offset, origin) == 0);
- }
-//////////////////////////////////////////////////////////
- virtual int32_t Tell()
- {
- if (!m_fp) return 0;
- return ftell(m_fp);
- }
-//////////////////////////////////////////////////////////
- virtual int32_t Size()
- {
- if (!m_fp) return -1;
- int32_t pos,size;
- pos = ftell(m_fp);
- fseek(m_fp, 0, SEEK_END);
- size = ftell(m_fp);
- fseek(m_fp, pos,SEEK_SET);
- return size;
- }
-//////////////////////////////////////////////////////////
- virtual bool Flush()
- {
- if (!m_fp) return false;
- return (bool)(fflush(m_fp) == 0);
- }
-//////////////////////////////////////////////////////////
- virtual bool Eof()
- {
- if (!m_fp) return true;
- return (bool)(feof(m_fp) != 0);
- }
-//////////////////////////////////////////////////////////
- virtual int32_t Error()
- {
- if (!m_fp) return -1;
- return ferror(m_fp);
- }
-//////////////////////////////////////////////////////////
- virtual bool PutC(uint8_t c)
- {
- if (!m_fp) return false;
- return (bool)(fputc(c, m_fp) == c);
- }
-//////////////////////////////////////////////////////////
- virtual int32_t GetC()
- {
- if (!m_fp) return EOF;
- return getc(m_fp);
- }
-//////////////////////////////////////////////////////////
- virtual char * GetS(char *string, int32_t n)
- {
- if (!m_fp) return NULL;
- return fgets(string,n,m_fp);
- }
-//////////////////////////////////////////////////////////
- virtual int32_t Scanf(const char *format, void* output)
- {
- if (!m_fp) return EOF;
- return fscanf(m_fp, format, output);
- }
-//////////////////////////////////////////////////////////
-protected:
- FILE *m_fp;
- bool m_bCloseFile;
- };
-
-#endif
diff --git a/smelt/sdl/CxImage/xmemfile.cpp b/smelt/sdl/CxImage/xmemfile.cpp deleted file mode 100644 index f235899..0000000 --- a/smelt/sdl/CxImage/xmemfile.cpp +++ /dev/null @@ -1,213 +0,0 @@ -#include "xmemfile.h"
-
-//////////////////////////////////////////////////////////
-CxMemFile::CxMemFile(uint8_t* pBuffer, uint32_t size)
-{
- m_pBuffer = pBuffer;
- m_Position = 0;
- m_Size = m_Edge = size;
- m_bFreeOnClose = (bool)(pBuffer==0);
- m_bEOF = false;
-}
-//////////////////////////////////////////////////////////
-CxMemFile::~CxMemFile()
-{
- Close();
-}
-//////////////////////////////////////////////////////////
-bool CxMemFile::Close()
-{
- if ( (m_pBuffer) && (m_bFreeOnClose) ){
- free(m_pBuffer);
- m_pBuffer = NULL;
- m_Size = 0;
- }
- return true;
-}
-//////////////////////////////////////////////////////////
-bool CxMemFile::Open()
-{
- if (m_pBuffer) return false; // Can't re-open without closing first
-
- m_Position = m_Size = m_Edge = 0;
- m_pBuffer=(uint8_t*)malloc(1);
- m_bFreeOnClose = true;
-
- return (m_pBuffer!=0);
-}
-//////////////////////////////////////////////////////////
-uint8_t* CxMemFile::GetBuffer(bool bDetachBuffer)
-{
- //can only detach, avoid inadvertantly attaching to
- // memory that may not be ours [Jason De Arte]
- if( bDetachBuffer )
- m_bFreeOnClose = false;
- return m_pBuffer;
-}
-//////////////////////////////////////////////////////////
-size_t CxMemFile::Read(void *buffer, size_t size, size_t count)
-{
- if (buffer==NULL) return 0;
-
- if (m_pBuffer==NULL) return 0;
- if (m_Position >= (int32_t)m_Size){
- m_bEOF = true;
- return 0;
- }
-
- int32_t nCount = (int32_t)(count*size);
- if (nCount == 0) return 0;
-
- int32_t nRead;
- if (m_Position + nCount > (int32_t)m_Size){
- m_bEOF = true;
- nRead = (m_Size - m_Position);
- } else
- nRead = nCount;
-
- memcpy(buffer, m_pBuffer + m_Position, nRead);
- m_Position += nRead;
-
- return (size_t)(nRead/size);
-}
-//////////////////////////////////////////////////////////
-size_t CxMemFile::Write(const void *buffer, size_t size, size_t count)
-{
- m_bEOF = false;
- if (m_pBuffer==NULL) return 0;
- if (buffer==NULL) return 0;
-
- int32_t nCount = (int32_t)(count*size);
- if (nCount == 0) return 0;
-
- if (m_Position + nCount > m_Edge){
- if (!Alloc(m_Position + nCount)){
- return false;
- }
- }
-
- memcpy(m_pBuffer + m_Position, buffer, nCount);
-
- m_Position += nCount;
-
- if (m_Position > (int32_t)m_Size) m_Size = m_Position;
-
- return count;
-}
-//////////////////////////////////////////////////////////
-bool CxMemFile::Seek(int32_t offset, int32_t origin)
-{
- m_bEOF = false;
- if (m_pBuffer==NULL) return false;
- int32_t lNewPos = m_Position;
-
- if (origin == SEEK_SET) lNewPos = offset;
- else if (origin == SEEK_CUR) lNewPos += offset;
- else if (origin == SEEK_END) lNewPos = m_Size + offset;
- else return false;
-
- if (lNewPos < 0) lNewPos = 0;
-
- m_Position = lNewPos;
- return true;
-}
-//////////////////////////////////////////////////////////
-int32_t CxMemFile::Tell()
-{
- if (m_pBuffer==NULL) return -1;
- return m_Position;
-}
-//////////////////////////////////////////////////////////
-int32_t CxMemFile::Size()
-{
- if (m_pBuffer==NULL) return -1;
- return m_Size;
-}
-//////////////////////////////////////////////////////////
-bool CxMemFile::Flush()
-{
- if (m_pBuffer==NULL) return false;
- return true;
-}
-//////////////////////////////////////////////////////////
-bool CxMemFile::Eof()
-{
- if (m_pBuffer==NULL) return true;
- return m_bEOF;
-}
-//////////////////////////////////////////////////////////
-int32_t CxMemFile::Error()
-{
- if (m_pBuffer==NULL) return -1;
- return (m_Position > (int32_t)m_Size);
-}
-//////////////////////////////////////////////////////////
-bool CxMemFile::PutC(uint8_t c)
-{
- m_bEOF = false;
- if (m_pBuffer==NULL) return false;
-
- if (m_Position >= m_Edge){
- if (!Alloc(m_Position + 1)){
- return false;
- }
- }
-
- m_pBuffer[m_Position++] = c;
-
- if (m_Position > (int32_t)m_Size) m_Size = m_Position;
-
- return true;
-}
-//////////////////////////////////////////////////////////
-int32_t CxMemFile::GetC()
-{
- if (m_pBuffer==NULL || m_Position >= (int32_t)m_Size){
- m_bEOF = true;
- return EOF;
- }
- return *(uint8_t*)((uint8_t*)m_pBuffer + m_Position++);
-}
-//////////////////////////////////////////////////////////
-char * CxMemFile::GetS(char *string, int32_t n)
-{
- n--;
- int32_t c,i=0;
- while (i<n){
- c = GetC();
- if (c == EOF) return 0;
- string[i++] = (char)c;
- if (c == '\n') break;
- }
- string[i] = 0;
- return string;
-}
-//////////////////////////////////////////////////////////
-int32_t CxMemFile::Scanf(const char *format, void* output)
-{
- return 0;
-}
-//////////////////////////////////////////////////////////
-bool CxMemFile::Alloc(uint32_t dwNewLen)
-{
- if (dwNewLen > (uint32_t)m_Edge)
- {
- // find new buffer size
- uint32_t dwNewBufferSize = (uint32_t)(((dwNewLen>>16)+1)<<16);
-
- // allocate new buffer
- if (m_pBuffer == NULL) m_pBuffer = (uint8_t*)malloc(dwNewBufferSize);
- else m_pBuffer = (uint8_t*)realloc(m_pBuffer, dwNewBufferSize);
- // I own this buffer now (caller knows nothing about it)
- m_bFreeOnClose = true;
-
- m_Edge = dwNewBufferSize;
- }
- return (m_pBuffer!=0);
-}
-//////////////////////////////////////////////////////////
-void CxMemFile::Free()
-{
- Close();
-}
-//////////////////////////////////////////////////////////
diff --git a/smelt/sdl/CxImage/xmemfile.h b/smelt/sdl/CxImage/xmemfile.h deleted file mode 100644 index e132db3..0000000 --- a/smelt/sdl/CxImage/xmemfile.h +++ /dev/null @@ -1,42 +0,0 @@ -#if !defined(__xmemfile_h)
-#define __xmemfile_h
-
-#include "xfile.h"
-
-//////////////////////////////////////////////////////////
-class DLL_EXP CxMemFile : public CxFile
-{
-public:
- CxMemFile(uint8_t* pBuffer = NULL, uint32_t size = 0);
- ~CxMemFile();
-
- bool Open();
- uint8_t* GetBuffer(bool bDetachBuffer = true);
-
- virtual bool Close();
- virtual size_t Read(void *buffer, size_t size, size_t count);
- virtual size_t Write(const void *buffer, size_t size, size_t count);
- virtual bool Seek(int32_t offset, int32_t origin);
- virtual int32_t Tell();
- virtual int32_t Size();
- virtual bool Flush();
- virtual bool Eof();
- virtual int32_t Error();
- virtual bool PutC(uint8_t c);
- virtual int32_t GetC();
- virtual char * GetS(char *string, int32_t n);
- virtual int32_t Scanf(const char *format, void* output);
-
-protected:
- bool Alloc(uint32_t nBytes);
- void Free();
-
- uint8_t* m_pBuffer;
- uint32_t m_Size;
- bool m_bFreeOnClose;
- int32_t m_Position; //current position
- int32_t m_Edge; //buffer size
- bool m_bEOF;
-};
-
-#endif
|