stb/stb_image_resize_test/stbirtest.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//#define HEAVYTM
#include "tm.h"

#ifdef RADUSETM3
tm_api * g_tm_api;
//#define PROFILE_MODE
#endif

#include <math.h>

#ifdef _MSC_VER
#define stop() __debugbreak()
#include <windows.h>
#define int64 __int64
#define uint64 unsigned __int64
#else
#define stop() __builtin_trap()
#define int64 long long
#define uint64 unsigned long long
#endif

#ifdef _MSC_VER
#pragma warning(disable:4127)
#endif

//#define NOCOMP


//#define PROFILE_NEW_ONLY
//#define PROFILE_MODE


#if defined(_x86_64) || defined( __x86_64__ ) || defined( _M_X64 ) || defined(__x86_64) || defined(__SSE2__) || defined(STBIR_SSE) || defined( _M_IX86_FP ) || defined(__i386) || defined( __i386__ ) || defined( _M_IX86 ) || defined( _X86_ )

#ifdef _MSC_VER

  uint64 __rdtsc();
  #define __cycles() __rdtsc()

#else // non msvc

  static inline uint64 __cycles() 
  {
    unsigned int lo, hi;
    asm volatile ("rdtsc" : "=a" (lo), "=d" (hi) );
    return ( ( (uint64) hi ) << 32 ) | ( (uint64) lo );
  }

#endif  // msvc

#elif defined( _M_ARM64 ) || defined( __aarch64__ ) || defined( __arm64__ ) || defined(__ARM_NEON__) 

#ifdef _MSC_VER

  #define __cycles() _ReadStatusReg(ARM64_CNTVCT)

#else

  static inline uint64 __cycles()
  {
    uint64 tsc;
    asm volatile("mrs %0, cntvct_el0" : "=r" (tsc));
    return tsc;
  }

#endif

#else // x64, arm

#error Unknown platform for timing.

#endif  //x64 and   


#ifdef PROFILE_MODE

#define STBIR_ASSERT(cond)

#endif

#ifdef _DEBUG
#undef STBIR_ASSERT
#define STBIR_ASSERT(cond) { if (!(cond)) stop(); }
#endif


#define SHRINKBYW 2
#define ZOOMBYW 2
#define SHRINKBYH 2
#define ZOOMBYH 2


int mem_count = 0;

#ifdef TEST_WITH_VALLOC

#define STBIR__SEPARATE_ALLOCATIONS

#if TEST_WITH_LIMIT_AT_FRONT

  void * wmalloc(SIZE_T size)
  {
     static unsigned int pagesize=0;
     void* p;
     SIZE_T s;

     // get the page size, if we haven't yet
     if (pagesize==0)
     {
       SYSTEM_INFO si;
       GetSystemInfo(&si);
       pagesize=si.dwPageSize;
     }

     // we need room for the size, 8 bytes to hide the original pointer and a
     //   validation dword, and enough data to completely fill one page
     s=(size+(pagesize-1))&~(pagesize-1);

     // allocate the size plus a page (for the guard)
     p=VirtualAlloc(0,(SIZE_T)s,MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
     
     return p;
   }

  void wfree(void * ptr)
  {
    if (ptr)
    {
      if ( ((ptrdiff_t)ptr) & 4095 ) stop();
      if ( VirtualFree(ptr,0,MEM_RELEASE) == 0 ) stop();
    }
  }

#else

  void * wmalloc(SIZE_T size)
  {
     static unsigned int pagesize=0;
     void* p;
     SIZE_T s;

     // get the page size, if we haven't yet
     if (pagesize==0)
     {
       SYSTEM_INFO si;
       GetSystemInfo(&si);
       pagesize=si.dwPageSize;
     }

     // we need room for the size, 8 bytes to hide the original pointer and a
     //   validation dword, and enough data to completely fill one page
     s=(size+16+(pagesize-1))&~(pagesize-1);

     // allocate the size plus a page (for the guard)
     p=VirtualAlloc(0,(SIZE_T)(s+pagesize+pagesize),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);

     if (p)
     {
       DWORD oldprot;
       void* orig=p;

       // protect the first page
       VirtualProtect(((char*)p),pagesize,PAGE_NOACCESS,&oldprot);

       // protect the final page
       VirtualProtect(((char*)p)+s+pagesize,pagesize,PAGE_NOACCESS,&oldprot);

       // now move the returned pointer so that it bumps right up against the
       //   the next (protected) page (this may result in unaligned return
       //   addresses - pre-align the sizes if you always want aligned ptrs)
//#define ERROR_ON_FRONT
#ifdef ERROR_ON_FRONT
       p=((char*)p)+pagesize+16;
#else
       p=((char*)p)+(s-size)+pagesize;
#endif

       // hide the validation value and the original pointer (which we'll
       //   need used for freeing) right behind the returned pointer
       ((unsigned int*)p)[-1]=0x98765432;
       ((void**)p)[-2]=orig;
       ++mem_count;
//printf("aloc: %p bytes: %d\n",p,(int)size);
       return(p);
     }

     return 0;
  }

  void wfree(void * ptr)
  {
    if (ptr)
    {
      int err=0;

      // is this one of our allocations?
      if (((((unsigned int*)ptr)[-1])!=0x98765432) || ((((void**)ptr)[-2])==0))
      {
        err=1;
      }

      if (err)
      {
        __debugbreak();
      }
      else
      {

        // back up to find the original pointer
        void* p=((void**)ptr)[-2];

        // clear the validation value and the original pointer
        ((unsigned int*)ptr)[-1]=0;
        ((void**)ptr)[-2]=0;

//printf("free: %p\n",ptr);

        --mem_count;

        // now free the pages
        if (p)
          VirtualFree(p,0,MEM_RELEASE);

      }
    }
  }

#endif

#define STBIR_MALLOC(size,user_data) ((void)(user_data), wmalloc(size))
#define STBIR_FREE(ptr,user_data)    ((void)(user_data), wfree(ptr))

#endif

#define STBIR_PROFILE
//#define STBIR_NO_SIMD
//#define STBIR_AVX
//#define STBIR_AVX2
#define STB_IMAGE_RESIZE_IMPLEMENTATION
#include "stb_image_resize2.h"  // new one!

#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"

int tsizes[5] =   { 1, 1, 2, 4, 2 };
int ttypes[5] =   { STBIR_TYPE_UINT8, STBIR_TYPE_UINT8_SRGB, STBIR_TYPE_UINT16, STBIR_TYPE_FLOAT, STBIR_TYPE_HALF_FLOAT };

int cedges[4] =   { STBIR_EDGE_CLAMP, STBIR_EDGE_REFLECT, STBIR_EDGE_ZERO, STBIR_EDGE_WRAP };
int flts[5] =     { STBIR_FILTER_BOX, STBIR_FILTER_TRIANGLE, STBIR_FILTER_CUBICBSPLINE, STBIR_FILTER_CATMULLROM, STBIR_FILTER_MITCHELL };
int buffers[20] = { STBIR_1CHANNEL, STBIR_2CHANNEL, STBIR_RGB, STBIR_4CHANNEL, 
                    STBIR_BGRA, STBIR_ARGB, STBIR_RA, STBIR_AR,
                    STBIR_RGBA_PM, STBIR_ARGB_PM, STBIR_RA_PM, STBIR_AR_PM,
                    STBIR_RGBA, STBIR_ARGB, STBIR_RA, STBIR_AR,
                    STBIR_RGBA_PM, STBIR_ARGB_PM, STBIR_RA_PM, STBIR_AR_PM,
                  };
int obuffers[20] = { STBIR_1CHANNEL, STBIR_2CHANNEL, STBIR_RGB, STBIR_4CHANNEL, 
                     STBIR_BGRA, STBIR_ARGB, STBIR_RA, STBIR_AR,
                     STBIR_RGBA_PM, STBIR_ARGB_PM, STBIR_RA_PM, STBIR_AR_PM,
                     STBIR_RGBA_PM, STBIR_ARGB_PM, STBIR_RA_PM, STBIR_AR_PM,
                     STBIR_RGBA, STBIR_ARGB, STBIR_RA, STBIR_AR,
                   };

int bchannels[20] = { 1, 2, 3, 4,  4,4, 2,2,  4,4, 2,2,  4,4, 2,2,  4,4, 2,2  }; 
int alphapos[20] = { -1, -1, -1, -1,  3,0,  1,0,   3,0,  1,0,   3,0,  1,0,3,0,  1,0 }; 


char const * buffstrs[20] = { "1ch", "2ch", "3ch", "4ch",  "RGBA", "ARGB", "RA", "AR",  "RGBA_both_pre", "ARGB_both_pre", "RA_both_pre", "AR_both_pre",  "RGBA_out_pre", "ARGB_out_pre", "RA_out_pre", "AR_out_pre",  "RGBA_in_pre", "ARGB_in_pre", "RA_in_pre", "AR_in_pre" };
char const * typestrs[5] =  { "Bytes", "BytesSRGB", "Shorts", "Floats", "Half Floats"};
char const * edgestrs[4] =  { "Clamp", "Reflect", "Zero", "Wrap" };
char const * fltstrs[5] =   { "Box", "Triangle", "Cubic", "Catmullrom", "Mitchell" };

#ifdef STBIR_PROFILE
  static void do_acc_zones( STBIR_PROFILE_INFO * profile )
  {
    stbir_uint32 j;
    stbir_uint64 start = tmGetAccumulationStart( tm_mask ); start=start;

    for( j = 0 ; j < profile->count ; j++ )
    {
      if ( profile->clocks[j] )
        tmEmitAccumulationZone( 0, 0, (tm_uint64*)&start, 0, profile->clocks[j], profile->descriptions[j] );
    }
  }
#else
  #define do_acc_zones(...)
#endif

int64 vert;

//#define WINTHREADTEST
#ifdef WINTHREADTEST

static STBIR_RESIZE * thread_resize;
static LONG which;
static int threads_started = 0;
static HANDLE threads[32];
static HANDLE starts,stops;
  
static DWORD resize_shim( LPVOID p )
{
  for(;;)
  {
    LONG wh;

    WaitForSingleObject( starts, INFINITE );

    wh = InterlockedAdd( &which, 1 ) - 1;

    ENTER( "Split %d", wh );
    stbir_resize_split( thread_resize, wh, 1 );
  #ifdef STBIR_PROFILE
    { STBIR_PROFILE_INFO profile; stbir_resize_split_profile_info( &profile, thread_resize, wh, 1 ); do_acc_zones( &profile ); vert = profile.clocks[1]; }
  #endif
    LEAVE();

    ReleaseSemaphore( stops, 1, 0 );
  }
}

#endif

void nresize( void * o, int ox, int oy, int op, void * i, int ix, int iy, int ip, int buf, int type, int edg, int flt )
{
  STBIR_RESIZE resize;
 
  stbir_resize_init( &resize, i, ix, iy, ip, o, ox, oy, op, buffers[buf], ttypes[type] );
  stbir_set_pixel_layouts( &resize, buffers[buf], obuffers[buf] );
  stbir_set_edgemodes( &resize, cedges[edg], cedges[edg] );
  stbir_set_filters( &resize, flts[flt], /*STBIR_FILTER_POINT_SAMPLE */ flts[flt] );
  //stbir_set_input_subrect( &resize, 0.55f,0.333f,0.75f,0.50f);
  //stbir_set_output_pixel_subrect( &resize, 00, 00, ox/2,oy/2);
  //stbir_set_pixel_subrect(&resize, 1430,1361,30,30);
  
  ENTER( "Resize" );
 
  #ifndef WINTHREADTEST

  ENTER( "Filters" );
  stbir_build_samplers_with_splits( &resize, 1 );
  #ifdef STBIR_PROFILE
    { STBIR_PROFILE_INFO profile; stbir_resize_build_profile_info( &profile, &resize ); do_acc_zones( &profile ); }
  #endif
  LEAVE();
 
  ENTER( "Resize" );
  if(!stbir_resize_extended( &resize ) )
    stop();
  #ifdef STBIR_PROFILE
    { STBIR_PROFILE_INFO profile; stbir_resize_extended_profile_info( &profile, &resize ); do_acc_zones( &profile ); vert = profile.clocks[1]; }
  #endif
  LEAVE();

  #else
  {
    int c, cnt;
 
    ENTER( "Filters" );
    cnt =  stbir_build_samplers_with_splits( &resize, 4 );
    #ifdef STBIR_PROFILE
      { STBIR_PROFILE_INFO profile; stbir_resize_build_profile_info( &profile, &resize ); do_acc_zones( &profile ); }
    #endif
    LEAVE();
    
    ENTER( "Thread start" );
    if ( threads_started == 0 )
    {
      starts = CreateSemaphore( 0, 0, 32, 0 );
      stops = CreateSemaphore( 0, 0, 32, 0 );
    }
    for( c = threads_started ; c < cnt ; c++ )
      threads[ c ] = CreateThread( 0, 2048*1024, resize_shim, 0, 0, 0 );
    
    threads_started = cnt;
    thread_resize = &resize;
    which = 0;
    LEAVE();

    // starts the threads
    ReleaseSemaphore( starts, cnt, 0 );

    ENTER( "Wait" );
    for( c = 0 ; c < cnt; c++ )
      WaitForSingleObject( stops, INFINITE );
    LEAVE();
  }
  #endif

  ENTER( "Free" );
  stbir_free_samplers( &resize );
  LEAVE();
  LEAVE();
}


#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

extern void oresize( void * o, int ox, int oy, int op, void * i, int ix, int iy, int ip, int buf, int type, int edg, int flt );



#define TYPESTART 0
#define TYPEEND   4

#define LAYOUTSTART  0
#define LAYOUTEND   19

#define SIZEWSTART 0
#define SIZEWEND   2

#define SIZEHSTART 0
#define SIZEHEND   2

#define EDGESTART 0
#define EDGEEND   3

#define FILTERSTART 0
#define FILTEREND   4

#define HEIGHTSTART 0
#define HEIGHTEND   2

#define WIDTHSTART 0
#define WIDTHEND   2




static void * convert8to16( unsigned char * i, int w, int h, int c )
{
  unsigned short * ret;
  int p;

  ret = malloc( w*h*c*sizeof(short) );
  for(p = 0 ; p < (w*h*c) ; p++ )
  {
    ret[p]=(short)((((int)i[p])<<8)+i[p]);
  }

  return ret;
}

static void * convert8tof( unsigned char * i, int w, int h, int c )
{
  float * ret;
  int p;

  ret = malloc( w*h*c*sizeof(float) );
  for(p = 0 ; p < (w*h*c) ; p++ )
  {
    ret[p]=((float)i[p])*(1.0f/255.0f);
  }

  return ret;
}

static void * convert8tohf( unsigned char * i, int w, int h, int c )
{
  stbir__FP16 * ret;
  int p;

  ret = malloc( w*h*c*sizeof(stbir__FP16) );
  for(p = 0 ; p < (w*h*c) ; p++ )
  {
    ret[p]=stbir__float_to_half(((float)i[p])*(1.0f/255.0f));
  }

  return ret;
}

static void * convert8tohff( unsigned char * i, int w, int h, int c )
{
  float * ret;
  int p;

  ret = malloc( w*h*c*sizeof(float) );
  for(p = 0 ; p < (w*h*c) ; p++ )
  {
    ret[p]=stbir__half_to_float(stbir__float_to_half(((float)i[p])*(1.0f/255.0f)));
  }

  return ret;
}

static int isprime( int v )
{
  int i;

  if ( v <= 3 )
    return ( v > 1 );
  if ( ( v & 1 ) == 0 )
    return 0;
  if ( ( v % 3 ) == 0 )
    return 0;
  i = 5;
  while ( (i*i) <= v )
  {
    if ( ( v % i ) == 0 )
      return 0;
    if ( ( v % ( i + 2 ) ) == 0 )
      return 0;
    i += 6;
  }

  return 1;
}

static int getprime( int v )
{
  int i;
  i = 0;
  for(;;)
  {
    if ( i >= v )
      return v;  // can't find any, just return orig
    if (isprime(v - i))
      return v - i;
    if (isprime(v + i))
      return v + i;
    ++i;
  }
}


int main( int argc, char ** argv )
{
  int ix, iy, ic;
  unsigned char * input[6];
  char * ir1;
  char * ir2;
  int szhs[3];
  int szws[3];
  int aw, ah, ac;
  unsigned char * correctalpha;
  int layouts, types, heights, widths, edges, filters;

  if ( argc != 2 )
  {
    printf("command: stbirtest [imagefile]\n");
    exit(1);
  }

  SetupTM( "127.0.0.1" );

  correctalpha = stbi_load( "correctalpha.png", &aw, &ah, &ac, 0 );

  input[0] = stbi_load( argv[1], &ix, &iy, &ic, 0 );
  input[1] = input[0];
  input[2] = convert8to16( input[0], ix, iy, ic );
  input[3] = convert8tof( input[0], ix, iy, ic );
  input[4] = convert8tohf( input[0], ix, iy, ic );
  input[5] = convert8tohff( input[0], ix, iy, ic );

  printf("Input %dx%d (%d channels)\n",ix,iy,ic);

  ir1 = malloc( 4 * 4 * 3000 * 3000ULL );
  ir2 = malloc( 4 * 4 * 3000 * 3000ULL );

  szhs[0] = getprime( iy/SHRINKBYH );
  szhs[1] = iy;
  szhs[2] = getprime( iy*ZOOMBYH );

  szws[0] = getprime( ix/SHRINKBYW );
  szws[1] = ix;
  szws[2] = getprime( ix*ZOOMBYW );

  #if 1
  for( types = TYPESTART ; types <= TYPEEND ; types++ )
  #else
  for( types = 1 ; types <= 1 ; types++ )
  #endif
  {
    ENTER( "Test type: %s",typestrs[types]);
    #if 1
    for( layouts = LAYOUTSTART ; layouts <= LAYOUTEND ; layouts++ )
    #else
    for( layouts = 16; layouts <= 16 ; layouts++ )
    #endif
    {
      ENTER( "Test layout: %s",buffstrs[layouts]);
      
      #if 0
      for( heights = HEIGHTSTART ; heights <= HEIGHTEND ; heights++ )
      {
        int w, h = szhs[heights];
      #else
      for( heights = 0 ; heights <= 11 ; heights++ )
      {
        static int szhsz[12]={32, 200, 350, 400, 450, 509, 532, 624, 700, 824, 1023, 2053 };
        int w, h = szhsz[heights];
      #endif

        ENTER( "Test height: %d %s %d",iy,(h<iy)?"Down":((h>iy)?"Up":"Same"),h);
  
        #if 0
        for( widths = WIDTHSTART ; widths <= WIDTHEND ; widths++ )
        {
          w = szws[widths];
        #else
        for( widths = 0 ; widths <= 12 ; widths++ )
        {
          static int szwsz[13]={2, 32, 200, 350, 400, 450, 509, 532, 624, 700, 824, 1023, 2053 };
          w = szwsz[widths];
        #endif

          ENTER( "Test width: %d %s %d",ix, (w<ix)?"Down":((w>ix)?"Up":"Same"), w);

          #if 0
          for( edges = EDGESTART ; edges <= EDGEEND ; edges++ )
          #else
          for( edges = 0 ; edges <= 0 ; edges++ )
          #endif
          {
            ENTER( "Test edge: %s",edgestrs[edges]);
            #if 0
            for( filters = FILTERSTART ; filters <= FILTEREND ; filters++ )
            #else
            for( filters = 3 ; filters <= 3 ; filters++ )
            #endif
            {
              int op, opw, np,npw, c, a;
              #ifdef COMPARE_SAME                        
              int oldtypes = types;
              #else
              int oldtypes = (types==4)?3:types;
              #endif
            
              ENTER( "Test filter: %s",fltstrs[filters]);
              {
                c = bchannels[layouts];
                a = alphapos[layouts];

                op = w*tsizes[oldtypes]*c + 60;
                opw = w*tsizes[oldtypes]*c;

                np = w*tsizes[types]*c + 60;
                npw = w*tsizes[types]*c;

                printf( "%s:layout: %s  w: %d h: %d edge: %s filt: %s\n", typestrs[types],buffstrs[layouts], w, h, edgestrs[edges], fltstrs[filters] );


                // clear pixel area to different, right edge to zero
                #ifndef NOCLEAR
                ENTER( "Test clear padding" );
                {
                  int d;
                  for( d = 0 ; d < h ; d++ )
                  {
                    int oofs = d * op;
                    int nofs = d * np;
                    memset( ir1 + oofs, 192, opw );
                    memset( ir1 + oofs+opw, 79, op-opw );
                    memset( ir2 + nofs, 255, npw );
                    memset( ir2 + nofs+npw, 79, np-npw );
                  }
                }
                LEAVE();

                #endif

                #ifdef COMPARE_SAME                        
                #define TIMINGS 1
                #else 
                #define TIMINGS 1
                #endif
                ENTER( "Test both" );
                {
                  #ifndef PROFILE_NEW_ONLY
                    {
                      int ttt, max = 0x7fffffff;
                      ENTER( "Test old" );
                      for( ttt = 0 ; ttt < TIMINGS ; ttt++ )
                      {
                        int64 m = __cycles();

                        oresize( ir1, w, h, op, 
                        #ifdef COMPARE_SAME                        
                        input[types], 
                        #else
                        input[(types==4)?5:types], 
                        #endif
                        ix, iy, ix*ic*tsizes[oldtypes], layouts, oldtypes, edges, filters );

                        m = __cycles() - m;
                        if ( ( (int)m ) < max )
                        max = (int) m;
                      }
                      LEAVE();
                      printf("old: %d\n", max );
                    }
                  #endif
     
                  {
                    int ttt, max = 0x7fffffff, maxv = 0x7fffffff;
                    ENTER( "Test new" );
                    for( ttt = 0 ; ttt < TIMINGS ; ttt++ )
                    {
                      int64 m = __cycles();

                      nresize( ir2, w, h, np, input[types], ix, iy, ix*ic*tsizes[types], layouts, types, edges, filters );
        
                      m = __cycles() - m;
                      if ( ( (int)m ) < max )
                        max = (int) m;
                      if ( ( (int)vert ) < maxv )
                        maxv = (int) vert;
                    }
                    LEAVE(); // test new
                    printf("new: %d (v: %d)\n", max, maxv );
                  }
                }
                LEAVE();  // test both

                if ( mem_count!= 0 )
                  stop();

              #ifndef NOCOMP
                ENTER( "Test compare" );
                {
                  int x,y,ch;
                  int nums = 0;
                  for( y = 0 ; y < h ; y++ )
                  {
                    for( x = 0 ; x < w ; x++ )
                    {
                      switch(types)
                      {
                        case 0:
                        case 1: //SRGB 
                        {
                          unsigned char * p1 = (unsigned char *)&ir1[y*op+x*c];
                          unsigned char * p2 = (unsigned char *)&ir2[y*np+x*c];
                          for( ch = 0 ; ch < c ; ch++ )
                          {
                            float pp1,pp2,d;
                            float av = (a==-1)?1.0f:((float)p1[a]/255.0f);

                            pp1 = p1[ch];
                            pp2 = p2[ch];

                            // compare in premult space
                            #ifndef COMPARE_SAME                        
                            if ( ( ( layouts >=4 ) && ( layouts <= 7 ) ) || ( ( layouts >=16 ) && ( layouts <= 19 ) ) )
                            {
                              pp1 *= av;
                              pp2 *= av;
                            }
                            #endif

                            d = pp1 - pp2;
                            if ( d < 0 ) d = -d;

                            #ifdef COMPARE_SAME                        
                            if ( d > 0 ) 
                            #else 
                            if ( d > 1 )
                            #endif
                            {
                              printf("Error at %d x %d (chan %d) (d: %g a: %g) [%d %d %d %d] [%d %d %d %d]\n",x,y,ch, d,av, p1[0],p1[1],p1[2],p1[3], p2[0],p2[1],p2[2],p2[3]);
                              ++nums;
                              if ( nums > 16 ) goto ex;
                              //if (d) exit(1);
                              //goto ex;
                            }
                          }  
                        }
                        break;

                        case 2:
                        {
                          unsigned short * p1 = (unsigned short *)&ir1[y*op+x*c*sizeof(short)];
                          unsigned short * p2 = (unsigned short *)&ir2[y*np+x*c*sizeof(short)];
                          for( ch = 0 ; ch < c ; ch++ )
                          {
                            float thres,pp1,pp2,d;
                            float av = (a==-1)?1.0f:((float)p1[a]/65535.0f);

                            pp1 = p1[ch];
                            pp2 = p2[ch];

                            // compare in premult space
                            #ifndef COMPARE_SAME                        
                            if ( ( ( layouts >=4 ) && ( layouts <= 7 ) ) || ( ( layouts >= 16 ) && ( layouts <= 19 ) ) )
                            {
                              pp1 *= av;
                              pp2 *= av;
                            }
                            #endif

                            d = pp1 - pp2;
                            if ( d < 0 ) d = -d;

                            thres=((float)p1[ch]*0.007f)+2.0f;
                            if (thres<4) thres = 4;
  
                            #ifdef COMPARE_SAME                        
                            if ( d > 0 ) 
                            #else 
                            if ( d > thres)
                            #endif
                            {
                              printf("Error at %d x %d (chan %d) %d %d [df: %g th: %g al: %g] (%d %d %d %d) (%d %d %d %d)\n",x,y,ch, p1[ch],p2[ch],d,thres,av,p1[0],p1[1],p1[2],p1[3],p2[0],p2[1],p2[2],p2[3]);
                              ++nums;
                              if ( nums > 16 ) goto ex;
                              //if (d) exit(1);
                              //goto ex;
                            }
                          }
                        }
                        break;

                        case 3:
                        {
                          float * p1 = (float *)&ir1[y*op+x*c*sizeof(float)];
                          float * p2 = (float *)&ir2[y*np+x*c*sizeof(float)];
                          for( ch = 0 ; ch < c ; ch++ )
                          {
                            float pp1 = p1[ch], pp2 = p2[ch];
                            float av = (a==-1)?1.0f:p1[a];
                            float thres, d;

                            // clamp
                            if (pp1<=0.0f) pp1 = 0;
                            if (pp2<=0.0f) pp2 = 0;
                            if (av<=0.0f) av = 0;
                            if (pp1>1.0f) pp1 = 1.0f;
                            if (pp2>1.0f) pp2 = 1.0f;
                            if (av>1.0f) av = 1.0f;

                            // compare in premult space
                            #ifndef COMPARE_SAME                        
                            if ( ( ( layouts >=4 ) && ( layouts <= 7 ) ) || ( ( layouts >= 16 ) && ( layouts <= 19 ) ) )
                            {
                              pp1 *= av;
                              pp2 *= av;
                            }
                            #endif

                            d = pp1 - pp2;
                            if ( d < 0 ) d = -d;

                            thres=(p1[ch]*0.002f)+0.0002f;
                            if ( thres < 0 ) thres = -thres;

                            #ifdef COMPARE_SAME                        
                            if ( d != 0.0f ) 
                            #else 
                            if ( d > thres )
                            #endif
                            {
                              printf("Error at %d x %d (chan %d) %g %g [df: %g th: %g al: %g] (%g %g %g %g) (%g %g %g %g)\n",x,y,ch, p1[ch],p2[ch],d,thres,av,p1[0],p1[1],p1[2],p1[3],p2[0],p2[1],p2[2],p2[3]);
                              ++nums;
                              if ( nums > 16 ) goto ex;
                              //if (d) exit(1);
                              //goto ex;
                            }
                          }
                        }
                        break;

                        case 4:
                        {
                          #ifdef COMPARE_SAME                        
                          stbir__FP16 * p1 = (stbir__FP16 *)&ir1[y*op+x*c*sizeof(stbir__FP16)];
                          #else
                          float * p1 = (float *)&ir1[y*op+x*c*sizeof(float)];
                          #endif
                          stbir__FP16 * p2 = (stbir__FP16 *)&ir2[y*np+x*c*sizeof(stbir__FP16)];
                          for( ch = 0 ; ch < c ; ch++ )
                          {
                            #ifdef COMPARE_SAME                        
                            float pp1  = stbir__half_to_float(p1[ch]);
                            float av = (a==-1)?1.0f:stbir__half_to_float(p1[a]);
                            #else
                            float pp1 = stbir__half_to_float(stbir__float_to_half(p1[ch]));
                            float av = (a==-1)?1.0f:stbir__half_to_float(stbir__float_to_half(p1[a]));
                            #endif
                            float pp2 = stbir__half_to_float(p2[ch]);
                            float d, thres;

                            // clamp
                            if (pp1<=0.0f) pp1 = 0;
                            if (pp2<=0.0f) pp2 = 0;
                            if (av<=0.0f) av = 0;
                            if (pp1>1.0f) pp1 = 1.0f;
                            if (pp2>1.0f) pp2 = 1.0f;
                            if (av>1.0f) av = 1.0f;

                            thres=(pp1*0.002f)+0.0002f;

                            // compare in premult space
                            #ifndef COMPARE_SAME                        
                            if ( ( ( layouts >=4 ) && ( layouts <= 7 ) ) || ( ( layouts >= 16 ) && ( layouts <= 19 ) ) )
                            {
                              pp1 *= av;
                              pp2 *= av;
                            }
                            #endif

                            d = pp1 - pp2;
                            if ( d < 0 ) d = -d;


                            #ifdef COMPARE_SAME                        
                            if ( d != 0.0f ) 
                            #else 
                            if ( d > thres )
                            #endif
                            {
                              printf("Error at %d x %d (chan %d) %g %g [df: %g th: %g al: %g] (%g %g %g %g) (%g %g %g %g)\n",x,y,ch, 
                              #ifdef COMPARE_SAME                        
                              stbir__half_to_float(p1[ch]), 
                              #else
                              p1[ch],
                              #endif
                              stbir__half_to_float(p2[ch]), 
                              d,thres,av,
                              #ifdef COMPARE_SAME                        
                              stbir__half_to_float(p1[0]),stbir__half_to_float(p1[1]),stbir__half_to_float(p1[2]),stbir__half_to_float(p1[3]),
                              #else
                              p1[0],p1[1],p1[2],p1[3],
                              #endif
                              stbir__half_to_float(p2[0]),stbir__half_to_float(p2[1]),stbir__half_to_float(p2[2]),stbir__half_to_float(p2[3]) );
                              ++nums;
                              if ( nums > 16 ) goto ex;
                              //if (d) exit(1);
                              //goto ex;
                            }
                          }
                        }
                        break;
                      }
                    }

                    for( x = (w*c)*tsizes[oldtypes]; x < op; x++ )
                    {
                      if ( ir1[y*op+x] != 79 )
                      {
                        printf("Margin error at %d x %d %d (should be 79) OLD!\n",x,y,(unsigned char)ir1[y*op+x]);
                        goto ex;
                      }
                    }

                    for( x = (w*c)*tsizes[types]; x < np; x++ )
                    {
                      if ( ir2[y*np+x] != 79 )
                      {
                        printf("Margin error at %d x %d %d (should be 79) NEW\n",x,y,(unsigned char)ir2[y*np+x]);
                        goto ex;
                      }
                    }
                  }
                
                  ex:
                  ENTER( "OUTPUT IMAGES" );
                  printf("  tot pix: %d, errs: %d\n", w*h*c,nums );

                  if (nums)
                  {
                    stbi_write_png("old.png", w, h, c, ir1, op);
                    stbi_write_png("new.png", w, h, c, ir2, np);
                    exit(1);
                  }

                  LEAVE(); // output images
                }
                LEAVE(); //test compare
              #endif



              }
              LEAVE(); // test filter
            }
            LEAVE(); // test edge
          }
          LEAVE(); // test width
        }
        LEAVE(); // test height
      }
      LEAVE(); // test type
    }
    LEAVE();  // test layout
  }

  CloseTM();
  return 0;
}