PeerStreamer

/*

 * DSP utils

 * Copyright (c) 2000, 2001 Fabrice Bellard

 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>

 *

 * gmc & q-pel & 32/64 bit based MC by Michael Niedermayer <michaelni@gmx.at>

 *

 * This file is part of Libav.

 *

 * Libav is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * Libav is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with Libav; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

/**

 * @file

 * DSP utils

 */

#include "libavutil/imgutils.h"

#include "avcodec.h"

#include "dsputil.h"

#include "simple_idct.h"

#include "faandct.h"

#include "faanidct.h"

#include "mathops.h"

#include "mpegvideo.h"

#include "config.h"

#include "ac3dec.h"

#include "vorbis.h"

#include "png.h"

uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };

uint32_t ff_squareTbl[512] = {0, };

// 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size

#define pb_7f (~0UL/255 * 0x7f)

#define pb_80 (~0UL/255 * 0x80)

const uint8_t ff_zigzag_direct[64] = {

    0,   1,  8, 16,  9,  2,  3, 10,

    17, 24, 32, 25, 18, 11,  4,  5,

    12, 19, 26, 33, 40, 48, 41, 34,

    27, 20, 13,  6,  7, 14, 21, 28,

    35, 42, 49, 56, 57, 50, 43, 36,

    29, 22, 15, 23, 30, 37, 44, 51,

    58, 59, 52, 45, 38, 31, 39, 46,

    53, 60, 61, 54, 47, 55, 62, 63

};

/* Specific zigzag scan for 248 idct. NOTE that unlike the

   specification, we interleave the fields */

const uint8_t ff_zigzag248_direct[64] = {

     0,  8,  1,  9, 16, 24,  2, 10,

    17, 25, 32, 40, 48, 56, 33, 41,

    18, 26,  3, 11,  4, 12, 19, 27,

    34, 42, 49, 57, 50, 58, 35, 43,

    20, 28,  5, 13,  6, 14, 21, 29,

    36, 44, 51, 59, 52, 60, 37, 45,

    22, 30,  7, 15, 23, 31, 38, 46,

    53, 61, 54, 62, 39, 47, 55, 63,

};

/* not permutated inverse zigzag_direct + 1 for MMX quantizer */

DECLARE_ALIGNED(16, uint16_t, inv_zigzag_direct16)[64];

const uint8_t ff_alternate_horizontal_scan[64] = {

    0,  1,   2,  3,  8,  9, 16, 17,

    10, 11,  4,  5,  6,  7, 15, 14,

    13, 12, 19, 18, 24, 25, 32, 33,

    26, 27, 20, 21, 22, 23, 28, 29,

    30, 31, 34, 35, 40, 41, 48, 49,

    42, 43, 36, 37, 38, 39, 44, 45,

    46, 47, 50, 51, 56, 57, 58, 59,

    52, 53, 54, 55, 60, 61, 62, 63,

};

const uint8_t ff_alternate_vertical_scan[64] = {

    0,  8,  16, 24,  1,  9,  2, 10,

    17, 25, 32, 40, 48, 56, 57, 49,

    41, 33, 26, 18,  3, 11,  4, 12,

    19, 27, 34, 42, 50, 58, 35, 43,

    51, 59, 20, 28,  5, 13,  6, 14,

    21, 29, 36, 44, 52, 60, 37, 45,

    53, 61, 22, 30,  7, 15, 23, 31,

    38, 46, 54, 62, 39, 47, 55, 63,

};

/* Input permutation for the simple_idct_mmx */

static const uint8_t simple_mmx_permutation[64]={

        0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,

        0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,

        0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,

        0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,

        0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,

        0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,

        0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,

        0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,

};

static const uint8_t idct_sse2_row_perm[8] = {0, 4, 1, 5, 2, 6, 3, 7};

void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){

    int i;

    int end;

    st->scantable= src_scantable;

    for(i=0; i<64; i++){

        int j;

        j = src_scantable[i];

        st->permutated[i] = permutation[j];

#if ARCH_PPC

        st->inverse[j] = i;

#endif

    }

    end=-1;

    for(i=0; i<64; i++){

        int j;

        j = st->permutated[i];

        if(j>end) end=j;

        st->raster_end[i]= end;

    }

}

static int pix_sum_c(uint8_t * pix, int line_size)

{

    int s, i, j;

    s = 0;

    for (i = 0; i < 16; i++) {

        for (j = 0; j < 16; j += 8) {

            s += pix[0];

            s += pix[1];

            s += pix[2];

            s += pix[3];

            s += pix[4];

            s += pix[5];

            s += pix[6];

            s += pix[7];

            pix += 8;

        }

        pix += line_size - 16;

    }

    return s;

}

static int pix_norm1_c(uint8_t * pix, int line_size)

{

    int s, i, j;

    uint32_t *sq = ff_squareTbl + 256;

    s = 0;

    for (i = 0; i < 16; i++) {

        for (j = 0; j < 16; j += 8) {

#if 0

            s += sq[pix[0]];

            s += sq[pix[1]];

            s += sq[pix[2]];

            s += sq[pix[3]];

            s += sq[pix[4]];

            s += sq[pix[5]];

            s += sq[pix[6]];

            s += sq[pix[7]];

#else

#if LONG_MAX > 2147483647

            register uint64_t x=*(uint64_t*)pix;

            s += sq[x&0xff];

            s += sq[(x>>8)&0xff];

            s += sq[(x>>16)&0xff];

            s += sq[(x>>24)&0xff];

            s += sq[(x>>32)&0xff];

            s += sq[(x>>40)&0xff];

            s += sq[(x>>48)&0xff];

            s += sq[(x>>56)&0xff];

#else

            register uint32_t x=*(uint32_t*)pix;

            s += sq[x&0xff];

            s += sq[(x>>8)&0xff];

            s += sq[(x>>16)&0xff];

            s += sq[(x>>24)&0xff];

            x=*(uint32_t*)(pix+4);

            s += sq[x&0xff];

            s += sq[(x>>8)&0xff];

            s += sq[(x>>16)&0xff];

            s += sq[(x>>24)&0xff];

#endif

#endif

            pix += 8;

        }

        pix += line_size - 16;

    }

    return s;

}

static void bswap_buf(uint32_t *dst, const uint32_t *src, int w){

    int i;

    for(i=0; i+8<=w; i+=8){

        dst[i+0]= av_bswap32(src[i+0]);

        dst[i+1]= av_bswap32(src[i+1]);

        dst[i+2]= av_bswap32(src[i+2]);

        dst[i+3]= av_bswap32(src[i+3]);

        dst[i+4]= av_bswap32(src[i+4]);

        dst[i+5]= av_bswap32(src[i+5]);

        dst[i+6]= av_bswap32(src[i+6]);

        dst[i+7]= av_bswap32(src[i+7]);

    }

    for(;i<w; i++){

        dst[i+0]= av_bswap32(src[i+0]);

    }

}

static void bswap16_buf(uint16_t *dst, const uint16_t *src, int len)

{

    while (len--)

        *dst++ = av_bswap16(*src++);

}

static int sse4_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)

{

    int s, i;

    uint32_t *sq = ff_squareTbl + 256;

    s = 0;

    for (i = 0; i < h; i++) {

        s += sq[pix1[0] - pix2[0]];

        s += sq[pix1[1] - pix2[1]];

        s += sq[pix1[2] - pix2[2]];

        s += sq[pix1[3] - pix2[3]];

        pix1 += line_size;

        pix2 += line_size;

    }

    return s;

}

static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)

{

    int s, i;

    uint32_t *sq = ff_squareTbl + 256;

    s = 0;

    for (i = 0; i < h; i++) {

        s += sq[pix1[0] - pix2[0]];

        s += sq[pix1[1] - pix2[1]];

        s += sq[pix1[2] - pix2[2]];

        s += sq[pix1[3] - pix2[3]];

        s += sq[pix1[4] - pix2[4]];

        s += sq[pix1[5] - pix2[5]];

        s += sq[pix1[6] - pix2[6]];

        s += sq[pix1[7] - pix2[7]];

        pix1 += line_size;

        pix2 += line_size;

    }

    return s;

}

static int sse16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

{

    int s, i;

    uint32_t *sq = ff_squareTbl + 256;

    s = 0;

    for (i = 0; i < h; i++) {

        s += sq[pix1[ 0] - pix2[ 0]];

        s += sq[pix1[ 1] - pix2[ 1]];

        s += sq[pix1[ 2] - pix2[ 2]];

        s += sq[pix1[ 3] - pix2[ 3]];

        s += sq[pix1[ 4] - pix2[ 4]];

        s += sq[pix1[ 5] - pix2[ 5]];

        s += sq[pix1[ 6] - pix2[ 6]];

        s += sq[pix1[ 7] - pix2[ 7]];

        s += sq[pix1[ 8] - pix2[ 8]];

        s += sq[pix1[ 9] - pix2[ 9]];

        s += sq[pix1[10] - pix2[10]];

        s += sq[pix1[11] - pix2[11]];

        s += sq[pix1[12] - pix2[12]];

        s += sq[pix1[13] - pix2[13]];

        s += sq[pix1[14] - pix2[14]];

        s += sq[pix1[15] - pix2[15]];

        pix1 += line_size;

        pix2 += line_size;

    }

    return s;

}

/* draw the edges of width 'w' of an image of size width, height */

//FIXME check that this is ok for mpeg4 interlaced

static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)

{

    uint8_t *ptr, *last_line;

    int i;

    last_line = buf + (height - 1) * wrap;

    for(i=0;i<w;i++) {

        /* top and bottom */

        memcpy(buf - (i + 1) * wrap, buf, width);

        memcpy(last_line + (i + 1) * wrap, last_line, width);

    }

    /* left and right */

    ptr = buf;

    for(i=0;i<height;i++) {

        memset(ptr - w, ptr[0], w);

        memset(ptr + width, ptr[width-1], w);

        ptr += wrap;

    }

    /* corners */

    for(i=0;i<w;i++) {

        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */

        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */

        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */

        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */

    }

}

/**

 * Copy a rectangular area of samples to a temporary buffer and replicate the border samples.

 * @param buf destination buffer

 * @param src source buffer

 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers

 * @param block_w width of block

 * @param block_h height of block

 * @param src_x x coordinate of the top left sample of the block in the source buffer

 * @param src_y y coordinate of the top left sample of the block in the source buffer

 * @param w width of the source buffer

 * @param h height of the source buffer

 */

void ff_emulated_edge_mc(uint8_t *buf, const uint8_t *src, int linesize, int block_w, int block_h,

                                    int src_x, int src_y, int w, int h){

    int x, y;

    int start_y, start_x, end_y, end_x;

    if(src_y>= h){

        src+= (h-1-src_y)*linesize;

        src_y=h-1;

    }else if(src_y<=-block_h){

        src+= (1-block_h-src_y)*linesize;

        src_y=1-block_h;

    }

    if(src_x>= w){

        src+= (w-1-src_x);

        src_x=w-1;

    }else if(src_x<=-block_w){

        src+= (1-block_w-src_x);

        src_x=1-block_w;

    }

    start_y= FFMAX(0, -src_y);

    start_x= FFMAX(0, -src_x);

    end_y= FFMIN(block_h, h-src_y);

    end_x= FFMIN(block_w, w-src_x);

    assert(start_y < end_y && block_h);

    assert(start_x < end_x && block_w);

    w    = end_x - start_x;

    src += start_y*linesize + start_x;

    buf += start_x;

    //top

    for(y=0; y<start_y; y++){

        memcpy(buf, src, w);

        buf += linesize;

    }

    // copy existing part

    for(; y<end_y; y++){

        memcpy(buf, src, w);

        src += linesize;

        buf += linesize;

    }

    //bottom

    src -= linesize;

    for(; y<block_h; y++){

        memcpy(buf, src, w);

        buf += linesize;

    }

    buf -= block_h * linesize + start_x;

    while (block_h--){

       //left

        for(x=0; x<start_x; x++){

            buf[x] = buf[start_x];

        }

       //right

        for(x=end_x; x<block_w; x++){

            buf[x] = buf[end_x - 1];

        }

        buf += linesize;

    }

}

static void get_pixels_c(DCTELEM *restrict block, const uint8_t *pixels, int line_size)

{

    int i;

    /* read the pixels */

    for(i=0;i<8;i++) {

        block[0] = pixels[0];

        block[1] = pixels[1];

        block[2] = pixels[2];

        block[3] = pixels[3];

        block[4] = pixels[4];

        block[5] = pixels[5];

        block[6] = pixels[6];

        block[7] = pixels[7];

        pixels += line_size;

        block += 8;

    }

}

static void diff_pixels_c(DCTELEM *restrict block, const uint8_t *s1,

                          const uint8_t *s2, int stride){

    int i;

    /* read the pixels */

    for(i=0;i<8;i++) {

        block[0] = s1[0] - s2[0];

        block[1] = s1[1] - s2[1];

        block[2] = s1[2] - s2[2];

        block[3] = s1[3] - s2[3];

        block[4] = s1[4] - s2[4];

        block[5] = s1[5] - s2[5];

        block[6] = s1[6] - s2[6];

        block[7] = s1[7] - s2[7];

        s1 += stride;

        s2 += stride;

        block += 8;

    }

}

void ff_put_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,

                             int line_size)

{

    int i;

    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */

    for(i=0;i<8;i++) {

        pixels[0] = cm[block[0]];

        pixels[1] = cm[block[1]];

        pixels[2] = cm[block[2]];

        pixels[3] = cm[block[3]];

        pixels[4] = cm[block[4]];

        pixels[5] = cm[block[5]];

        pixels[6] = cm[block[6]];

        pixels[7] = cm[block[7]];

        pixels += line_size;

        block += 8;

    }

}

static void put_pixels_clamped4_c(const DCTELEM *block, uint8_t *restrict pixels,

                                 int line_size)

{

    int i;

    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */

    for(i=0;i<4;i++) {

        pixels[0] = cm[block[0]];

        pixels[1] = cm[block[1]];

        pixels[2] = cm[block[2]];

        pixels[3] = cm[block[3]];

        pixels += line_size;

        block += 8;

    }

}

static void put_pixels_clamped2_c(const DCTELEM *block, uint8_t *restrict pixels,

                                 int line_size)

{

    int i;

    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */

    for(i=0;i<2;i++) {

        pixels[0] = cm[block[0]];

        pixels[1] = cm[block[1]];

        pixels += line_size;

        block += 8;

    }

}

void ff_put_signed_pixels_clamped_c(const DCTELEM *block,

                                    uint8_t *restrict pixels,

                                    int line_size)

{

    int i, j;

    for (i = 0; i < 8; i++) {

        for (j = 0; j < 8; j++) {

            if (*block < -128)

                *pixels = 0;

            else if (*block > 127)

                *pixels = 255;

            else

                *pixels = (uint8_t)(*block + 128);

            block++;

            pixels++;

        }

        pixels += (line_size - 8);

    }

}

static void put_pixels_nonclamped_c(const DCTELEM *block, uint8_t *restrict pixels,

                                    int line_size)

{

    int i;

    /* read the pixels */

    for(i=0;i<8;i++) {

        pixels[0] = block[0];

        pixels[1] = block[1];

        pixels[2] = block[2];

        pixels[3] = block[3];

        pixels[4] = block[4];

        pixels[5] = block[5];

        pixels[6] = block[6];

        pixels[7] = block[7];

        pixels += line_size;

        block += 8;

    }

}

void ff_add_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,

                             int line_size)

{

    int i;

    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */

    for(i=0;i<8;i++) {

        pixels[0] = cm[pixels[0] + block[0]];

        pixels[1] = cm[pixels[1] + block[1]];

        pixels[2] = cm[pixels[2] + block[2]];

        pixels[3] = cm[pixels[3] + block[3]];

        pixels[4] = cm[pixels[4] + block[4]];

        pixels[5] = cm[pixels[5] + block[5]];

        pixels[6] = cm[pixels[6] + block[6]];

        pixels[7] = cm[pixels[7] + block[7]];

        pixels += line_size;

        block += 8;

    }

}

static void add_pixels_clamped4_c(const DCTELEM *block, uint8_t *restrict pixels,

                          int line_size)

{

    int i;

    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */

    for(i=0;i<4;i++) {

        pixels[0] = cm[pixels[0] + block[0]];

        pixels[1] = cm[pixels[1] + block[1]];

        pixels[2] = cm[pixels[2] + block[2]];

        pixels[3] = cm[pixels[3] + block[3]];

        pixels += line_size;

        block += 8;

    }

}

static void add_pixels_clamped2_c(const DCTELEM *block, uint8_t *restrict pixels,

                          int line_size)

{

    int i;

    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */

    for(i=0;i<2;i++) {

        pixels[0] = cm[pixels[0] + block[0]];

        pixels[1] = cm[pixels[1] + block[1]];

        pixels += line_size;

        block += 8;

    }

}

static void add_pixels8_c(uint8_t *restrict pixels, DCTELEM *block, int line_size)

{

    int i;

    for(i=0;i<8;i++) {

        pixels[0] += block[0];

        pixels[1] += block[1];

        pixels[2] += block[2];

        pixels[3] += block[3];

        pixels[4] += block[4];

        pixels[5] += block[5];

        pixels[6] += block[6];

        pixels[7] += block[7];

        pixels += line_size;

        block += 8;

    }

}

static void add_pixels4_c(uint8_t *restrict pixels, DCTELEM *block, int line_size)

{

    int i;

    for(i=0;i<4;i++) {

        pixels[0] += block[0];

        pixels[1] += block[1];

        pixels[2] += block[2];

        pixels[3] += block[3];

        pixels += line_size;

        block += 4;

    }

}

static int sum_abs_dctelem_c(DCTELEM *block)

{

    int sum=0, i;

    for(i=0; i<64; i++)

        sum+= FFABS(block[i]);

    return sum;

}

static void fill_block16_c(uint8_t *block, uint8_t value, int line_size, int h)

{

    int i;

    for (i = 0; i < h; i++) {

        memset(block, value, 16);

        block += line_size;

    }

}

static void fill_block8_c(uint8_t *block, uint8_t value, int line_size, int h)

{

    int i;

    for (i = 0; i < h; i++) {

        memset(block, value, 8);

        block += line_size;

    }

}

static void scale_block_c(const uint8_t src[64]/*align 8*/, uint8_t *dst/*align 8*/, int linesize)

{

    int i, j;

    uint16_t *dst1 = (uint16_t *) dst;

    uint16_t *dst2 = (uint16_t *)(dst + linesize);

    for (j = 0; j < 8; j++) {

        for (i = 0; i < 8; i++) {

            dst1[i] = dst2[i] = src[i] * 0x0101;

        }

        src  += 8;

        dst1 += linesize;

        dst2 += linesize;

    }

}

#if 0

#define PIXOP2(OPNAME, OP) \

static void OPNAME ## _pixels(uint8_t *block, const uint8_t *pixels, int line_size, int h)\

{\

    int i;\

    for(i=0; i<h; i++){\

        OP(*((uint64_t*)block), AV_RN64(pixels));\

        pixels+=line_size;\

        block +=line_size;\

    }\

}\

\

static void OPNAME ## _no_rnd_pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\

{\

    int i;\

    for(i=0; i<h; i++){\

        const uint64_t a= AV_RN64(pixels  );\

        const uint64_t b= AV_RN64(pixels+1);\

        OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\

        pixels+=line_size;\

        block +=line_size;\

    }\

}\

\

static void OPNAME ## _pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\

{\

    int i;\

    for(i=0; i<h; i++){\

        const uint64_t a= AV_RN64(pixels  );\

        const uint64_t b= AV_RN64(pixels+1);\

        OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\

        pixels+=line_size;\

        block +=line_size;\

    }\

}\

\

static void OPNAME ## _no_rnd_pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\

{\

    int i;\

    for(i=0; i<h; i++){\

        const uint64_t a= AV_RN64(pixels          );\

        const uint64_t b= AV_RN64(pixels+line_size);\

        OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\

        pixels+=line_size;\

        block +=line_size;\

    }\

}\

\

static void OPNAME ## _pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\

{\

    int i;\

    for(i=0; i<h; i++){\

        const uint64_t a= AV_RN64(pixels          );\

        const uint64_t b= AV_RN64(pixels+line_size);\

        OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\

        pixels+=line_size;\

        block +=line_size;\

    }\

}\

\

static void OPNAME ## _pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\

{\

        int i;\

        const uint64_t a= AV_RN64(pixels  );\

        const uint64_t b= AV_RN64(pixels+1);\

        uint64_t l0=  (a&0x0303030303030303ULL)\

                    + (b&0x0303030303030303ULL)\

                    + 0x0202020202020202ULL;\

        uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\

                   + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\

        uint64_t l1,h1;\

\

        pixels+=line_size;\

        for(i=0; i<h; i+=2){\

            uint64_t a= AV_RN64(pixels  );\

            uint64_t b= AV_RN64(pixels+1);\

            l1=  (a&0x0303030303030303ULL)\

               + (b&0x0303030303030303ULL);\

            h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\

              + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\

            OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\

            pixels+=line_size;\

            block +=line_size;\

            a= AV_RN64(pixels  );\

            b= AV_RN64(pixels+1);\

            l0=  (a&0x0303030303030303ULL)\

               + (b&0x0303030303030303ULL)\

               + 0x0202020202020202ULL;\

            h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\

              + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\

            OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\

            pixels+=line_size;\

            block +=line_size;\

        }\

}\

\

static void OPNAME ## _no_rnd_pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\

{\

        int i;\

        const uint64_t a= AV_RN64(pixels  );\

        const uint64_t b= AV_RN64(pixels+1);\

        uint64_t l0=  (a&0x0303030303030303ULL)\

                    + (b&0x0303030303030303ULL)\

                    + 0x0101010101010101ULL;\

        uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\

                   + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\

        uint64_t l1,h1;\

\

        pixels+=line_size;\

        for(i=0; i<h; i+=2){\

            uint64_t a= AV_RN64(pixels  );\

            uint64_t b= AV_RN64(pixels+1);\

            l1=  (a&0x0303030303030303ULL)\

               + (b&0x0303030303030303ULL);\

            h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\

              + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\

            OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\

            pixels+=line_size;\

            block +=line_size;\

            a= AV_RN64(pixels  );\

            b= AV_RN64(pixels+1);\

            l0=  (a&0x0303030303030303ULL)\

               + (b&0x0303030303030303ULL)\

               + 0x0101010101010101ULL;\

            h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\

              + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\

            OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\

            pixels+=line_size;\

            block +=line_size;\

        }\

}\

\

CALL_2X_PIXELS(OPNAME ## _pixels16_c    , OPNAME ## _pixels_c    , 8)\

CALL_2X_PIXELS(OPNAME ## _pixels16_x2_c , OPNAME ## _pixels_x2_c , 8)\

CALL_2X_PIXELS(OPNAME ## _pixels16_y2_c , OPNAME ## _pixels_y2_c , 8)\

CALL_2X_PIXELS(OPNAME ## _pixels16_xy2_c, OPNAME ## _pixels_xy2_c, 8)\

CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_x2_c , OPNAME ## _no_rnd_pixels_x2_c , 8)\

CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_y2_c , OPNAME ## _no_rnd_pixels_y2_c , 8)\

CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_xy2_c, OPNAME ## _no_rnd_pixels_xy2_c, 8)

#define op_avg(a, b) a = ( ((a)|(b)) - ((((a)^(b))&0xFEFEFEFEFEFEFEFEULL)>>1) )

#else // 64 bit variant

#define PIXOP2(OPNAME, OP) \

static void OPNAME ## _pixels2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    int i;\

    for(i=0; i<h; i++){\

        OP(*((uint16_t*)(block  )), AV_RN16(pixels  ));\

        pixels+=line_size;\

        block +=line_size;\

    }\

}\

static void OPNAME ## _pixels4_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    int i;\

    for(i=0; i<h; i++){\

        OP(*((uint32_t*)(block  )), AV_RN32(pixels  ));\

        pixels+=line_size;\

        block +=line_size;\

    }\

}\

static void OPNAME ## _pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    int i;\

    for(i=0; i<h; i++){\

        OP(*((uint32_t*)(block  )), AV_RN32(pixels  ));\

        OP(*((uint32_t*)(block+4)), AV_RN32(pixels+4));\

        pixels+=line_size;\

        block +=line_size;\

    }\

}\

static inline void OPNAME ## _no_rnd_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    OPNAME ## _pixels8_c(block, pixels, line_size, h);\

}\

\

static inline void OPNAME ## _no_rnd_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \

                                                int src_stride1, int src_stride2, int h){\

    int i;\

    for(i=0; i<h; i++){\

        uint32_t a,b;\

        a= AV_RN32(&src1[i*src_stride1  ]);\

        b= AV_RN32(&src2[i*src_stride2  ]);\

        OP(*((uint32_t*)&dst[i*dst_stride  ]), no_rnd_avg32(a, b));\

        a= AV_RN32(&src1[i*src_stride1+4]);\

        b= AV_RN32(&src2[i*src_stride2+4]);\

        OP(*((uint32_t*)&dst[i*dst_stride+4]), no_rnd_avg32(a, b));\

    }\

}\

\

static inline void OPNAME ## _pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \

                                                int src_stride1, int src_stride2, int h){\

    int i;\

    for(i=0; i<h; i++){\

        uint32_t a,b;\

        a= AV_RN32(&src1[i*src_stride1  ]);\

        b= AV_RN32(&src2[i*src_stride2  ]);\

        OP(*((uint32_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));\

        a= AV_RN32(&src1[i*src_stride1+4]);\

        b= AV_RN32(&src2[i*src_stride2+4]);\

        OP(*((uint32_t*)&dst[i*dst_stride+4]), rnd_avg32(a, b));\

    }\

}\

\

static inline void OPNAME ## _pixels4_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \

                                                int src_stride1, int src_stride2, int h){\

    int i;\

    for(i=0; i<h; i++){\

        uint32_t a,b;\

        a= AV_RN32(&src1[i*src_stride1  ]);\

        b= AV_RN32(&src2[i*src_stride2  ]);\

        OP(*((uint32_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));\

    }\

}\

\

static inline void OPNAME ## _pixels2_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \

                                                int src_stride1, int src_stride2, int h){\

    int i;\

    for(i=0; i<h; i++){\

        uint32_t a,b;\

        a= AV_RN16(&src1[i*src_stride1  ]);\

        b= AV_RN16(&src2[i*src_stride2  ]);\

        OP(*((uint16_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));\

    }\

}\

\

static inline void OPNAME ## _pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \

                                                int src_stride1, int src_stride2, int h){\

    OPNAME ## _pixels8_l2(dst  , src1  , src2  , dst_stride, src_stride1, src_stride2, h);\

    OPNAME ## _pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);\

}\

\

static inline void OPNAME ## _no_rnd_pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \

                                                int src_stride1, int src_stride2, int h){\

    OPNAME ## _no_rnd_pixels8_l2(dst  , src1  , src2  , dst_stride, src_stride1, src_stride2, h);\

    OPNAME ## _no_rnd_pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);\

}\

\

static inline void OPNAME ## _no_rnd_pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    OPNAME ## _no_rnd_pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\

}\

\

static inline void OPNAME ## _pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    OPNAME ## _pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\

}\

\

static inline void OPNAME ## _no_rnd_pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    OPNAME ## _no_rnd_pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\

}\

\

static inline void OPNAME ## _pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    OPNAME ## _pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\

}\

\

static inline void OPNAME ## _pixels8_l4(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, const uint8_t *src4,\

                 int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\

    int i;\

    for(i=0; i<h; i++){\

        uint32_t a, b, c, d, l0, l1, h0, h1;\

        a= AV_RN32(&src1[i*src_stride1]);\

        b= AV_RN32(&src2[i*src_stride2]);\

        c= AV_RN32(&src3[i*src_stride3]);\

        d= AV_RN32(&src4[i*src_stride4]);\

        l0=  (a&0x03030303UL)\

           + (b&0x03030303UL)\

           + 0x02020202UL;\

        h0= ((a&0xFCFCFCFCUL)>>2)\

          + ((b&0xFCFCFCFCUL)>>2);\

        l1=  (c&0x03030303UL)\

           + (d&0x03030303UL);\

        h1= ((c&0xFCFCFCFCUL)>>2)\

          + ((d&0xFCFCFCFCUL)>>2);\

        OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

        a= AV_RN32(&src1[i*src_stride1+4]);\

        b= AV_RN32(&src2[i*src_stride2+4]);\

        c= AV_RN32(&src3[i*src_stride3+4]);\

        d= AV_RN32(&src4[i*src_stride4+4]);\

        l0=  (a&0x03030303UL)\

           + (b&0x03030303UL)\

           + 0x02020202UL;\

        h0= ((a&0xFCFCFCFCUL)>>2)\

          + ((b&0xFCFCFCFCUL)>>2);\

        l1=  (c&0x03030303UL)\

           + (d&0x03030303UL);\

        h1= ((c&0xFCFCFCFCUL)>>2)\

          + ((d&0xFCFCFCFCUL)>>2);\

        OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

    }\

}\

\

static inline void OPNAME ## _pixels4_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    OPNAME ## _pixels4_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\

}\

\

static inline void OPNAME ## _pixels4_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    OPNAME ## _pixels4_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\

}\

\

static inline void OPNAME ## _pixels2_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    OPNAME ## _pixels2_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\

}\

\

static inline void OPNAME ## _pixels2_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

    OPNAME ## _pixels2_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\

}\

\

static inline void OPNAME ## _no_rnd_pixels8_l4(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, const uint8_t *src4,\

                 int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\

    int i;\

    for(i=0; i<h; i++){\

        uint32_t a, b, c, d, l0, l1, h0, h1;\

        a= AV_RN32(&src1[i*src_stride1]);\

        b= AV_RN32(&src2[i*src_stride2]);\

        c= AV_RN32(&src3[i*src_stride3]);\

        d= AV_RN32(&src4[i*src_stride4]);\

        l0=  (a&0x03030303UL)\

           + (b&0x03030303UL)\

           + 0x01010101UL;\

        h0= ((a&0xFCFCFCFCUL)>>2)\

          + ((b&0xFCFCFCFCUL)>>2);\

        l1=  (c&0x03030303UL)\

           + (d&0x03030303UL);\

        h1= ((c&0xFCFCFCFCUL)>>2)\

          + ((d&0xFCFCFCFCUL)>>2);\

        OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

        a= AV_RN32(&src1[i*src_stride1+4]);\

        b= AV_RN32(&src2[i*src_stride2+4]);\

        c= AV_RN32(&src3[i*src_stride3+4]);\

        d= AV_RN32(&src4[i*src_stride4+4]);\

        l0=  (a&0x03030303UL)\

           + (b&0x03030303UL)\

           + 0x01010101UL;\

        h0= ((a&0xFCFCFCFCUL)>>2)\

          + ((b&0xFCFCFCFCUL)>>2);\

        l1=  (c&0x03030303UL)\

           + (d&0x03030303UL);\

        h1= ((c&0xFCFCFCFCUL)>>2)\

          + ((d&0xFCFCFCFCUL)>>2);\

        OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

    }\

}\

static inline void OPNAME ## _pixels16_l4(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, const uint8_t *src4,\

                 int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\

    OPNAME ## _pixels8_l4(dst  , src1  , src2  , src3  , src4  , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\

    OPNAME ## _pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\

}\

static inline void OPNAME ## _no_rnd_pixels16_l4(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, const uint8_t *src4,\

                 int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\

    OPNAME ## _no_rnd_pixels8_l4(dst  , src1  , src2  , src3  , src4  , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\

    OPNAME ## _no_rnd_pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\

}\

\

static inline void OPNAME ## _pixels2_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\

{\

        int i, a0, b0, a1, b1;\

        a0= pixels[0];\

        b0= pixels[1] + 2;\

        a0 += b0;\

        b0 += pixels[2];\

\

        pixels+=line_size;\

        for(i=0; i<h; i+=2){\

            a1= pixels[0];\

            b1= pixels[1];\

            a1 += b1;\

            b1 += pixels[2];\

\

            block[0]= (a1+a0)>>2; /* FIXME non put */\

            block[1]= (b1+b0)>>2;\

\

            pixels+=line_size;\

            block +=line_size;\

\

            a0= pixels[0];\

            b0= pixels[1] + 2;\

            a0 += b0;\

            b0 += pixels[2];\

\

            block[0]= (a1+a0)>>2;\

            block[1]= (b1+b0)>>2;\

            pixels+=line_size;\

            block +=line_size;\

        }\

}\

\

static inline void OPNAME ## _pixels4_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\

{\

        int i;\

        const uint32_t a= AV_RN32(pixels  );\

        const uint32_t b= AV_RN32(pixels+1);\

        uint32_t l0=  (a&0x03030303UL)\

                    + (b&0x03030303UL)\

                    + 0x02020202UL;\

        uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\

                   + ((b&0xFCFCFCFCUL)>>2);\

        uint32_t l1,h1;\

\

        pixels+=line_size;\

        for(i=0; i<h; i+=2){\

            uint32_t a= AV_RN32(pixels  );\

            uint32_t b= AV_RN32(pixels+1);\

            l1=  (a&0x03030303UL)\

               + (b&0x03030303UL);\

            h1= ((a&0xFCFCFCFCUL)>>2)\

              + ((b&0xFCFCFCFCUL)>>2);\

            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

            pixels+=line_size;\

            block +=line_size;\

            a= AV_RN32(pixels  );\

            b= AV_RN32(pixels+1);\

            l0=  (a&0x03030303UL)\

               + (b&0x03030303UL)\

               + 0x02020202UL;\

            h0= ((a&0xFCFCFCFCUL)>>2)\

              + ((b&0xFCFCFCFCUL)>>2);\

            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

            pixels+=line_size;\

            block +=line_size;\

        }\

}\

\

static inline void OPNAME ## _pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\

{\

    int j;\

    for(j=0; j<2; j++){\

        int i;\

        const uint32_t a= AV_RN32(pixels  );\

        const uint32_t b= AV_RN32(pixels+1);\

        uint32_t l0=  (a&0x03030303UL)\

                    + (b&0x03030303UL)\

                    + 0x02020202UL;\

        uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\

                   + ((b&0xFCFCFCFCUL)>>2);\

        uint32_t l1,h1;\

\

        pixels+=line_size;\

        for(i=0; i<h; i+=2){\

            uint32_t a= AV_RN32(pixels  );\

            uint32_t b= AV_RN32(pixels+1);\

            l1=  (a&0x03030303UL)\

               + (b&0x03030303UL);\

            h1= ((a&0xFCFCFCFCUL)>>2)\

              + ((b&0xFCFCFCFCUL)>>2);\

            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

            pixels+=line_size;\

            block +=line_size;\

            a= AV_RN32(pixels  );\

            b= AV_RN32(pixels+1);\

            l0=  (a&0x03030303UL)\

               + (b&0x03030303UL)\

               + 0x02020202UL;\

            h0= ((a&0xFCFCFCFCUL)>>2)\

              + ((b&0xFCFCFCFCUL)>>2);\

            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

            pixels+=line_size;\

            block +=line_size;\

        }\

        pixels+=4-line_size*(h+1);\

        block +=4-line_size*h;\

    }\

}\

\

static inline void OPNAME ## _no_rnd_pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\

{\

    int j;\

    for(j=0; j<2; j++){\

        int i;\

        const uint32_t a= AV_RN32(pixels  );\

        const uint32_t b= AV_RN32(pixels+1);\

        uint32_t l0=  (a&0x03030303UL)\

                    + (b&0x03030303UL)\

                    + 0x01010101UL;\

        uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\

                   + ((b&0xFCFCFCFCUL)>>2);\

        uint32_t l1,h1;\

\

        pixels+=line_size;\

        for(i=0; i<h; i+=2){\

            uint32_t a= AV_RN32(pixels  );\

            uint32_t b= AV_RN32(pixels+1);\

            l1=  (a&0x03030303UL)\

               + (b&0x03030303UL);\

            h1= ((a&0xFCFCFCFCUL)>>2)\

              + ((b&0xFCFCFCFCUL)>>2);\

            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

            pixels+=line_size;\

            block +=line_size;\

            a= AV_RN32(pixels  );\

            b= AV_RN32(pixels+1);\

            l0=  (a&0x03030303UL)\

               + (b&0x03030303UL)\

               + 0x01010101UL;\

            h0= ((a&0xFCFCFCFCUL)>>2)\

              + ((b&0xFCFCFCFCUL)>>2);\

            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\

            pixels+=line_size;\

            block +=line_size;\

        }\

        pixels+=4-line_size*(h+1);\

        block +=4-line_size*h;\

    }\

}\

\

CALL_2X_PIXELS(OPNAME ## _pixels16_c  , OPNAME ## _pixels8_c  , 8)\

CALL_2X_PIXELS(OPNAME ## _pixels16_x2_c , OPNAME ## _pixels8_x2_c , 8)\

CALL_2X_PIXELS(OPNAME ## _pixels16_y2_c , OPNAME ## _pixels8_y2_c , 8)\

CALL_2X_PIXELS(OPNAME ## _pixels16_xy2_c, OPNAME ## _pixels8_xy2_c, 8)\

av_unused CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_c  , OPNAME ## _pixels8_c         , 8)\

CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_x2_c , OPNAME ## _no_rnd_pixels8_x2_c , 8)\

CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_y2_c , OPNAME ## _no_rnd_pixels8_y2_c , 8)\

CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_xy2_c, OPNAME ## _no_rnd_pixels8_xy2_c, 8)\

#define op_avg(a, b) a = rnd_avg32(a, b)

#endif

#define op_put(a, b) a = b

PIXOP2(avg, op_avg)

PIXOP2(put, op_put)

#undef op_avg

#undef op_put

#define put_no_rnd_pixels8_c  put_pixels8_c

#define put_no_rnd_pixels16_c put_pixels16_c

#define avg2(a,b) ((a+b+1)>>1)

#define avg4(a,b,c,d) ((a+b+c+d+2)>>2)

static void put_no_rnd_pixels16_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){

    put_no_rnd_pixels16_l2(dst, a, b, stride, stride, stride, h);

}

static void put_no_rnd_pixels8_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){

    put_no_rnd_pixels8_l2(dst, a, b, stride, stride, stride, h);

}

static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)

{

    const int A=(16-x16)*(16-y16);

    const int B=(   x16)*(16-y16);

    const int C=(16-x16)*(   y16);

    const int D=(   x16)*(   y16);

    int i;

    for(i=0; i<h; i++)

    {

        dst[0]= (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + rounder)>>8;

        dst[1]= (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + rounder)>>8;

        dst[2]= (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + rounder)>>8;