/ray/src/lib/pixmap/imagetile.cc

Go to the documentation of this file.

/*
 * lib/pixmap/imagetile.cc
 * 
 * Stores the data of an image tile in memory provides pixel access functions. 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#include "imagetile.h"
#include <lib/salloc.h>


// Scaling constants for flt conversion: 
static const flt CF_R5 =  0.03225806451612903f;       // 1/31
static const flt CF_R6 =  0.01587301587301587f;       // 1/63
static const flt CF_R8 =  0.003921568627450980f;      // 1/255
static const flt CF_R16 = 0.00001525902189669642f;    // 1/65535
static const flt CF_N5 =     31.0f;
static const flt CF_N6 =     63.0f;
static const flt CF_N8 =    255.0f;
static const flt CF_N16 = 65565.0f;

// Convert pixel values to flts: 
static inline flt P2F(uint8 x)    {  return(CF_R8*x);   }
static inline flt P2F(uint16 x)   {  return(CF_R16*x);  }
// Convert flts to pixel values: 
static inline uint8  F2P8(flt x)   {  return((uint8)(CF_N8*x+0.5f));   }
static inline uint16 F2P16(flt x)  {  return((uint16)(CF_N16*x+0.5f));  }

// Special versions for 555 and 565 (packed): 
static inline flt P2F_5(uint16 x)  {  return(CF_R5*x);  }
static inline flt P2F_6(uint16 x)  {  return(CF_R6*x);  }
static inline uint16 F2P_5(flt x)  {  return((uint16)(CF_N5*x+0.5f));  }
static inline uint16 F2P_6(flt x)  {  return((uint16)(CF_N6*x+0.5f));  }

// This is just a non-implemented conversion template. 
// All implementations are specialisations and implemented below. 
template<typename D,typename S>static inline void CV_GET(D*,S);
template<typename D,typename S>static inline void CV_PUT(D*,S);
// Specialisations: 
static inline void CV_GET(uint8 *d,uint8 s)    {  *d=s;  }
// NO version CV_GET(uint8 *d,uint16 s); does not make sense!!
static inline void CV_GET(uint16 *d,uint8 s)   {  *d=s;  }
static inline void CV_GET(uint16 *d,uint16 s)  {  *d=s;  }

static inline void CV_PUT(uint8 *d,uint8 s)    {  *d=s;  }
static inline void CV_PUT(uint8 *d,uint16 s)   {  *d=s;  }
static inline void CV_PUT(uint16 *d,uint8 s)   {  *d=s;  }
static inline void CV_PUT(uint16 *d,uint16 s)  {  *d=s;  }

static inline void CV_GET(flt *d,flt s)    {  *d=s;  }
static inline void CV_PUT(flt *d,flt s)    {  *d=s;  }

static inline void CV_GET(flt *d,uint8 s)    {  *d=P2F(s);  }
static inline void CV_GET(flt *d,uint16 s)   {  *d=P2F(s);  }

static inline void CV_PUT(uint8 *d,flt s)    {  *d=F2P8(s);   }
static inline void CV_PUT(uint16 *d,flt s)   {  *d=F2P16(s);  }



struct PixmapImageTileInternal
{
    // *************************************************************************
    // Prototypes for the unimplemented image pixel functions: 
    static void no_getpixel8(const PixmapImageTile *,uint,uint,uint8 *)
        {  CritAssert(!"unimplemented");  }
    static void no_getpixel16(const PixmapImageTile *,uint,uint,uint16 *)
        {  CritAssert(!"unimplemented");  }
    static void no_getpixelF(const PixmapImageTile *,uint,uint,flt *)
        {  CritAssert(!"unimplemented");  }
    static void no_putpixel8(PixmapImageTile *,uint,uint,const uint8 *)
        {  CritAssert(!"unimplemented");  }
    static void no_putpixel16(PixmapImageTile *,uint,uint,const uint16 *)
        {  CritAssert(!"unimplemented");  }
    static void no_putpixelF(PixmapImageTile *,uint,uint,const flt *)
        {  CritAssert(!"unimplemented");  }
    
    // *************************************************************************
    // All the different image pixel functions which are currently supported: 
    // C = storage type (all channels use the same), uint8, uint16 or flt. 
    // P = external type, i.e. uint8, uint16 or flt. 
    // CHANNELS: 1
    template<typename C,typename P>static void getpixel_1(
        const PixmapImageTile *t,uint x,uint y,P *p)
    {
        CV_GET( p, ((const C*)t->data)[y*t->w+x] );
    }
    template<typename C,typename P>static void putpixel_1(
        PixmapImageTile *t,uint x,uint y,const P *p)
    {
        CV_PUT( &((C*)t->data)[y*t->w+x], *p );
    }
    
    // CHANNELS: 2
    template<typename C,typename P>static void getpixel_2(
        const PixmapImageTile *t,uint x,uint y,P *p)
    {
        const C *v = &((const C*)t->data)[(y*t->w+x)*2];
        CV_GET( p++, *v++ );
        CV_GET( p,   *v   );
    }
    template<typename C,typename P>static void putpixel_2(
        PixmapImageTile *t,uint x,uint y,const P *p)
    {
        C *v = &((C*)t->data)[(y*t->w+x)*2];
        CV_PUT( v++, *p++ );
        CV_PUT( v,   *p   );
    }
    
    // CHANNELS: 3
    template<typename C,typename P>static void getpixel_3(
        const PixmapImageTile *t,uint x,uint y,P *p)
    {
        const C *v = &((const C*)t->data)[(y*t->w+x)*3];
        CV_GET( p++, *v++ );
        CV_GET( p++, *v++ );
        CV_GET( p,   *v   );
    }
    template<typename C,typename P>static void putpixel_3(
        PixmapImageTile *t,uint x,uint y,const P *p)
    {
        C *v = &((C*)t->data)[(y*t->w+x)*3];
        CV_PUT( v++, *p++ );
        CV_PUT( v++, *p++ );
        CV_PUT( v,   *p   );
    }
    
    // CHANNELS: 4
    template<typename C,typename P>static void getpixel_4(
        const PixmapImageTile *t,uint x,uint y,P *p)
    {
        const C *v = &((const C*)t->data)[(y*t->w+x)*4];
        CV_GET( p++, *v++ );
        CV_GET( p++, *v++ );
        CV_GET( p++, *v++ );
        CV_GET( p,   *v   );
    }
    template<typename C,typename P>static void putpixel_4(
        PixmapImageTile *t,uint x,uint y,const P *p)
    {
        C *v = &((C*)t->data)[(y*t->w+x)*4];
        CV_PUT( v++, *p++ );
        CV_PUT( v++, *p++ );
        CV_PUT( v++, *p++ );
        CV_PUT( v,   *p   );
    }
    
    // CHANNELS: 5
    template<typename C,typename P>static void getpixel_5(
        const PixmapImageTile *t,uint x,uint y,P *p)
    {
        const C *v = &((const C*)t->data)[(y*t->w+x)*5];
        CV_GET( p++, *v++ );
        CV_GET( p++, *v++ );
        CV_GET( p++, *v++ );
        CV_GET( p++, *v++ );
        CV_GET( p,   *v   );
    }
    template<typename C,typename P>static void putpixel_5(
        PixmapImageTile *t,uint x,uint y,const P *p)
    {
        C *v = &((C*)t->data)[(y*t->w+x)*5];
        CV_PUT( v++, *p++ );
        CV_PUT( v++, *p++ );
        CV_PUT( v++, *p++ );
        CV_PUT( v++, *p++ );
        CV_PUT( v,   *p   );
    }
    
    // Standard function selection matrix for types with 8 and 16 bytes 
    // as well as flts. 
    // MethSelMatrix[nchannels][bytes]
    //  where bytes=0 -> flt
    //              1 -> uint8
    //              2 -> uint16
    //  and nchannels is the number of channels minus 1 (i.e. starts at 0). 
    static const int STD_MAX_CHANNELS=5;
    static const PixmapImageTile::Methods MethSelMatrix[STD_MAX_CHANNELS][3];
    
    // *************************************************************************
    // Special versions for 555 (packed): 
    static void getpixel8_555(const PixmapImageTile *t,uint x,uint y,uint8 *p)
    {
        uint16 v=((const uint16*)t->data)[y*t->w+x];
        *p++ = v >> 10;
        *p++ = (v >> 5) & 31U;
        *p   = v & 31U;
    }
    static void getpixel16_555(const PixmapImageTile *t,uint x,uint y,uint16 *p)
    {
        uint16 v=((const uint16*)t->data)[y*t->w+x];
        *p++ = v >> 10;
        *p++ = (v >> 5) & 31U;
        *p   = v & 31U;
    }
    static void getpixelF_555(const PixmapImageTile *t,uint x,uint y,flt *p)
    {
        uint16 v=((const uint16*)t->data)[y*t->w+x];
        *p++ = P2F_5(v >> 10);
        *p++ = P2F_5((v >> 5) & 31U);
        *p   = P2F_5(v & 31U);
    }
    static void putpixel8_555(PixmapImageTile *t,uint x,uint y,const uint8 *p)
    {
        uint16 v = *p++;
        v<<=5;  v|= *p++;
        v<<=5;  v|= *p;
        ((uint16*)t->data)[y*t->w+x] = v;
    }
    static void putpixel16_555(PixmapImageTile *t,uint x,uint y,const uint16 *p)
    {
        uint16 v = *p++;
        v<<=5;  v|= *p++;
        v<<=5;  v|= *p;
        ((uint16*)t->data)[y*t->w+x] = v;
    }
    static void putpixelF_555(PixmapImageTile *t,uint x,uint y,const flt *p)
    {
        uint16 v = F2P_5(*p++);
        v<<=5;  v|= F2P_5(*p++);
        v<<=5;  v|= F2P_5(*p);
        ((uint16*)t->data)[y*t->w+x] = v;
    }
    
    // *************************************************************************
    // Special versions for 565 (packed): 
    static void getpixel8_565(const PixmapImageTile *t,uint x,uint y,uint8 *p)
    {
        uint16 v=((const uint16*)t->data)[y*t->w+x];
        *p++ = v >> 11;
        *p++ = (v >> 5) & 63U;
        *p   = v & 31U;
    }
    static void getpixel16_565(const PixmapImageTile *t,uint x,uint y,uint16 *p)
    {
        uint16 v=((const uint16*)t->data)[y*t->w+x];
        *p++ = v >> 11;
        *p++ = (v >> 5) & 63U;
        *p   = v & 31U;
    }
    static void getpixelF_565(const PixmapImageTile *t,uint x,uint y,flt *p)
    {
        uint16 v=((const uint16*)t->data)[y*t->w+x];
        *p++ = P2F_5(v >> 11);
        *p++ = P2F_6((v >> 5) & 63U);
        *p   = P2F_5(v & 31U);
    }
    static void putpixel8_565(PixmapImageTile *t,uint x,uint y,const uint8 *p)
    {
        uint16 v = *p++;
        v<<=5;  v|= *p++;
        v<<=6;  v|= *p;
        ((uint16*)t->data)[y*t->w+x] = v;
    }
    static void putpixel16_565(PixmapImageTile *t,uint x,uint y,const uint16 *p)
    {
        uint16 v = *p++;
        v<<=5;  v|= *p++;
        v<<=6;  v|= *p;
        ((uint16*)t->data)[y*t->w+x] = v;
    }
    static void putpixelF_565(PixmapImageTile *t,uint x,uint y,const flt *p)
    {
        uint16 v = F2P_5(*p++);
        v<<=5;  v|= F2P_6(*p++);
        v<<=6;  v|= F2P_5(*p);
        ((uint16*)t->data)[y*t->w+x] = v;
    }
    
    // Method structures for 555 and 565 packed into 2 bytes: 
    static const PixmapImageTile::Methods Meth_555;
    static const PixmapImageTile::Methods Meth_565;
    
    // *************************************************************************
    // Special versions for 1 bit black/white bitmaps (packed): 
    static void getpixel8_1(const PixmapImageTile *t,uint x,uint y,uint8 *p)
    {
        size_t idx = y*t->w+x;
        *p = ( ( ((const uint8*)t->data)[idx>>3] ) >> (idx & 7U)) & 1U;
    }
    static void getpixel16_1(const PixmapImageTile *t,uint x,uint y,uint16 *p)
    {
        size_t idx = y*t->w+x;
        *p = ( ( ((const uint8*)t->data)[idx>>3] ) >> (idx & 7U)) & 1U;
    }
    static void getpixelF_1(const PixmapImageTile *t,uint x,uint y,flt *p)
    {
        size_t idx = y*t->w+x;
        *p = flt(( ( ((const uint8*)t->data)[idx>>3] ) >> (idx & 7U)) & 1U);
    }
    static void putpixel8_1(PixmapImageTile *t,uint x,uint y,const uint8 *p)
    {
        size_t idx = y*t->w+x;
        if(*p)  ((uint8*)t->data)[idx>>3] |= 1U << (idx & 7U);
        else    ((uint8*)t->data)[idx>>3] &= ~uint8( 1U << (idx & 7U) );
    }
    static void putpixel16_1(PixmapImageTile *t,uint x,uint y,const uint16 *p)
    {
        size_t idx = y*t->w+x;
        if(*p)  ((uint8*)t->data)[idx>>3] |= 1U << (idx & 7U);
        else    ((uint8*)t->data)[idx>>3] &= ~uint8( 1U << (idx & 7U) );
    }
    static void putpixelF_1(PixmapImageTile *t,uint x,uint y,const flt *p)
    {
        size_t idx = y*t->w+x;
        if(*p<0.5f)  ((uint8*)t->data)[idx>>3] &= ~uint8( 1U << (idx & 7U) );
        else         ((uint8*)t->data)[idx>>3] |= 1U << (idx & 7U);
    }
    
    // Method structures for 555 and 565 packed into 2 bytes: 
    static const PixmapImageTile::Methods Meth_1;
    
    // *************************************************************************
    // Special versions for 12 bit grayscale bitmaps (packed): 
    static void getpixel16_12(const PixmapImageTile *t,uint x,uint y,uint16 *p)
    {
        size_t idx = y*t->w+x;
        const uint8 *v=&((const uint8*)t->data)[(idx*3)/2]; // <--NOT (idx/2)*3
        if(idx&1)  /* odd  */  {  *p = (*v & 0xfU) | (uint16(v[1]) << 4);  }
        else       /* even */  {  *p = (uint16(*v) << 4) | (v[1] >> 4);  }
    }
    static void getpixelF_12(const PixmapImageTile *t,uint x,uint y,flt *p)
    {
        CritAssert(!"!implemented");
    }
    static void putpixel16_12(PixmapImageTile *t,uint x,uint y,const uint16 *p)
    {
        size_t idx = y*t->w+x;
        uint8 *v=&((uint8*)t->data)[(idx*3)/2]; // <--NOT (idx/2)*3
        if(idx&1)  /* odd  */
        {  *v = (*v & 0xf0U) | ( *p & 0xfU );  v[1] = *p >> 4;  }
        else       /* even */
        {  *v = *p >> 4;  v[1] = (v[1] & 0xfU) | ( (*p & 0xfU) << 4 );  }
    }
    static void putpixelF_12(PixmapImageTile *t,uint x,uint y,const flt *p)
    {
        CritAssert(!"!implemented");
    }
    
    // Method structures for 555 and 565 packed into 2 bytes: 
    static const PixmapImageTile::Methods Meth_12;
};


const PixmapImageTile::Methods 
    PixmapImageTileInternal::MethSelMatrix[STD_MAX_CHANNELS][3]=
{
    // 1 CHANNEL: 
    {
        // STORAGE = flt
        {
            &no_getpixel8,
            &no_getpixel16,
            &getpixel_1<flt,flt>,
            &no_putpixel8,
            &no_putpixel16,
            &putpixel_1<flt,flt>
        },
        // STORAGE = UINT8
        {
            &getpixel_1<uint8,uint8>,
            &getpixel_1<uint8,uint16>,
            &getpixel_1<uint8,flt>,
            &putpixel_1<uint8,uint8>,
            &putpixel_1<uint8,uint16>,
            &putpixel_1<uint8,flt>
        },
        // STORAGE = UINT16
        {
            &no_getpixel8,
            &getpixel_1<uint16,uint16>,
            &getpixel_1<uint16,flt>,
            &no_putpixel8,
            &putpixel_1<uint16,uint16>,
            &putpixel_1<uint16,flt>
        }
    },
    // 2 CHANNELS: 
    {
        // STORAGE = flt
        {
            &no_getpixel8,
            &no_getpixel16,
            &getpixel_2<flt,flt>,
            &no_putpixel8,
            &no_putpixel16,
            &putpixel_2<flt,flt>
        },
        // STORAGE = UINT8
        {
            &getpixel_2<uint8,uint8>,
            &getpixel_2<uint8,uint16>,
            &getpixel_2<uint8,flt>,
            &putpixel_2<uint8,uint8>,
            &putpixel_2<uint8,uint16>,
            &putpixel_2<uint8,flt>
        },
        // STORAGE = UINT16
        {
            &no_getpixel8,
            &getpixel_2<uint16,uint16>,
            &getpixel_2<uint16,flt>,
            &no_putpixel8,
            &putpixel_2<uint16,uint16>,
            &putpixel_2<uint16,flt>
        }
    },
    // 3 CHANNELS: 
    {
        // STORAGE = flt
        {
            &no_getpixel8,
            &no_getpixel16,
            &getpixel_3<flt,flt>,
            &no_putpixel8,
            &no_putpixel16,
            &putpixel_3<flt,flt>
        },
        // STORAGE = UINT8
        {
            &getpixel_3<uint8,uint8>,
            &getpixel_3<uint8,uint16>,
            &getpixel_3<uint8,flt>,
            &putpixel_3<uint8,uint8>,
            &putpixel_3<uint8,uint16>,
            &putpixel_3<uint8,flt>
        },
        // STORAGE = UINT16
        {
            &no_getpixel8,
            &getpixel_3<uint16,uint16>,
            &getpixel_3<uint16,flt>,
            &no_putpixel8,
            &putpixel_3<uint16,uint16>,
            &putpixel_3<uint16,flt>
        }
    },
    // 4 CHANNELS: 
    {
        // STORAGE = flt
        {
            &no_getpixel8,
            &no_getpixel16,
            &getpixel_4<flt,flt>,
            &no_putpixel8,
            &no_putpixel16,
            &putpixel_4<flt,flt>
        },
        // STORAGE = UINT8
        {
            &getpixel_4<uint8,uint8>,
            &getpixel_4<uint8,uint16>,
            &getpixel_4<uint8,flt>,
            &putpixel_4<uint8,uint8>,
            &putpixel_4<uint8,uint16>,
            &putpixel_4<uint8,flt>
        },
        // STORAGE = UINT16
        {
            &no_getpixel8,
            &getpixel_4<uint16,uint16>,
            &getpixel_4<uint16,flt>,
            &no_putpixel8,
            &putpixel_4<uint16,uint16>,
            &putpixel_4<uint16,flt>
        }
    },
    // 5 CHANNELS: 
    {
        // STORAGE = flt
        {
            &no_getpixel8,
            &no_getpixel16,
            &getpixel_5<flt,flt>,
            &no_putpixel8,
            &no_putpixel16,
            &putpixel_5<flt,flt>
        },
        // STORAGE = UINT8
        {
            &getpixel_5<uint8,uint8>,
            &getpixel_5<uint8,uint16>,
            &getpixel_5<uint8,flt>,
            &putpixel_5<uint8,uint8>,
            &putpixel_5<uint8,uint16>,
            &putpixel_5<uint8,flt>
        },
        // STORAGE = UINT16
        {
            &no_getpixel8,
            &getpixel_5<uint16,uint16>,
            &getpixel_5<uint16,flt>,
            &no_putpixel8,
            &putpixel_5<uint16,uint16>,
            &putpixel_5<uint16,flt>
        }
    }
};

const PixmapImageTile::Methods PixmapImageTileInternal::Meth_555=
{
    &getpixel8_555,  &getpixel16_555,  &getpixelF_555,
    &putpixel8_555,  &putpixel16_555,  &putpixelF_555
};

const PixmapImageTile::Methods PixmapImageTileInternal::Meth_565=
{
    &getpixel8_565,  &getpixel16_565,  &getpixelF_565,
    &putpixel8_565,  &putpixel16_565,  &putpixelF_565
};


const PixmapImageTile::Methods PixmapImageTileInternal::Meth_1=
{
    &getpixel8_1,  &getpixel16_1,  &getpixelF_1,
    &putpixel8_1,  &putpixel16_1,  &putpixelF_1
};


const PixmapImageTile::Methods PixmapImageTileInternal::Meth_12=
{
    &no_getpixel8,  &getpixel16_12,  &getpixelF_12,
    &no_putpixel8,  &putpixel16_12,  &putpixelF_12
};



void PixmapImageTile::_ZapPixelFuncs()
{
    meth.getpixel8= &PixmapImageTileInternal::no_getpixel8;
    meth.getpixel16=&PixmapImageTileInternal::no_getpixel16;
    meth.getpixelF= &PixmapImageTileInternal::no_getpixelF;
    meth.putpixel8= &PixmapImageTileInternal::no_putpixel8;
    meth.putpixel16=&PixmapImageTileInternal::no_putpixel16;
    meth.putpixelF= &PixmapImageTileInternal::no_putpixelF;
}


int PixmapImageTile::_SetPixelFuncs(const PixmapFormat &pf)
{
    _ZapPixelFuncs();
    size=0;
    
    // Choose the correct pixel functions: 
    do {
        // Well, the "None" format is "supported" in that it resets the 
        // format to "unset": 
        if(pf==PixmapFormat::None)  break;
        
        // First, see if it is in our standard selection matrix: 
        // These are all formats with 1 to 5 channels and 8 or 16 bits 
        // or flt value storage. 
        int nchan=pf.nchannels();
        if(nchan>=1 && nchan<PixmapImageTileInternal::STD_MAX_CHANNELS)  // <-- CORRECT!
        {
            // See if all channels have same size: 8,16 or flt. 
            const PixmapImageTile::Methods *usemeth=NULL;
            int bytes_per_channel=0;
            switch(pf.SameBitsForAll())
            {
                case PixmapFormat::FloatBits:
                    usemeth=&PixmapImageTileInternal::MethSelMatrix[nchan-1][0];
                    bytes_per_channel=sizeof(flt);
                    break;
                case 8:
                    usemeth=&PixmapImageTileInternal::MethSelMatrix[nchan-1][1];
                    bytes_per_channel=1;
                    break;
                case 16:
                    usemeth=&PixmapImageTileInternal::MethSelMatrix[nchan-1][2];
                    bytes_per_channel=2;
                    break;
                //default: usemeth stays NULL
            }
            if(usemeth)
            {
                // Assign the pixel functions: 
                meth=*usemeth;
                
                // Compute the image size in bytes: 
                size=(size_t)w*h*nchan*bytes_per_channel;
                
                break;
            }
        }
        
        // Next, see if this is a specially supported format: 
        if(pf.nchannels()==3 && pf.bits(0)==5 && pf.bits(2)==5)
        {
            if(pf.bits(1)==5)
            {
                // Assign the pixel functions: 
                meth=PixmapImageTileInternal::Meth_555;
                
                // Compute the image size in bytes: 
                size=(size_t)w*h*2;
                
                break;
            }
            else if(pf.bits(1)==6)
            {
                // Assign the pixel functions: 
                meth=PixmapImageTileInternal::Meth_565;
                
                // Compute the image size in bytes: 
                size=(size_t)w*h*2;
            }
        }
        
        // One channel bitmap format?
        if(pf.nchannels()==1 && pf.bits(0)==1)
        {
            // Assign the pixel functions: 
            meth=PixmapImageTileInternal::Meth_1;
            
            // Compute the image size in bytes: 
            size=((size_t)w*h+7)/8;
        }
        
        // Otherwise, it is a non-supported image format. 
        return(1);
    } while(0);
    
    return(0);
}


void PixmapImageTile::setup(const PixmapFormat &pf,uint _width,uint _height)
{
    w=_width;
    h=_height;
    int rv=_SetPixelFuncs(pf);
    CritAssert(rv==0);   // Fail on non-supported formats. (FIXME?)
    // Data is not allocated. 
}


PixmapImageTile::PixmapImageTile() : 
    w(0),h(0),
    size(0),
    data(NULL)
{
    _ZapPixelFuncs();
}

PixmapImageTile::PixmapImageTile(const PixmapFormat &pf,
    uint _width,uint _height) : 
    w(_width),h(_height)
{
    data=NULL;
    
    int rv=_SetPixelFuncs(pf);
    CritAssert(rv==0);   // Fail on non-supported formats. (FIXME?)
    // Data is not allocated. 
}

PixmapImageTile::~PixmapImageTile()
{
    // Data must have been freed (no...). 
    //Assert(!data);
}

---