xref: /external/opencv/cv/src/cvpyramids.cpp

/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of Intel Corporation may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/

#include "_cv.h"

/****************************************************************************************\
                         Down-sampling pyramids core functions
\****************************************************************************************/

//////////// Filtering macros /////////////

/* COMMON CASE */
/* 1/16[1    4    6    4    1]       */
/* ...| x0 | x1 | x2 | x3 | x4 |...  */
#define  PD_FILTER( x0, x1, x2, x3, x4 ) ((x2)*6+((x1)+(x3))*4+(x0)+(x4))

/* MACROS FOR BORDERS */

/* | b I a | b | reflection used ("I" denotes the image boundary) */

/* LEFT/TOP */
/* 1/16[1    4    6    4    1]       */
/*    | x2 | x1 I x0 | x1 | x2 |...  */
#define  PD_LT(x0,x1,x2)                 ((x0)*6 + (x1)*8 + (x2)*2)

/* RIGHT/BOTTOM */
/* 1/16[1    4    6    4    1]       */
/* ...| x0 | x1 | x2 | x3 I x2 |     */
#define  PD_RB(x0,x1,x2,x3)              ((x0) + ((x1) + (x3))*4 + (x2)*7)

/* SINGULAR CASE ( width == 2 || height == 2 ) */
/* 1/16[1    4    6    4    1]       */
/*    | x0 | x1 I x0 | x1 I x0 |     */
#define  PD_SINGULAR(x0,x1)    (((x0) + (x1))*8)

#define  PD_SCALE_INT(x)       (((x) + (1<<7)) >> 8)
#define  PD_SCALE_FLT(x)       ((x)*0.00390625f)

#define  PD_SZ  5

////////// generic macro ////////////

#define ICV_DEF_PYR_DOWN_FUNC( flavor, type, worktype, _pd_scale_ )                     \
static CvStatus CV_STDCALL                                                              \
icvPyrDownG5x5_##flavor##_CnR( const type* src, int srcstep, type* dst,                 \
                               int dststep, CvSize size, void *buf, int Cs )            \
{                                                                                       \
    worktype*  buffer = (worktype*)buf;  /* pointer to temporary buffer */              \
    worktype*  rows[PD_SZ]; /* array of rows pointers. dim(rows) is PD_SZ */            \
    int  y, top_row = 0;                                                                \
    int  Wd = size.width/2, Wdn = Wd*Cs;                                                \
    int  buffer_step = Wdn;                                                             \
    int  pd_sz = (PD_SZ + 1)*buffer_step;                                               \
    int  fst = 0, lst = size.height <= PD_SZ/2 ? size.height : PD_SZ/2 + 1;             \
                                                                                        \
    assert( Cs == 1 || Cs == 3 );                                                       \
    srcstep /= sizeof(src[0]); dststep /= sizeof(dst[0]);                               \
                                                                                        \
    /* main loop */                                                                     \
    for( y = 0; y < size.height; y += 2, dst += dststep )                               \
    {                                                                                   \
        /* set first and last indices of buffer rows which are need to be filled */     \
        int x, y1, k = top_row;                                                         \
        int x1 = buffer_step;                                                           \
        worktype *row01, *row23, *row4;                                                 \
                                                                                        \
        /* assign rows pointers */                                                      \
        for( y1 = 0; y1 < PD_SZ; y1++ )                                                 \
        {                                                                               \
            rows[y1] = buffer + k;                                                      \
            k += buffer_step;                                                           \
            k &= k < pd_sz ? -1 : 0;                                                    \
        }                                                                               \
                                                                                        \
        row01 = rows[0];                                                                \
        row23 = rows[2];                                                                \
        row4  = rows[4];                                                                \
                                                                                        \
        /* fill new buffer rows with filtered source (horizontal conv) */               \
        if( Cs == 1 )                                                                   \
        {                                                                               \
            if( size.width > PD_SZ/2 )                                                  \
                for( y1 = fst; y1 < lst; y1++, src += srcstep )                         \
                {                                                                       \
                    worktype *row = rows[y1];                                           \
                                                                                        \
                    /* process left & right bounds */                                   \
                    row[0]    = PD_LT( src[0], src[1], src[2] );                        \
                    row[Wd-1] = PD_RB( src[Wd*2-4], src[Wd*2-3],                        \
                                       src[Wd*2-2], src[Wd*2-1]);                       \
                    /* other points (even) */                                           \
                    for( x = 1; x < Wd - 1; x++ )                                       \
                    {                                                                   \
                        row[x] = PD_FILTER( src[2*x-2], src[2*x-1], src[2*x],           \
                                            src[2*x+1], src[2*x+2] );                   \
                    }                                                                   \
                }                                                                       \
            else                                                                        \
                for( y1 = fst; y1 < lst; y1++, src += srcstep )                         \
                {                                                                       \
                    rows[y1][0] = PD_SINGULAR( src[0], src[1] );                        \
                }                                                                       \
        }                                                                               \
        else /* Cs == 3 */                                                              \
        {                                                                               \
            for( y1 = fst; y1 < lst; y1++, src += srcstep )                             \
            {                                                                           \
                worktype *row = rows[y1];                                               \
                                                                                        \
                if( size.width > PD_SZ/2 )                                              \
                {                                                                       \
                    int c;                                                              \
                    for( c = 0; c < 3; c++ )                                            \
                    {                                                                   \
                        /* process left & right bounds  */                              \
                        row[c] = PD_LT( src[c], src[3+c], src[6+c] );                   \
                        row[Wdn-3+c] = PD_RB( src[Wdn*2-12+c], src[Wdn*2-9+c],          \
                                              src[Wdn*2-6+c], src[Wdn*2-3+c] );         \
                    }                                                                   \
                    /* other points (even) */                                           \
                    for( x = 3; x < Wdn - 3; x += 3 )                                   \
                    {                                                                   \
                        row[x]   = PD_FILTER( src[2*x-6], src[2*x-3], src[2*x],         \
                                              src[2*x+3], src[2*x+6] );                 \
                        row[x+1] = PD_FILTER( src[2*x-5], src[2*x-2], src[2*x+1],       \
                                              src[2*x+4], src[2*x+7] );                 \
                        row[x+2] = PD_FILTER( src[2*x-4], src[2*x-1], src[2*x+2],       \
                                              src[2*x+5], src[2*x+8] );                 \
                    }                                                                   \
                }                                                                       \
                else /* size.width <= PD_SZ/2 */                                        \
                {                                                                       \
                    row[0] = PD_SINGULAR( src[0], src[3] );                             \
                    row[1] = PD_SINGULAR( src[1], src[4] );                             \
                    row[2] = PD_SINGULAR( src[2], src[5] );                             \
                }                                                                       \
            }                                                                           \
        }                                                                               \
                                                                                        \
        /* second pass. Do vertical conv and write results do destination image */      \
        if( y > 0 )                                                                     \
        {                                                                               \
            if( y < size.height - PD_SZ/2 )                                             \
            {                                                                           \
                for( x = 0; x < Wdn; x++, x1++ )                                        \
                {                                                                       \
                    dst[x] = (type)_pd_scale_( PD_FILTER( row01[x],  row01[x1],         \
                                               row23[x], row23[x1], row4[x] ));         \
                }                                                                       \
                top_row += 2*buffer_step;                                               \
                top_row &= top_row < pd_sz ? -1 : 0;                                    \
            }                                                                           \
            else /* bottom */                                                           \
                for( x = 0; x < Wdn; x++, x1++ )                                        \
                    dst[x] = (type)_pd_scale_( PD_RB( row01[x], row01[x1],              \
                                                      row23[x], row23[x1]));            \
        }                                                                               \
        else                                                                            \
        {                                                                               \
            if( size.height > PD_SZ/2 ) /* top */                                       \
            {                                                                           \
                for( x = 0; x < Wdn; x++, x1++ )                                        \
                    dst[x] = (type)_pd_scale_( PD_LT( row01[x], row01[x1], row23[x] )); \
            }                                                                           \
            else /* size.height <= PD_SZ/2 */                                           \
            {                                                                           \
                for( x = 0; x < Wdn; x++, x1++ )                                        \
                    dst[x] = (type)_pd_scale_( PD_SINGULAR( row01[x], row01[x1] ));     \
            }                                                                           \
            fst = PD_SZ - 2;                                                            \
        }                                                                               \
                                                                                        \
        lst = y + 2 + PD_SZ/2 < size.height ? PD_SZ : size.height - y;                  \
    }                                                                                   \
                                                                                        \
    return CV_OK;                                                                       \
}


ICV_DEF_PYR_DOWN_FUNC( 8u, uchar, int, PD_SCALE_INT )
ICV_DEF_PYR_DOWN_FUNC( 16s, short, int, PD_SCALE_INT )
ICV_DEF_PYR_DOWN_FUNC( 16u, ushort, int, PD_SCALE_INT )
ICV_DEF_PYR_DOWN_FUNC( 32f, float, float, PD_SCALE_FLT )
ICV_DEF_PYR_DOWN_FUNC( 64f, double, double, PD_SCALE_FLT )


/****************************************************************************************\
                           Up-sampling pyramids core functions
\****************************************************************************************/

/////////// filtering macros //////////////

/* COMMON CASE: NON ZERO */
/* 1/16[1    4   6    4   1]       */
/* ...| x0 | 0 | x1 | 0 | x2 |...  */
#define  PU_FILTER( x0, x1, x2 )         ((x1)*6 + (x0) + (x2))

/* ZERO POINT AT CENTER */
/* 1/16[1   4    6   4    1]      */
/* ...| 0 | x0 | 0 | x1 | 0 |...  */
#define  PU_FILTER_ZI( x0, x1 )          (((x0) + (x1))*4)

/* MACROS FOR BORDERS */

/* | b I a | b | reflection */

/* LEFT/TOP */
/* 1/16[1    4   6    4   1]       */
/*    | x1 | 0 I x0 | 0 | x1 |...  */
#define  PU_LT( x0, x1 )                 ((x0)*6 + (x1)*2)

/* 1/16[1   4    6   4    1]       */
/*    | 0 I x0 | 0 | x1 | 0 |...   */
#define  PU_LT_ZI( x0, x1 )              PU_FILTER_ZI((x0),(x1))

/* RIGHT/BOTTOM: NON ZERO */
/* 1/16[1    4   6    4   1]       */
/* ...| x0 | 0 | x1 | 0 I x1 |     */
#define  PU_RB( x0, x1 )                 ((x0) + (x1)*7)

/* RIGHT/BOTTOM: ZERO POINT AT CENTER */
/* 1/16[1   4    6   4    1]       */
/* ...| 0 | x0 | 0 I x0 | 0 |      */
#define  PU_RB_ZI( x0 )                  ((x0)*8)

/* SINGULAR CASE */
/* 1/16[1    4   6    4   1]       */
/*    | x0 | 0 I x0 | 0 I x0 |     */
#define  PU_SINGULAR( x0 )               PU_RB_ZI((x0)) /* <--| the same formulas */
#define  PU_SINGULAR_ZI( x0 )            PU_RB_ZI((x0)) /* <--| */

/* x/64  - scaling in up-sampling functions */
#define  PU_SCALE_INT(x)                 (((x) + (1<<5)) >> 6)
#define  PU_SCALE_FLT(x)                 ((x)*0.015625f)

#define  PU_SZ  3

//////////// generic macro /////////////


#define ICV_DEF_PYR_UP_FUNC( flavor, type, worktype, _pu_scale_ )                       \
static CvStatus CV_STDCALL                                                              \
icvPyrUpG5x5_##flavor##_CnR( const type* src, int srcstep, type* dst,                   \
                             int dststep, CvSize size, void *buf, int Cs )              \
{                                                                                       \
    worktype *buffer = (worktype*)buf;                                                  \
    worktype *rows[PU_SZ];                                                              \
    int y, top_row = 0;                                                                 \
    int Wd = size.width * 2, Wdn = Wd * Cs, Wn = size.width * Cs;                       \
    int buffer_step = Wdn;                                                              \
    int pu_sz = PU_SZ*buffer_step;                                                      \
    int fst = 0, lst = size.height <= PU_SZ/2 ? size.height : PU_SZ/2 + 1;              \
                                                                                        \
    assert( Cs == 1 || Cs == 3 );                                                       \
    srcstep /= sizeof(src[0]); dststep /= sizeof(dst[0]);                               \
                                                                                        \
    /* main loop */                                                                     \
    for( y = 0; y < size.height; y++, dst += 2 * dststep )                              \
    {                                                                                   \
        int x, y1, k = top_row;                                                         \
        worktype *row0, *row1, *row2;                                                   \
        type *dst1;                                                                     \
                                                                                        \
        /* assign rows pointers */                                                      \
        for( y1 = 0; y1 < PU_SZ; y1++ )                                                 \
        {                                                                               \
            rows[y1] = buffer + k;                                                      \
            k += buffer_step;                                                           \
            k &= k < pu_sz ? -1 : 0;                                                    \
        }                                                                               \
                                                                                        \
        row0 = rows[0];                                                                 \
        row1 = rows[1];                                                                 \
        row2 = rows[2];                                                                 \
        dst1 = dst + dststep;                                                           \
                                                                                        \
        /* fill new buffer rows with filtered source (horizontal conv) */               \
        if( Cs == 1 )                                                                   \
            if( size.width > PU_SZ / 2 )                                                \
                for( y1 = fst; y1 < lst; y1++, src += srcstep )                         \
                {                                                                       \
                    worktype *row = rows[y1];                                           \
                                                                                        \
                    /* process left & right bounds */                                   \
                    row[0] = PU_LT( src[0], src[1] );                                   \
                    row[1] = PU_LT_ZI( src[0], src[1] );                                \
                    row[size.width * 2 - 2] = PU_RB( src[size.width - 2],               \
                                                     src[size.width - 1] );             \
                    row[size.width * 2 - 1] = PU_RB_ZI( src[size.width - 1] );          \
                    /* other points */                                                  \
                    for( x = 1; x < size.width - 1; x++ )                               \
                    {                                                                   \
                        row[2 * x] = PU_FILTER( src[x - 1], src[x], src[x + 1] );       \
                        row[2 * x + 1] = PU_FILTER_ZI( src[x], src[x + 1] );            \
                    }                                                                   \
                }                                                                       \
            else                /* size.width <= PU_SZ/2 */                             \
                for( y1 = fst; y1 < lst; y1++, src += srcstep )                         \
                {                                                                       \
                    worktype *row = rows[y1];                                           \
                    worktype val = src[0];                                              \
                                                                                        \
                    row[0] = PU_SINGULAR( val );                                        \
                    row[1] = PU_SINGULAR_ZI( val );                                     \
                }                                                                       \
        else                    /* Cs == 3 */                                           \
            for( y1 = fst; y1 < lst; y1++, src += srcstep )                             \
            {                                                                           \
                worktype *row = rows[y1];                                               \
                                                                                        \
                if( size.width > PU_SZ / 2 )                                            \
                {                                                                       \
                    int c;                                                              \
                                                                                        \
                    for( c = 0; c < 3; c++ )                                            \
                    {                                                                   \
                        /* process left & right bounds  */                              \
                        row[c] = PU_LT( src[c], src[3 + c] );                           \
                        row[3 + c] = PU_LT_ZI( src[c], src[3 + c] );                    \
                        row[Wn * 2 - 6 + c] = PU_RB( src[Wn - 6 + c], src[Wn - 3 + c]); \
                        row[Wn * 2 - 3 + c] = PU_RB_ZI( src[Wn - 3 + c] );              \
                    }                                                                   \
                    /* other points */                                                  \
                    for( x = 3; x < Wn - 3; x += 3 )                                    \
                    {                                                                   \
                        row[2 * x] = PU_FILTER( src[x - 3], src[x], src[x + 3] );       \
                        row[2 * x + 3] = PU_FILTER_ZI( src[x], src[x + 3] );            \
                                                                                        \
                        row[2 * x + 1] = PU_FILTER( src[x - 2], src[x + 1], src[x + 4]);\
                        row[2 * x + 4] = PU_FILTER_ZI( src[x + 1], src[x + 4] );        \
                                                                                        \
                        row[2 * x + 2] = PU_FILTER( src[x - 1], src[x + 2], src[x + 5]);\
                        row[2 * x + 5] = PU_FILTER_ZI( src[x + 2], src[x + 5] );        \
                    }                                                                   \
                }                                                                       \
                else            /* size.width <= PU_SZ/2 */                             \
                {                                                                       \
                    int c;                                                              \
                                                                                        \
                    for( c = 0; c < 3; c++ )                                            \
                    {                                                                   \
                        row[c] = PU_SINGULAR( src[c] );                                 \
                        row[3 + c] = PU_SINGULAR_ZI( src[c] );                          \
                    }                                                                   \
                }                                                                       \
            }                                                                           \
                                                                                        \
        /* second pass. Do vertical conv and write results do destination image */      \
        if( y > 0 )                                                                     \
        {                                                                               \
            if( y < size.height - PU_SZ / 2 )                                           \
            {                                                                           \
                for( x = 0; x < Wdn; x++ )                                              \
                {                                                                       \
                    dst[x] = (type)_pu_scale_( PU_FILTER( row0[x], row1[x], row2[x] )); \
                    dst1[x] = (type)_pu_scale_( PU_FILTER_ZI( row1[x], row2[x] ));      \
                }                                                                       \
                top_row += buffer_step;                                                 \
                top_row &= top_row < pu_sz ? -1 : 0;                                    \
            }                                                                           \
            else                /* bottom */                                            \
                for( x = 0; x < Wdn; x++ )                                              \
                {                                                                       \
                    dst[x] = (type)_pu_scale_( PU_RB( row0[x], row1[x] ));              \
                    dst1[x] = (type)_pu_scale_( PU_RB_ZI( row1[x] ));                   \
                }                                                                       \
        }                                                                               \
        else                                                                            \
        {                                                                               \
            if( size.height > PU_SZ / 2 ) /* top */                                     \
                for( x = 0; x < Wdn; x++ )                                              \
                {                                                                       \
                    dst[x] = (type)_pu_scale_( PU_LT( row0[x], row1[x] ));              \
                    dst1[x] = (type)_pu_scale_( PU_LT_ZI( row0[x], row1[x] ));          \
                }                                                                       \
            else                /* size.height <= PU_SZ/2 */                            \
                for( x = 0; x < Wdn; x++ )                                              \
                {                                                                       \
                    dst[x] = (type)_pu_scale_( PU_SINGULAR( row0[x] ));                 \
                    dst1[x] = (type)_pu_scale_( PU_SINGULAR_ZI( row0[x] ));             \
                }                                                                       \
            fst = PU_SZ - 1;                                                            \
        }                                                                               \
                                                                                        \
        lst = y < size.height - PU_SZ/2 - 1 ? PU_SZ : size.height + PU_SZ/2 - y - 1;    \
    }                                                                                   \
                                                                                        \
    return CV_OK;                                                                       \
}


ICV_DEF_PYR_UP_FUNC( 8u, uchar, int, PU_SCALE_INT )
ICV_DEF_PYR_UP_FUNC( 16s, short, int, PU_SCALE_INT )
ICV_DEF_PYR_UP_FUNC( 16u, ushort, int, PU_SCALE_INT )
ICV_DEF_PYR_UP_FUNC( 32f, float, float, PU_SCALE_FLT )
ICV_DEF_PYR_UP_FUNC( 64f, double, double, PU_SCALE_FLT )


static CvStatus CV_STDCALL
icvPyrUpG5x5_GetBufSize( int roiWidth, CvDataType dataType,
                         int channels, int *bufSize )
{
    int bufStep;

    if( !bufSize )
        return CV_NULLPTR_ERR;
    *bufSize = 0;

    if( roiWidth < 0 )
        return CV_BADSIZE_ERR;
    if( channels != 1 && channels != 3 )
        return CV_UNSUPPORTED_CHANNELS_ERR;

    bufStep = 2*roiWidth*channels;

    if( dataType == cv64f )
        bufStep *= sizeof(double);
    else
        bufStep *= sizeof(int);

    *bufSize = bufStep * PU_SZ;
    return CV_OK;
}


static CvStatus CV_STDCALL
icvPyrDownG5x5_GetBufSize( int roiWidth, CvDataType dataType,
                           int channels, int *bufSize )
{
    int bufStep;

    if( !bufSize )
        return CV_NULLPTR_ERR;
    *bufSize = 0;

    if( roiWidth < 0 || (roiWidth & 1) != 0 )
        return CV_BADSIZE_ERR;
    if( channels != 1 && channels != 3 )
        return CV_UNSUPPORTED_CHANNELS_ERR;

    bufStep = 2*roiWidth*channels;

    if( dataType == cv64f )
        bufStep *= sizeof(double);
    else
        bufStep *= sizeof(int);

    *bufSize = bufStep * (PD_SZ + 1);
    return CV_OK;
}

/****************************************************************************************\
                        Downsampled image border completion
\****************************************************************************************/

#define ICV_DEF_PYR_BORDER_FUNC( flavor, arrtype, worktype, _pd_scale_ )                \
static CvStatus CV_STDCALL                                                              \
icvPyrDownBorder_##flavor##_CnR( const arrtype *src, int src_step, CvSize src_size,     \
                          arrtype *dst, int dst_step, CvSize dst_size, int channels )   \
{                                                                                       \
    int local_alloc = 0;                                                                \
    worktype *buf = 0, *buf0 = 0;                                                       \
    const arrtype* src2;                                                                \
    arrtype* dst2;                                                                      \
    int buf_size;                                                                       \
    int i, j;                                                                           \
    int W = src_size.width, H = src_size.height;                                        \
    int Wd = dst_size.width, Hd = dst_size.height;                                      \
    int Wd_, Hd_;                                                                       \
    int Wn = W*channels;                                                                \
    int bufW;                                                                           \
    int cols, rows; /* columns and rows to modify */                                    \
                                                                                        \
    assert( channels == 1 || channels == 3 );                                           \
                                                                                        \
    buf_size = MAX(src_size.width,src_size.height) * sizeof(buf[0]) * 2 * channels;     \
    if( buf_size > (1 << 14) )                                                          \
    {                                                                                   \
        buf = (worktype*)cvAlloc( buf_size );                                           \
        if( !buf )                                                                      \
            return CV_OUTOFMEM_ERR;                                                     \
    }                                                                                   \
    else                                                                                \
    {                                                                                   \
        buf = (worktype*)cvAlignPtr(alloca( buf_size+8 ), 8);                           \
        local_alloc = 1;                                                                \
    }                                                                                   \
                                                                                        \
    buf0 = buf;                                                                         \
                                                                                        \
    src_step /= sizeof(src[0]);                                                         \
    dst_step /= sizeof(dst[0]);                                                         \
                                                                                        \
    cols = (W & 1) + (Wd*2 > W);                                                        \
    rows = (H & 1) + (Hd*2 > H);                                                        \
                                                                                        \
    src2 = src + (H-1)*src_step;                                                        \
    dst2 = dst + (Hd - rows)*dst_step;                                                  \
    src += (W - 1)*channels;                                                            \
    dst += (Wd - cols)*channels;                                                        \
                                                                                        \
    /* part of row(column) from 1 to Wd_(Hd_) is processed using PD_FILTER macro */     \
    Wd_ = Wd - 1 + (cols == 1 && (W & 1) != 0);                                         \
    Hd_ = Hd - 1 + (rows == 1 && (H & 1) != 0);                                         \
                                                                                        \
    bufW = channels * cols;                                                             \
                                                                                        \
    /******************* STAGE 1. ******************/                                   \
                                                                                        \
    /* do horizontal convolution of the 1-2 right columns and write results to buffer */\
    if( cols > 0 )                                                                      \
    {                                                                                   \
        if( W <= 2 )                                                                    \
        {                                                                               \
            assert( Wd == 1 );                                                          \
            for( i = 0; i < H; i++, src += src_step, buf += channels )                  \
            {                                                                           \
                if( channels == 1 )                                                     \
                    buf[0] = PD_SINGULAR( src[1-Wn], src[0] );                          \
                else                                                                    \
                {                                                                       \
                    buf[0] = PD_SINGULAR( src[3-Wn], src[0] );                          \
                    buf[1] = PD_SINGULAR( src[4-Wn], src[1] );                          \
                    buf[2] = PD_SINGULAR( src[5-Wn], src[2] );                          \
                }                                                                       \
            }                                                                           \
        }                                                                               \
        else if( (W == 3 && Wd == 1) || (W > 3 && !(Wd & 1)) )                          \
        {                                                                               \
            for( i = 0; i < H; i++, src += src_step, buf += channels )                  \
            {                                                                           \
                if( channels == 1 )                                                     \
                    buf[0] = PD_LT( src[-2], src[-1], src[0] );                         \
                else                                                                    \
                {                                                                       \
                    buf[0] = PD_LT( src[-6], src[-3], src[0] );                         \
                    buf[1] = PD_LT( src[-5], src[-2], src[1] );                         \
                    buf[2] = PD_LT( src[-4], src[-1], src[2] );                         \
                }                                                                       \
            }                                                                           \
        }                                                                               \
        else if( W == 3 )                                                               \
        {                                                                               \
            for( i = 0; i < H; i++, src += src_step, buf += channels*2 )                \
            {                                                                           \
                if( channels == 1 )                                                     \
                {                                                                       \
                    buf[0] = PD_LT( src[-2], src[-1], src[0] );                         \
                    buf[1] = PD_LT( src[0], src[-1], src[-2] );                         \
                }                                                                       \
                else                                                                    \
                {                                                                       \
                    buf[0] = PD_LT( src[-6], src[-3], src[0] );                         \
                    buf[1] = PD_LT( src[-5], src[-2], src[1] );                         \
                    buf[2] = PD_LT( src[-4], src[-1], src[2] );                         \
                    buf[3] = PD_LT( src[0], src[-3], src[-6] );                         \
                    buf[4] = PD_LT( src[1], src[-2], src[-5] );                         \
                    buf[5] = PD_LT( src[2], src[-1], src[-4] );                         \
                }                                                                       \
            }                                                                           \
        }                                                                               \
        else if( cols == 1 )                                                            \
        {                                                                               \
            for( i = 0; i < H; i++, src += src_step, buf += channels )                  \
            {                                                                           \
                if( channels == 1 )                                                     \
                    buf[0] = PD_FILTER( src[-4], src[-3], src[-2], src[-1], src[0]);    \
                else                                                                    \
                {                                                                       \
                    buf[0] = PD_FILTER( src[-12], src[-9], src[-6], src[-3], src[0]);   \
                    buf[1] = PD_FILTER( src[-11], src[-8], src[-5], src[-2], src[1]);   \
                    buf[2] = PD_FILTER( src[-10], src[-7], src[-4], src[-1], src[2]);   \
                }                                                                       \
            }                                                                           \
        }                                                                               \
        else                                                                            \
        {                                                                               \
            for( i = 0; i < H; i++, src += src_step, buf += channels*2 )                \
            {                                                                           \
                if( channels == 1 )                                                     \
                {                                                                       \
                    buf[0] = PD_FILTER( src[-4], src[-3], src[-2], src[-1], src[0] );   \
                    buf[1] = PD_LT( src[0], src[-1], src[-2] );                         \
                }                                                                       \
                else                                                                    \
                {                                                                       \
                    buf[0] = PD_FILTER( src[-12], src[-9], src[-6], src[-3], src[0] );  \
                    buf[1] = PD_FILTER( src[-11], src[-8], src[-5], src[-2], src[1] );  \
                    buf[2] = PD_FILTER( src[-10], src[-7], src[-4], src[-1], src[2] );  \
                    buf[3] = PD_LT( src[0], src[-3], src[-6] );                         \
                    buf[4] = PD_LT( src[1], src[-2], src[-5] );                         \
                    buf[5] = PD_LT( src[2], src[-1], src[-4] );                         \
                }                                                                       \
            }                                                                           \
        }                                                                               \
        buf = buf0;                                                                     \
    }                                                                                   \
                                                                                        \
    src = src2;                                                                         \
                                                                                        \
    /******************* STAGE 2. ******************/                                   \
                                                                                        \
    /* do vertical convolution of the pre-processed right columns, */                   \
    /* stored in buffer, and write results to the destination */                        \
    /* do vertical convolution of the 1-2 bottom rows */                                \
    /* and write results to the buffer */                                               \
    if( H <= 2 )                                                                        \
    {                                                                                   \
        if( cols > 0 )                                                                  \
        {                                                                               \
            assert( Hd == 1 );                                                          \
            for( j = 0; j < bufW; j++ )                                                 \
                dst[j] = (arrtype)_pd_scale_( PD_SINGULAR( buf[j], buf[j+(H-1)*bufW] ));\
        }                                                                               \
                                                                                        \
        if( rows > 0 )                                                                  \
        {                                                                               \
            for( j = 0; j < Wn; j++ )                                                   \
                buf[j] = PD_SINGULAR( src[j-src_step], src[j] );                        \
        }                                                                               \
    }                                                                                   \
    else if( H == 3 )                                                                   \
    {                                                                                   \
        if( cols > 0 )                                                                  \
        {                                                                               \
            for( j = 0; j < bufW; j++ )                                                 \
            {                                                                           \
                dst[j]= (arrtype)_pd_scale_(PD_LT( buf[j], buf[j+bufW], buf[j+bufW*2]));\
            }                                                                           \
            if( Hd == 2 )                                                               \
            {                                                                           \
                dst += dst_step;                                                        \
                for( j = 0; j < bufW; j++ )                                             \
                    dst[j] = (arrtype)_pd_scale_( PD_LT( buf[j+bufW*2],                 \
                                                  buf[j+bufW], buf[j] ));               \
            }                                                                           \
        }                                                                               \
                                                                                        \
        if( Hd == 1 )                                                                   \
        {                                                                               \
            for( j = 0; j < Wn; j++ )                                                   \
                buf[j] = PD_LT( src[j-src_step*2], src[j - src_step], src[j] );         \
        }                                                                               \
        else                                                                            \
        {                                                                               \
            for( j = 0; j < Wn; j++ )                                                   \
            {                                                                           \
                buf[j] = PD_LT( src[j-src_step*2], src[j - src_step], src[j] );         \
                buf[j+Wn] = PD_LT( src[j],src[j-src_step],src[j-src_step*2] );          \
            }                                                                           \
        }                                                                               \
    }                                                                                   \
    else                                                                                \
    {                                                                                   \
        if( cols > 0 )                                                                  \
        {                                                                               \
            /* top of the right border */                                               \
            for( j = 0; j < bufW; j++ )                                                 \
                dst[j]=(arrtype)_pd_scale_( PD_LT( buf[j], buf[j+bufW], buf[j+bufW*2]));\
                                                                                        \
            /* middle part of the right border */                                       \
            buf += bufW*2;                                                              \
            dst += dst_step;                                                            \
            for( i = 1; i < Hd_; i++, dst += dst_step, buf += bufW*2 )                  \
            {                                                                           \
                for( j = 0; j < bufW; j++ )                                             \
                    dst[j] = (arrtype)_pd_scale_( PD_FILTER( buf[j-bufW*2], buf[j-bufW],\
                                                  buf[j], buf[j+bufW], buf[j+bufW*2] ));\
            }                                                                           \
                                                                                        \
            /* bottom of the right border */                                            \
            if( !(H & 1) )                                                              \
            {                                                                           \
                for( j = 0; j < bufW; j++ )                                             \
                    dst[j] = (arrtype)_pd_scale_( PD_RB( buf[j-bufW*2], buf[j-bufW],    \
                                                         buf[j], buf[j+bufW] ));        \
            }                                                                           \
            else if( rows > 1 )                                                         \
            {                                                                           \
                for( j = 0; j < bufW; j++ )                                             \
                    dst[j]=(arrtype)_pd_scale_( PD_LT( buf[j-bufW*2],                   \
                                                buf[j-bufW], buf[j]));                  \
            }                                                                           \
                                                                                        \
            buf = buf0;                                                                 \
        }                                                                               \
                                                                                        \
        if( rows > 0 )                                                                  \
        {                                                                               \
            if( !(H & 1) )                                                              \
            {                                                                           \
                for( j = 0; j < Wn; j++ )                                               \
                    buf[j] = PD_LT( src[j], src[j-src_step], src[j-src_step*2] );       \
            }                                                                           \
            else if( cols == 1 )                                                        \
            {                                                                           \
                for( j = 0; j < Wn; j++ )                                               \
                    buf[j] = PD_FILTER( src[j-src_step*4], src[j-src_step*3],           \
                                        src[j-src_step*2], src[j-src_step], src[j] );   \
            }                                                                           \
            else                                                                        \
            {                                                                           \
                for( j = 0; j < Wn; j++ )                                               \
                {                                                                       \
                    buf[j] = PD_FILTER( src[j-src_step*4], src[j-src_step*3],           \
                                        src[j-src_step*2], src[j-src_step], src[j] );   \
                    buf[j+Wn] = PD_LT( src[j], src[j-src_step], src[j-src_step*2] );    \
                }                                                                       \
            }                                                                           \
        }                                                                               \
    }                                                                                   \
                                                                                        \
                                                                                        \
    /******************* STAGE 3. ******************/                                   \
                                                                                        \
    /* do horizontal convolution of the pre-processed bottom rows,*/                    \
    /* stored in buffer, and write results to the destination */                        \
    if( rows > 0 )                                                                      \
    {                                                                                   \
        dst = dst2;                                                                     \
                                                                                        \
        if( W <= 2 )                                                                    \
        {                                                                               \
            assert( Wd == 1 );                                                          \
            for( ; rows--; dst += dst_step, buf += Wn )                                 \
            {                                                                           \
                if( channels == 1 )                                                     \
                    dst[0] = (arrtype)_pd_scale_( PD_SINGULAR( buf[0], buf[Wn-1] ));    \
                else                                                                    \
                {                                                                       \
                    dst[0] = (arrtype)_pd_scale_( PD_SINGULAR( buf[0], buf[Wn-3] ));    \
                    dst[1] = (arrtype)_pd_scale_( PD_SINGULAR( buf[1], buf[Wn-2] ));    \
                    dst[2] = (arrtype)_pd_scale_( PD_SINGULAR( buf[2], buf[Wn-1] ));    \
                }                                                                       \
            }                                                                           \
        }                                                                               \
        else if( W == 3 )                                                               \
        {                                                                               \
            if( Wd == 1 )                                                               \
            {                                                                           \
                for( ; rows--; dst += dst_step, buf += Wn )                             \
                {                                                                       \
                    if( channels == 1 )                                                 \
                        dst[0] = (arrtype)_pd_scale_( PD_LT(buf[0], buf[1], buf[2] ));  \
                    else                                                                \
                    {                                                                   \
                        dst[0] = (arrtype)_pd_scale_( PD_LT(buf[0], buf[3], buf[6] ));  \
                        dst[1] = (arrtype)_pd_scale_( PD_LT(buf[1], buf[4], buf[7] ));  \
                        dst[2] = (arrtype)_pd_scale_( PD_LT(buf[2], buf[5], buf[8] ));  \
                    }                                                                   \
                }                                                                       \
            }                                                                           \
            else                                                                        \
            {                                                                           \
                for( ; rows--; dst += dst_step, buf += Wn )                             \
                {                                                                       \
                    if( channels == 1 )                                                 \
                    {                                                                   \
                        dst[0] = (arrtype)_pd_scale_( PD_LT(buf[0], buf[1], buf[2] ));  \
                        dst[1] = (arrtype)_pd_scale_( PD_LT(buf[2], buf[1], buf[0] ));  \
                    }                                                                   \
                    else                                                                \
                    {                                                                   \
                        dst[0] = (arrtype)_pd_scale_( PD_LT(buf[0], buf[3], buf[6] ));  \
                        dst[1] = (arrtype)_pd_scale_( PD_LT(buf[1], buf[4], buf[7] ));  \
                        dst[2] = (arrtype)_pd_scale_( PD_LT(buf[2], buf[5], buf[8] ));  \
                        dst[3] = (arrtype)_pd_scale_( PD_LT(buf[6], buf[3], buf[0] ));  \
                        dst[4] = (arrtype)_pd_scale_( PD_LT(buf[7], buf[4], buf[1] ));  \
                        dst[5] = (arrtype)_pd_scale_( PD_LT(buf[8], buf[5], buf[2] ));  \
                    }                                                                   \
                }                                                                       \
            }                                                                           \
        }                                                                               \
        else                                                                            \
        {                                                                               \
            for( ; rows--; dst += dst_step, buf += Wn )                                 \
            {                                                                           \
                if( channels == 1 )                                                     \
                {                                                                       \
                    /* left part of the bottom row */                                   \
                    dst[0] = (arrtype)_pd_scale_( PD_LT( buf[0], buf[1], buf[2] ));     \
                                                                                        \
                    /* middle part of the bottom row */                                 \
                    for( i = 1; i < Wd_; i++ )                                          \
                    {                                                                   \
                        dst[i] = (arrtype)_pd_scale_( PD_FILTER(buf[i*2-2], buf[i*2-1], \
                                                    buf[i*2],buf[i*2+1], buf[i*2+2] )); \
                    }                                                                   \
                                                                                        \
                    /* right part of the bottom row */                                  \
                    if( !(W & 1) )                                                      \
                        dst[i] = (arrtype)_pd_scale_( PD_RB( buf[i*2-2],buf[i*2-1],     \
                                                    buf[i*2], buf[i*2+1] ));            \
                    else if( cols > 1 )                                                 \
                        dst[i] = (arrtype)_pd_scale_( PD_LT( buf[i*2-2],                \
                                                    buf[i*2-1], buf[i*2] ));            \
                }                                                                       \
                else                                                                    \
                {                                                                       \
                    /* left part of the bottom row */                                   \
                    dst[0] = (arrtype)_pd_scale_( PD_LT( buf[0], buf[3], buf[6] ));     \
                    dst[1] = (arrtype)_pd_scale_( PD_LT( buf[1], buf[4], buf[7] ));     \
                    dst[2] = (arrtype)_pd_scale_( PD_LT( buf[2], buf[5], buf[8] ));     \
                                                                                        \
                    /* middle part of the bottom row */                                 \
                    for( i = 3; i < Wd_*3; i++ )                                        \
                    {                                                                   \
                        dst[i] = (arrtype)_pd_scale_( PD_FILTER(buf[i*2-6], buf[i*2-3], \
                                                      buf[i*2],buf[i*2+3], buf[i*2+6]));\
                    }                                                                   \
                                                                                        \
                    /* right part of the bottom row */                                  \
                    if( !(W & 1) )                                                      \
                    {                                                                   \
                        dst[i] = (arrtype)_pd_scale_( PD_RB( buf[i*2-6],buf[i*2-3],     \
                                                    buf[i*2], buf[i*2+3] ));            \
                        dst[i+1] = (arrtype)_pd_scale_( PD_RB( buf[i*2-5],buf[i*2-2],   \
                                                    buf[i*2+1], buf[i*2+4] ));          \
                        dst[i+2] = (arrtype)_pd_scale_( PD_RB( buf[i*2-4],buf[i*2-1],   \
                                                    buf[i*2+2], buf[i*2+5] ));          \
                    }                                                                   \
                    else if( cols > 1 )                                                 \
                    {                                                                   \
                        dst[i] = (arrtype)_pd_scale_( PD_LT( buf[i*2-6], buf[i*2-3], buf[i*2] ));   \
                        dst[i+1] = (arrtype)_pd_scale_( PD_LT( buf[i*2-5], buf[i*2-2], buf[i*2+1]));\
                        dst[i+2] = (arrtype)_pd_scale_( PD_LT( buf[i*2-4], buf[i*2-1], buf[i*2+2]));\
                    }                                                                   \
                }                                                                       \
            }                                                                           \
        }                                                                               \
    }                                                                                   \
                                                                                        \
    if( !local_alloc )                                                                  \
        cvFree( &buf0 );                                                                \
                                                                                        \
    return CV_OK;                                                                       \
}


#define ICV_DEF_INIT_PYR_TABLE( FUNCNAME )                          \
static void icvInit##FUNCNAME##Table( CvFuncTable* tab )            \
{                                                                   \
    tab->fn_2d[CV_8U] = (void*)icv##FUNCNAME##_8u_CnR;              \
    tab->fn_2d[CV_8S] = 0;                                          \
    tab->fn_2d[CV_16S] = (void*)icv##FUNCNAME##_16s_CnR;            \
    tab->fn_2d[CV_16U] = (void*)icv##FUNCNAME##_16u_CnR;            \
    tab->fn_2d[CV_32F] = (void*)icv##FUNCNAME##_32f_CnR;            \
    tab->fn_2d[CV_64F] = (void*)icv##FUNCNAME##_64f_CnR;            \
}

static void icvInitPyrDownBorderTable( CvFuncTable* tab );

ICV_DEF_INIT_PYR_TABLE( PyrUpG5x5 )
ICV_DEF_INIT_PYR_TABLE( PyrDownG5x5 )

typedef CvStatus (CV_STDCALL * CvPyrDownBorderFunc)( const void* src, int srcstep,
                                                     CvSize srcsize, void* dst,
                                                     int dststep, CvSize dstsize, int cn );

////////////////////////////// IPP pyramid functions /////////////////////////////////////

icvPyrDown_Gauss5x5_8u_C1R_t icvPyrDown_Gauss5x5_8u_C1R_p = 0;
icvPyrDown_Gauss5x5_8u_C3R_t icvPyrDown_Gauss5x5_8u_C3R_p = 0;
icvPyrDown_Gauss5x5_32f_C1R_t icvPyrDown_Gauss5x5_32f_C1R_p = 0;
icvPyrDown_Gauss5x5_32f_C3R_t icvPyrDown_Gauss5x5_32f_C3R_p = 0;

icvPyrUp_Gauss5x5_8u_C1R_t icvPyrUp_Gauss5x5_8u_C1R_p = 0;
icvPyrUp_Gauss5x5_8u_C3R_t icvPyrUp_Gauss5x5_8u_C3R_p = 0;
icvPyrUp_Gauss5x5_32f_C1R_t icvPyrUp_Gauss5x5_32f_C1R_p = 0;
icvPyrUp_Gauss5x5_32f_C3R_t icvPyrUp_Gauss5x5_32f_C3R_p = 0;

icvPyrUpGetBufSize_Gauss5x5_t icvPyrUpGetBufSize_Gauss5x5_p = 0;
icvPyrDownGetBufSize_Gauss5x5_t icvPyrDownGetBufSize_Gauss5x5_p = 0;

typedef CvStatus (CV_STDCALL * CvPyramidFunc)
( const void* src, int srcstep, void* dst,
  int dststep, CvSize size, void* buffer, int cn );

typedef CvStatus (CV_STDCALL * CvPyramidIPPFunc)
( const void* src, int srcstep, void* dst, int dststep, CvSize size, void* buffer );

//////////////////////////////////////////////////////////////////////////////////////////

/****************************************************************************************\
*                                 External functions                                     *
\****************************************************************************************/

CV_IMPL void
cvPyrUp( const void* srcarr, void* dstarr, int _filter )
{
    static CvFuncTable pyrup_tab;
    static int inittab = 0;

    void *buffer = 0;
    int local_alloc = 0;

    CV_FUNCNAME( "cvPyrUp" );

    __BEGIN__;

    int coi1 = 0, coi2 = 0;
    int buffer_size = 0;
    int type, depth, cn;
    CvMat srcstub, *src = (CvMat*)srcarr;
    CvMat dststub, *dst = (CvMat*)dstarr;
    CvFilter filter = (CvFilter) _filter;
    CvPyramidFunc func;
    CvPyramidIPPFunc ipp_func = 0;
    int use_ipp = 0;
    CvSize size;

    if( !inittab )
    {
        icvInitPyrUpG5x5Table( &pyrup_tab );
        inittab = 1;
    }

    CV_CALL( src = cvGetMat( src, &srcstub, &coi1 ));
    CV_CALL( dst = cvGetMat( dst, &dststub, &coi2 ));

    if( coi1 != 0 || coi2 != 0 )
        CV_ERROR( CV_BadCOI, "" );

    if( filter != CV_GAUSSIAN_5x5 )
        CV_ERROR( CV_StsBadArg, "this filter type not supported" );

    if( !CV_ARE_TYPES_EQ( src, dst ))
        CV_ERROR( CV_StsUnmatchedFormats, "" );

    if( src->cols*2 != dst->cols || src->rows*2 != dst->rows )
        CV_ERROR( CV_StsUnmatchedSizes, "" );

    size = cvGetMatSize(src);
    type = CV_MAT_TYPE(src->type);
    depth = CV_MAT_DEPTH(type);
    cn = CV_MAT_CN(type);

    if( cn != 1 && cn != 3 )
        CV_ERROR( CV_StsUnsupportedFormat, "The images must have 1 or 3 channel" );

    func = (CvPyramidFunc)pyrup_tab.fn_2d[depth];

    if( !func )
        CV_ERROR( CV_StsUnsupportedFormat, "" );

    if( icvPyrUpGetBufSize_Gauss5x5_p )
    {
        ipp_func = type == CV_8UC1 ? icvPyrUp_Gauss5x5_8u_C1R_p :
                   type == CV_8UC3 ? icvPyrUp_Gauss5x5_8u_C3R_p :
                   type == CV_32FC1 ? icvPyrUp_Gauss5x5_32f_C1R_p :
                   type == CV_32FC3 ? icvPyrUp_Gauss5x5_32f_C3R_p : 0;

        use_ipp = ipp_func && icvPyrUpGetBufSize_Gauss5x5_p( size.width,
                    icvDepthToDataType(type), cn, &buffer_size ) >= 0;
    }

    if( !use_ipp )
        icvPyrUpG5x5_GetBufSize( size.width, icvDepthToDataType(type), cn, &buffer_size );

    if( buffer_size <= CV_MAX_LOCAL_SIZE )
    {
        buffer = cvStackAlloc( buffer_size );
        local_alloc = 1;
    }
    else
        CV_CALL( buffer = cvAlloc( buffer_size ));

    if( !use_ipp )
        func( src->data.ptr, src->step, dst->data.ptr, dst->step, size, buffer, cn );
    else
        IPPI_CALL( ipp_func( src->data.ptr, src->step ? src->step : CV_STUB_STEP,
            dst->data.ptr, dst->step ? dst->step : CV_STUB_STEP, size, buffer ));
    __END__;

    if( buffer && !local_alloc )
        cvFree( &buffer );
}


CV_IMPL void
cvPyrDown( const void* srcarr, void* dstarr, int _filter )
{
    static CvFuncTable pyrdown_tab;
    static CvFuncTable pyrdownborder_tab;
    static int inittab = 0;

    void *buffer = 0;
    int local_alloc = 0;

    CV_FUNCNAME( "cvPyrDown" );

    __BEGIN__;

    int coi1 = 0, coi2 = 0;
    int buffer_size = 0;
    int type, depth, cn;
    CvMat srcstub, *src = (CvMat*)srcarr;
    CvMat dststub, *dst = (CvMat*)dstarr;
    CvFilter filter = (CvFilter) _filter;
    CvPyramidFunc func;
    CvPyramidIPPFunc ipp_func = 0;
    int use_ipp = 0;
    CvSize src_size, src_size2, dst_size;

    if( !inittab )
    {
        icvInitPyrDownG5x5Table( &pyrdown_tab );
        icvInitPyrDownBorderTable( &pyrdownborder_tab );
        inittab = 1;
    }

    CV_CALL( src = cvGetMat( src, &srcstub, &coi1 ));
    CV_CALL( dst = cvGetMat( dst, &dststub, &coi2 ));

    if( coi1 != 0 || coi2 != 0 )
        CV_ERROR( CV_BadCOI, "" );

    if( filter != CV_GAUSSIAN_5x5 )
        CV_ERROR( CV_StsBadArg, "this filter type not supported" );

    if( !CV_ARE_TYPES_EQ( src, dst ))
        CV_ERROR( CV_StsUnmatchedFormats, "" );

    src_size = cvGetMatSize(src);
    dst_size = cvGetMatSize(dst);
    src_size2.width = src_size.width & -2;
    src_size2.height = src_size.height & -2;

    if( (unsigned)(dst_size.width - src_size.width/2) > 1 ||
        (unsigned)(dst_size.height - src_size.height/2) > 1 )
        CV_ERROR( CV_StsUnmatchedSizes, "" );

    // current restriction of PyrDownBorder*
    if( (src_size.width <= 2 && dst_size.width != 1) ||
        (src_size.height <= 2 && dst_size.height != 1) )
        CV_ERROR( CV_StsUnmatchedSizes, "" );

    /*if( src->data.ptr == dst->data.ptr )
        CV_ERROR( CV_StsInplaceNotSupported, "" );*/

    type = CV_MAT_TYPE(src->type);
    depth = CV_MAT_DEPTH(type);
    cn = CV_MAT_CN(type);

    if( cn != 1 && cn != 3 )
        CV_ERROR( CV_StsUnsupportedFormat, "The images must have 1 or 3 channel" );

    func = (CvPyramidFunc)pyrdown_tab.fn_2d[depth];

    if( !func )
        CV_ERROR( CV_StsUnsupportedFormat, "" );

    if( icvPyrDownGetBufSize_Gauss5x5_p )
    {
        ipp_func = type == CV_8UC1 ? icvPyrDown_Gauss5x5_8u_C1R_p :
                   type == CV_8UC3 ? icvPyrDown_Gauss5x5_8u_C3R_p :
                   type == CV_32FC1 ? icvPyrDown_Gauss5x5_32f_C1R_p :
                   type == CV_32FC3 ? icvPyrDown_Gauss5x5_32f_C3R_p : 0;

        use_ipp = ipp_func && icvPyrDownGetBufSize_Gauss5x5_p( src_size2.width,
                    icvDepthToDataType(type), cn, &buffer_size ) >= 0;
    }

    if( !use_ipp )
        icvPyrDownG5x5_GetBufSize( src_size2.width,
            icvDepthToDataType(type), cn, &buffer_size );

    if( buffer_size <= CV_MAX_LOCAL_SIZE )
    {
        buffer = cvStackAlloc( buffer_size );
        local_alloc = 1;
    }
    else
        CV_CALL( buffer = cvAlloc( buffer_size ));

    if( !use_ipp )
        func( src->data.ptr, src->step, dst->data.ptr,
              dst->step, src_size2, buffer, cn );
    else
        IPPI_CALL( ipp_func( src->data.ptr, src->step ? src->step : CV_STUB_STEP,
            dst->data.ptr, dst->step ? dst->step : CV_STUB_STEP, src_size2, buffer ));

    if( src_size.width != dst_size.width*2 || src_size.height != dst_size.height*2 )
    {
        CvPyrDownBorderFunc border_func = (CvPyrDownBorderFunc)
                            pyrdownborder_tab.fn_2d[CV_MAT_DEPTH(type)];

        if( !border_func )
            CV_ERROR( CV_StsUnsupportedFormat, "" );

        IPPI_CALL( border_func( src->data.ptr, src->step, src_size,
                                dst->data.ptr, dst->step, dst_size, CV_MAT_CN(type) ));
    }

    __END__;

    if( buffer && !local_alloc )
        cvFree( &buffer );
}


CV_IMPL void
cvReleasePyramid( CvMat*** _pyramid, int extra_layers )
{
    CV_FUNCNAME( "cvReleasePyramid" );

    __BEGIN__;

    CvMat** pyramid;
    int i;

    if( !_pyramid )
        CV_ERROR( CV_StsNullPtr, "" );

    pyramid = *_pyramid;

    if( pyramid )
    {
        for( i = 0; i <= extra_layers; i++ )
            cvReleaseMat( &pyramid[i] );
    }

    cvFree( _pyramid );

    __END__;
}


CV_IMPL CvMat**
cvCreatePyramid( const CvArr* srcarr, int extra_layers, double rate,
                 const CvSize* layer_sizes, CvArr* bufarr,
                 int calc, int filter )
{
    CvMat** pyramid = 0;
    const float eps = 0.1f;

    CV_FUNCNAME( "cvCreatePyramid" );

    __BEGIN__;

    int i, elem_size, layer_step;
    CvMat stub, *src;
    CvSize size, layer_size;
    uchar* ptr = 0;

    CV_CALL( src = cvGetMat( srcarr, &stub ));

    if( extra_layers < 0 )
        CV_ERROR( CV_StsOutOfRange, "The number of extra layers must be non negative" );

    elem_size = CV_ELEM_SIZE(src->type);
    size = cvGetMatSize(src);

    if( bufarr )
    {
        CvMat bstub, *buf;
        int bufsize = 0;

        CV_CALL( buf = cvGetMat( bufarr, &bstub ));
        bufsize = buf->rows*buf->cols*CV_ELEM_SIZE(buf->type);
        layer_size = size;
        for( i = 1; i <= extra_layers; i++ )
        {
            if( !layer_sizes )
            {
                layer_size.width = cvRound(layer_size.width*rate+eps);
                layer_size.height = cvRound(layer_size.height*rate+eps);
            }
            else
                layer_size = layer_sizes[i-1];
            layer_step = layer_size.width*elem_size;
            bufsize -= layer_step*layer_size.height;
        }

        if( bufsize < 0 )
            CV_ERROR( CV_StsOutOfRange, "The buffer is too small to fit the pyramid" );
        ptr = buf->data.ptr;
    }

    CV_CALL( pyramid = (CvMat**)cvAlloc( (extra_layers+1)*sizeof(pyramid[0]) ));
    memset( pyramid, 0, (extra_layers+1)*sizeof(pyramid[0]) );

    pyramid[0] = cvCreateMatHeader( size.height, size.width, src->type );
    cvSetData( pyramid[0], src->data.ptr, src->step );
    layer_size = size;

    for( i = 1; i <= extra_layers; i++ )
    {
        if( !layer_sizes )
        {
            layer_size.width = cvRound(layer_size.width*rate + eps);
            layer_size.height = cvRound(layer_size.height*rate + eps);
        }
        else
            layer_size = layer_sizes[i];

        if( bufarr )
        {
            pyramid[i] = cvCreateMatHeader( layer_size.height, layer_size.width, src->type );
            layer_step = layer_size.width*elem_size;
            cvSetData( pyramid[i], ptr, layer_step );
            ptr += layer_step*layer_size.height;
        }
        else
            pyramid[i] = cvCreateMat( layer_size.height, layer_size.width, src->type );

        if( calc )
            cvPyrDown( pyramid[i-1], pyramid[i], filter );
            //cvResize( pyramid[i-1], pyramid[i], CV_INTER_LINEAR );
    }

    __END__;

    if( cvGetErrStatus() < 0 )
        cvReleasePyramid( &pyramid, extra_layers );

    return pyramid;
}


/* MSVC .NET 2003 spends a long time building this, thus, as the code
   is not performance-critical, we turn off the optimization here */
#if defined _MSC_VER && _MSC_VER > 1300 && !defined CV_ICC
#pragma optimize("", off)
#endif

ICV_DEF_PYR_BORDER_FUNC( 8u, uchar, int, PD_SCALE_INT )
ICV_DEF_PYR_BORDER_FUNC( 16u, ushort, int, PD_SCALE_INT )
ICV_DEF_PYR_BORDER_FUNC( 16s, short, int, PD_SCALE_INT )
ICV_DEF_PYR_BORDER_FUNC( 32f, float, float, PD_SCALE_FLT )
ICV_DEF_PYR_BORDER_FUNC( 64f, double, double, PD_SCALE_FLT )

#define ICV_DEF_INIT_PYR_BORDER_TABLE( FUNCNAME )                   \
static void icvInit##FUNCNAME##Table( CvFuncTable* tab )            \
{                                                                   \
    tab->fn_2d[CV_8U] = (void*)icv##FUNCNAME##_8u_CnR;              \
    tab->fn_2d[CV_8S] = 0;                                          \
    tab->fn_2d[CV_16U] = (void*)icv##FUNCNAME##_16u_CnR;            \
    tab->fn_2d[CV_16S] = (void*)icv##FUNCNAME##_16s_CnR;            \
    tab->fn_2d[CV_32F] = (void*)icv##FUNCNAME##_32f_CnR;            \
    tab->fn_2d[CV_64F] = (void*)icv##FUNCNAME##_64f_CnR;            \
}

ICV_DEF_INIT_PYR_BORDER_TABLE( PyrDownBorder )

/* End of file. */