static int RENAME(swScale)(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,

                           int srcSliceH, uint8_t* dst[], int dstStride[])

{

    /* load a few things into local vars to make the code more readable? and faster */

    const int srcW= c->srcW;

    const int dstW= c->dstW;

    const int dstH= c->dstH;

    const int chrDstW= c->chrDstW;

    const int chrSrcW= c->chrSrcW;

    const int lumXInc= c->lumXInc;

    const int chrXInc= c->chrXInc;

    const enum PixelFormat dstFormat= c->dstFormat;

    const enum PixelFormat srcFormat= c->srcFormat;

    const int flags= c->flags;

    int16_t *vLumFilterPos= c->vLumFilterPos;

    int16_t *vChrFilterPos= c->vChrFilterPos;

    int16_t *hLumFilterPos= c->hLumFilterPos;

    int16_t *hChrFilterPos= c->hChrFilterPos;

    int16_t *vLumFilter= c->vLumFilter;

    int16_t *vChrFilter= c->vChrFilter;

    int16_t *hLumFilter= c->hLumFilter;

    int16_t *hChrFilter= c->hChrFilter;

    int32_t *lumMmxFilter= c->lumMmxFilter;

    int32_t *chrMmxFilter= c->chrMmxFilter;

    int32_t *alpMmxFilter= c->alpMmxFilter;

    const int vLumFilterSize= c->vLumFilterSize;

    const int vChrFilterSize= c->vChrFilterSize;

    const int hLumFilterSize= c->hLumFilterSize;

    const int hChrFilterSize= c->hChrFilterSize;

    int16_t **lumPixBuf= c->lumPixBuf;

    int16_t **chrPixBuf= c->chrPixBuf;

    int16_t **alpPixBuf= c->alpPixBuf;

    const int vLumBufSize= c->vLumBufSize;

    const int vChrBufSize= c->vChrBufSize;

    uint8_t *formatConvBuffer= c->formatConvBuffer;

    const int chrSrcSliceY= srcSliceY >> c->chrSrcVSubSample;

    const int chrSrcSliceH= -((-srcSliceH) >> c->chrSrcVSubSample);

    int lastDstY;

    uint32_t *pal=c->pal_yuv;



    /* vars which will change and which we need to store back in the context */

    int dstY= c->dstY;

    int lumBufIndex= c->lumBufIndex;

    int chrBufIndex= c->chrBufIndex;

    int lastInLumBuf= c->lastInLumBuf;

    int lastInChrBuf= c->lastInChrBuf;



    if (isPacked(c->srcFormat)) {

        src[0]=

        src[1]=

        src[2]=

        src[3]= src[0];

        srcStride[0]=

        srcStride[1]=

        srcStride[2]=

        srcStride[3]= srcStride[0];

    }

    srcStride[1]<<= c->vChrDrop;

    srcStride[2]<<= c->vChrDrop;



    DEBUG_BUFFERS("swScale() %p[%d] %p[%d] %p[%d] %p[%d] -> %p[%d] %p[%d] %p[%d] %p[%d]\n",

                  src[0], srcStride[0], src[1], srcStride[1], src[2], srcStride[2], src[3], srcStride[3],

                  dst[0], dstStride[0], dst[1], dstStride[1], dst[2], dstStride[2], dst[3], dstStride[3]);

    DEBUG_BUFFERS("srcSliceY: %d srcSliceH: %d dstY: %d dstH: %d\n",

                   srcSliceY,    srcSliceH,    dstY,    dstH);

    DEBUG_BUFFERS("vLumFilterSize: %d vLumBufSize: %d vChrFilterSize: %d vChrBufSize: %d\n",

                   vLumFilterSize,    vLumBufSize,    vChrFilterSize,    vChrBufSize);



    if (dstStride[0]%8 !=0 || dstStride[1]%8 !=0 || dstStride[2]%8 !=0 || dstStride[3]%8 != 0) {

        static int warnedAlready=0; //FIXME move this into the context perhaps

        if (flags & SWS_PRINT_INFO && !warnedAlready) {

            av_log(c, AV_LOG_WARNING, "Warning: dstStride is not aligned!\n"

                   "         ->cannot do aligned memory accesses anymore\n");

            warnedAlready=1;

        }

    }



    /* Note the user might start scaling the picture in the middle so this

       will not get executed. This is not really intended but works

       currently, so people might do it. */

    if (srcSliceY ==0) {

        lumBufIndex=0;

        chrBufIndex=0;

        dstY=0;

        lastInLumBuf= -1;

        lastInChrBuf= -1;

    }



    lastDstY= dstY;



    for (;dstY < dstH; dstY++) {

        unsigned char *dest =dst[0]+dstStride[0]*dstY;

        const int chrDstY= dstY>>c->chrDstVSubSample;

        unsigned char *uDest=dst[1]+dstStride[1]*chrDstY;

        unsigned char *vDest=dst[2]+dstStride[2]*chrDstY;

        unsigned char *aDest=(CONFIG_SWSCALE_ALPHA && alpPixBuf) ? dst[3]+dstStride[3]*dstY : NULL;



        const int firstLumSrcY= vLumFilterPos[dstY]; //First line needed as input

        const int firstChrSrcY= vChrFilterPos[chrDstY]; //First line needed as input

        int lastLumSrcY= firstLumSrcY + vLumFilterSize -1; // Last line needed as input

        int lastChrSrcY= firstChrSrcY + vChrFilterSize -1; // Last line needed as input

        int enough_lines;



        //handle holes (FAST_BILINEAR & weird filters)

        if (firstLumSrcY > lastInLumBuf) lastInLumBuf= firstLumSrcY-1;

        if (firstChrSrcY > lastInChrBuf) lastInChrBuf= firstChrSrcY-1;

        assert(firstLumSrcY >= lastInLumBuf - vLumBufSize + 1);

        assert(firstChrSrcY >= lastInChrBuf - vChrBufSize + 1);



        // Do we have enough lines in this slice to output the dstY line

        enough_lines = lastLumSrcY < srcSliceY + srcSliceH && lastChrSrcY < -((-srcSliceY - srcSliceH)>>c->chrSrcVSubSample);

        if (!enough_lines) {

            lastLumSrcY = srcSliceY + srcSliceH - 1;

            lastChrSrcY = chrSrcSliceY + chrSrcSliceH - 1;

        }



        DEBUG_BUFFERS("dstY: %d\n", dstY);

        DEBUG_BUFFERS("\tfirstLumSrcY: %d lastLumSrcY: %d lastInLumBuf: %d\n",

                         firstLumSrcY,    lastLumSrcY,    lastInLumBuf);

        DEBUG_BUFFERS("\tfirstChrSrcY: %d lastChrSrcY: %d lastInChrBuf: %d\n",

                         firstChrSrcY,    lastChrSrcY,    lastInChrBuf);



        //Do horizontal scaling

        while(lastInLumBuf < lastLumSrcY) {

            uint8_t *src1= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];

            uint8_t *src2= src[3]+(lastInLumBuf + 1 - srcSliceY)*srcStride[3];

            lumBufIndex++;

            DEBUG_BUFFERS("\t\tlumBufIndex %d: lastInLumBuf: %d\n",

                               lumBufIndex,    lastInLumBuf);

            assert(lumBufIndex < 2*vLumBufSize);

            assert(lastInLumBuf + 1 - srcSliceY < srcSliceH);

            assert(lastInLumBuf + 1 - srcSliceY >= 0);

            RENAME(hyscale)(c, lumPixBuf[ lumBufIndex ], dstW, src1, srcW, lumXInc,

                            flags, hLumFilter, hLumFilterPos, hLumFilterSize,

                            c->srcFormat, formatConvBuffer,

                            pal, 0);

            if (CONFIG_SWSCALE_ALPHA && alpPixBuf)

                RENAME(hyscale)(c, alpPixBuf[ lumBufIndex ], dstW, src2, srcW, lumXInc,

                                flags, hLumFilter, hLumFilterPos, hLumFilterSize,

                                c->srcFormat, formatConvBuffer,

                                pal, 1);

            lastInLumBuf++;

        }

        while(lastInChrBuf < lastChrSrcY) {

            uint8_t *src1= src[1]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[1];

            uint8_t *src2= src[2]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[2];

            chrBufIndex++;

            DEBUG_BUFFERS("\t\tchrBufIndex %d: lastInChrBuf: %d\n",

                               chrBufIndex,    lastInChrBuf);

            assert(chrBufIndex < 2*vChrBufSize);

            assert(lastInChrBuf + 1 - chrSrcSliceY < (chrSrcSliceH));

            assert(lastInChrBuf + 1 - chrSrcSliceY >= 0);

            //FIXME replace parameters through context struct (some at least)



            if (!(isGray(srcFormat) || isGray(dstFormat)))

                RENAME(hcscale)(c, chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, chrSrcW, chrXInc,

                                flags, hChrFilter, hChrFilterPos, hChrFilterSize,

                                c->srcFormat, formatConvBuffer,

                                pal);

            lastInChrBuf++;

        }

        //wrap buf index around to stay inside the ring buffer

        if (lumBufIndex >= vLumBufSize) lumBufIndex-= vLumBufSize;

        if (chrBufIndex >= vChrBufSize) chrBufIndex-= vChrBufSize;

        if (!enough_lines)

            break; //we can't output a dstY line so let's try with the next slice



#if COMPILE_TEMPLATE_MMX

        c->blueDither= ff_dither8[dstY&1];

        if (c->dstFormat == PIX_FMT_RGB555 || c->dstFormat == PIX_FMT_BGR555)

            c->greenDither= ff_dither8[dstY&1];

        else

            c->greenDither= ff_dither4[dstY&1];

        c->redDither= ff_dither8[(dstY+1)&1];

#endif

        if (dstY < dstH-2) {

            const int16_t **lumSrcPtr= (const int16_t **) lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;

            const int16_t **chrSrcPtr= (const int16_t **) chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;

            const int16_t **alpSrcPtr= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **) alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;

#if COMPILE_TEMPLATE_MMX

            int i;

            if (flags & SWS_ACCURATE_RND) {

                int s= APCK_SIZE / 8;

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

                    *(void**)&lumMmxFilter[s*i              ]= lumSrcPtr[i  ];

                    *(void**)&lumMmxFilter[s*i+APCK_PTR2/4  ]= lumSrcPtr[i+(vLumFilterSize>1)];

                              lumMmxFilter[s*i+APCK_COEF/4  ]=

                              lumMmxFilter[s*i+APCK_COEF/4+1]= vLumFilter[dstY*vLumFilterSize + i    ]

                        + (vLumFilterSize>1 ? vLumFilter[dstY*vLumFilterSize + i + 1]<<16 : 0);

                    if (CONFIG_SWSCALE_ALPHA && alpPixBuf) {

                        *(void**)&alpMmxFilter[s*i              ]= alpSrcPtr[i  ];

                        *(void**)&alpMmxFilter[s*i+APCK_PTR2/4  ]= alpSrcPtr[i+(vLumFilterSize>1)];

                                  alpMmxFilter[s*i+APCK_COEF/4  ]=

                                  alpMmxFilter[s*i+APCK_COEF/4+1]= lumMmxFilter[s*i+APCK_COEF/4  ];

                    }

                }

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

                    *(void**)&chrMmxFilter[s*i              ]= chrSrcPtr[i  ];

                    *(void**)&chrMmxFilter[s*i+APCK_PTR2/4  ]= chrSrcPtr[i+(vChrFilterSize>1)];

                              chrMmxFilter[s*i+APCK_COEF/4  ]=

                              chrMmxFilter[s*i+APCK_COEF/4+1]= vChrFilter[chrDstY*vChrFilterSize + i    ]

                        + (vChrFilterSize>1 ? vChrFilter[chrDstY*vChrFilterSize + i + 1]<<16 : 0);

                }

            } else {

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

                    lumMmxFilter[4*i+0]= (int32_t)lumSrcPtr[i];

                    lumMmxFilter[4*i+1]= (uint64_t)lumSrcPtr[i] >> 32;

                    lumMmxFilter[4*i+2]=

                    lumMmxFilter[4*i+3]=

                        ((uint16_t)vLumFilter[dstY*vLumFilterSize + i])*0x10001;

                    if (CONFIG_SWSCALE_ALPHA && alpPixBuf) {

                        alpMmxFilter[4*i+0]= (int32_t)alpSrcPtr[i];

                        alpMmxFilter[4*i+1]= (uint64_t)alpSrcPtr[i] >> 32;

                        alpMmxFilter[4*i+2]=

                        alpMmxFilter[4*i+3]= lumMmxFilter[4*i+2];

                    }

                }

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

                    chrMmxFilter[4*i+0]= (int32_t)chrSrcPtr[i];

                    chrMmxFilter[4*i+1]= (uint64_t)chrSrcPtr[i] >> 32;

                    chrMmxFilter[4*i+2]=

                    chrMmxFilter[4*i+3]=

                        ((uint16_t)vChrFilter[chrDstY*vChrFilterSize + i])*0x10001;

                }

            }

#endif

            if (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21) {

                const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

                if (dstY&chrSkipMask) uDest= NULL; //FIXME split functions in lumi / chromi

                c->yuv2nv12X(c,

                             vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                             vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                             dest, uDest, dstW, chrDstW, dstFormat);

            } else if (isPlanarYUV(dstFormat) || dstFormat==PIX_FMT_GRAY8) { //YV12 like

                const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

                if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi

                if (is16BPS(dstFormat)) {

                    yuv2yuvX16inC(

                                  vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                                  vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                  alpSrcPtr, (uint16_t *) dest, (uint16_t *) uDest, (uint16_t *) vDest, (uint16_t *) aDest, dstW, chrDstW,

                                  dstFormat);

                } else if (vLumFilterSize == 1 && vChrFilterSize == 1) { // unscaled YV12

                    int16_t *lumBuf = lumSrcPtr[0];

                    int16_t *chrBuf= chrSrcPtr[0];

                    int16_t *alpBuf= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? alpSrcPtr[0] : NULL;

                    c->yuv2yuv1(c, lumBuf, chrBuf, alpBuf, dest, uDest, vDest, aDest, dstW, chrDstW);

                } else { //General YV12

                    c->yuv2yuvX(c,

                                vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                                vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                alpSrcPtr, dest, uDest, vDest, aDest, dstW, chrDstW);

                }

            } else {

                assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);

                assert(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);

                if (vLumFilterSize == 1 && vChrFilterSize == 2) { //unscaled RGB

                    int chrAlpha= vChrFilter[2*dstY+1];

                    if(flags & SWS_FULL_CHR_H_INT) {

                        yuv2rgbXinC_full(c, //FIXME write a packed1_full function

                                         vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                         vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                         alpSrcPtr, dest, dstW, dstY);

                    } else {

                        c->yuv2packed1(c, *lumSrcPtr, *chrSrcPtr, *(chrSrcPtr+1),

                                       alpPixBuf ? *alpSrcPtr : NULL,

                                       dest, dstW, chrAlpha, dstFormat, flags, dstY);

                    }

                } else if (vLumFilterSize == 2 && vChrFilterSize == 2) { //bilinear upscale RGB

                    int lumAlpha= vLumFilter[2*dstY+1];

                    int chrAlpha= vChrFilter[2*dstY+1];

                    lumMmxFilter[2]=

                    lumMmxFilter[3]= vLumFilter[2*dstY   ]*0x10001;

                    chrMmxFilter[2]=

                    chrMmxFilter[3]= vChrFilter[2*chrDstY]*0x10001;

                    if(flags & SWS_FULL_CHR_H_INT) {

                        yuv2rgbXinC_full(c, //FIXME write a packed2_full function

                                         vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                         vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                         alpSrcPtr, dest, dstW, dstY);

                    } else {

                        c->yuv2packed2(c, *lumSrcPtr, *(lumSrcPtr+1), *chrSrcPtr, *(chrSrcPtr+1),

                                       alpPixBuf ? *alpSrcPtr : NULL, alpPixBuf ? *(alpSrcPtr+1) : NULL,

                                       dest, dstW, lumAlpha, chrAlpha, dstY);

                    }

                } else { //general RGB

                    if(flags & SWS_FULL_CHR_H_INT) {

                        yuv2rgbXinC_full(c,

                                         vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                         vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                         alpSrcPtr, dest, dstW, dstY);

                    } else {

                        c->yuv2packedX(c,

                                       vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                       vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                       alpSrcPtr, dest, dstW, dstY);

                    }

                }

            }

        } else { // hmm looks like we can't use MMX here without overwriting this array's tail

            const int16_t **lumSrcPtr= (const int16_t **)lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;

            const int16_t **chrSrcPtr= (const int16_t **)chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;

            const int16_t **alpSrcPtr= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **)alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;

            if (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21) {

                const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

                if (dstY&chrSkipMask) uDest= NULL; //FIXME split functions in lumi / chromi

                yuv2nv12XinC(

                             vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                             vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                             dest, uDest, dstW, chrDstW, dstFormat);

            } else if (isPlanarYUV(dstFormat) || dstFormat==PIX_FMT_GRAY8) { //YV12

                const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

                if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi

                if (is16BPS(dstFormat)) {

                    yuv2yuvX16inC(

                                  vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                                  vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                  alpSrcPtr, (uint16_t *) dest, (uint16_t *) uDest, (uint16_t *) vDest, (uint16_t *) aDest, dstW, chrDstW,

                                  dstFormat);

                } else {

                    yuv2yuvXinC(

                                vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                                vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                alpSrcPtr, dest, uDest, vDest, aDest, dstW, chrDstW);

                }

            } else {

                assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);

                assert(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);

                if(flags & SWS_FULL_CHR_H_INT) {

                    yuv2rgbXinC_full(c,

                                     vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                     vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                     alpSrcPtr, dest, dstW, dstY);

                } else {

                    yuv2packedXinC(c,

                                   vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                   vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                   alpSrcPtr, dest, dstW, dstY);

                }

            }

        }

    }



    if ((dstFormat == PIX_FMT_YUVA420P) && !alpPixBuf)

        fillPlane(dst[3], dstStride[3], dstW, dstY-lastDstY, lastDstY, 255);



#if COMPILE_TEMPLATE_MMX

    if (flags & SWS_CPU_CAPS_MMX2 )  __asm__ volatile("sfence":::"memory");

    /* On K6 femms is faster than emms. On K7 femms is directly mapped to emms. */

    if (flags & SWS_CPU_CAPS_3DNOW)  __asm__ volatile("femms" :::"memory");

    else                             __asm__ volatile("emms"  :::"memory");

#endif

    /* store changed local vars back in the context */

    c->dstY= dstY;

    c->lumBufIndex= lumBufIndex;

    c->chrBufIndex= chrBufIndex;

    c->lastInLumBuf= lastInLumBuf;

    c->lastInChrBuf= lastInChrBuf;



    return dstY - lastDstY;

}

static int RENAME(swScale)(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,

                           int srcSliceH, uint8_t* dst[], int dstStride[])

{

    

    const int srcW= c->srcW;

    const int dstW= c->dstW;

    const int dstH= c->dstH;

    const int chrDstW= c->chrDstW;

    const int chrSrcW= c->chrSrcW;

    const int lumXInc= c->lumXInc;

    const int chrXInc= c->chrXInc;

    const enum PixelFormat dstFormat= c->dstFormat;

    const enum PixelFormat srcFormat= c->srcFormat;

    const int flags= c->flags;

    int16_t *vLumFilterPos= c->vLumFilterPos;

    int16_t *vChrFilterPos= c->vChrFilterPos;

    int16_t *hLumFilterPos= c->hLumFilterPos;

    int16_t *hChrFilterPos= c->hChrFilterPos;

    int16_t *vLumFilter= c->vLumFilter;

    int16_t *vChrFilter= c->vChrFilter;

    int16_t *hLumFilter= c->hLumFilter;

    int16_t *hChrFilter= c->hChrFilter;

    int32_t *lumMmxFilter= c->lumMmxFilter;

    int32_t *chrMmxFilter= c->chrMmxFilter;

    int32_t *alpMmxFilter= c->alpMmxFilter;

    const int vLumFilterSize= c->vLumFilterSize;

    const int vChrFilterSize= c->vChrFilterSize;

    const int hLumFilterSize= c->hLumFilterSize;

    const int hChrFilterSize= c->hChrFilterSize;

    int16_t **lumPixBuf= c->lumPixBuf;

    int16_t **chrPixBuf= c->chrPixBuf;

    int16_t **alpPixBuf= c->alpPixBuf;

    const int vLumBufSize= c->vLumBufSize;

    const int vChrBufSize= c->vChrBufSize;

    uint8_t *formatConvBuffer= c->formatConvBuffer;

    const int chrSrcSliceY= srcSliceY >> c->chrSrcVSubSample;

    const int chrSrcSliceH= -((-srcSliceH) >> c->chrSrcVSubSample);

    int lastDstY;

    uint32_t *pal=c->pal_yuv;



    

    int dstY= c->dstY;

    int lumBufIndex= c->lumBufIndex;

    int chrBufIndex= c->chrBufIndex;

    int lastInLumBuf= c->lastInLumBuf;

    int lastInChrBuf= c->lastInChrBuf;



    if (isPacked(c->srcFormat)) {

        src[0]=

        src[1]=

        src[2]=

        src[3]= src[0];

        srcStride[0]=

        srcStride[1]=

        srcStride[2]=

        srcStride[3]= srcStride[0];

    }

    srcStride[1]<<= c->vChrDrop;

    srcStride[2]<<= c->vChrDrop;



    DEBUG_BUFFERS("swScale() %p[%d] %p[%d] %p[%d] %p[%d] -> %p[%d] %p[%d] %p[%d] %p[%d]\n",

                  src[0], srcStride[0], src[1], srcStride[1], src[2], srcStride[2], src[3], srcStride[3],

                  dst[0], dstStride[0], dst[1], dstStride[1], dst[2], dstStride[2], dst[3], dstStride[3]);

    DEBUG_BUFFERS("srcSliceY: %d srcSliceH: %d dstY: %d dstH: %d\n",

                   srcSliceY,    srcSliceH,    dstY,    dstH);

    DEBUG_BUFFERS("vLumFilterSize: %d vLumBufSize: %d vChrFilterSize: %d vChrBufSize: %d\n",

                   vLumFilterSize,    vLumBufSize,    vChrFilterSize,    vChrBufSize);



    if (dstStride[0]%8 !=0 || dstStride[1]%8 !=0 || dstStride[2]%8 !=0 || dstStride[3]%8 != 0) {

        static int warnedAlready=0; 

        if (flags & SWS_PRINT_INFO && !warnedAlready) {

            av_log(c, AV_LOG_WARNING, "Warning: dstStride is not aligned!\n"

                   "         ->cannot do aligned memory accesses anymore\n");

            warnedAlready=1;

        }

    }



    





    if (srcSliceY ==0) {

        lumBufIndex=0;

        chrBufIndex=0;

        dstY=0;

        lastInLumBuf= -1;

        lastInChrBuf= -1;

    }



    lastDstY= dstY;



    for (;dstY < dstH; dstY++) {

        unsigned char *dest =dst[0]+dstStride[0]*dstY;

        const int chrDstY= dstY>>c->chrDstVSubSample;

        unsigned char *uDest=dst[1]+dstStride[1]*chrDstY;

        unsigned char *vDest=dst[2]+dstStride[2]*chrDstY;

        unsigned char *aDest=(CONFIG_SWSCALE_ALPHA && alpPixBuf) ? dst[3]+dstStride[3]*dstY : NULL;



        const int firstLumSrcY= vLumFilterPos[dstY]; 

        const int firstChrSrcY= vChrFilterPos[chrDstY]; 

        int lastLumSrcY= firstLumSrcY + vLumFilterSize -1; 

        int lastChrSrcY= firstChrSrcY + vChrFilterSize -1; 

        int enough_lines;



        

        if (firstLumSrcY > lastInLumBuf) lastInLumBuf= firstLumSrcY-1;

        if (firstChrSrcY > lastInChrBuf) lastInChrBuf= firstChrSrcY-1;

        assert(firstLumSrcY >= lastInLumBuf - vLumBufSize + 1);

        assert(firstChrSrcY >= lastInChrBuf - vChrBufSize + 1);



        

        enough_lines = lastLumSrcY < srcSliceY + srcSliceH && lastChrSrcY < -((-srcSliceY - srcSliceH)>>c->chrSrcVSubSample);

        if (!enough_lines) {

            lastLumSrcY = srcSliceY + srcSliceH - 1;

            lastChrSrcY = chrSrcSliceY + chrSrcSliceH - 1;

        }



        DEBUG_BUFFERS("dstY: %d\n", dstY);

        DEBUG_BUFFERS("\tfirstLumSrcY: %d lastLumSrcY: %d lastInLumBuf: %d\n",

                         firstLumSrcY,    lastLumSrcY,    lastInLumBuf);

        DEBUG_BUFFERS("\tfirstChrSrcY: %d lastChrSrcY: %d lastInChrBuf: %d\n",

                         firstChrSrcY,    lastChrSrcY,    lastInChrBuf);



        

        while(lastInLumBuf < lastLumSrcY) {

            uint8_t *src1= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];

            uint8_t *src2= src[3]+(lastInLumBuf + 1 - srcSliceY)*srcStride[3];

            lumBufIndex++;

            DEBUG_BUFFERS("\t\tlumBufIndex %d: lastInLumBuf: %d\n",

                               lumBufIndex,    lastInLumBuf);

            assert(lumBufIndex < 2*vLumBufSize);

            assert(lastInLumBuf + 1 - srcSliceY < srcSliceH);

            assert(lastInLumBuf + 1 - srcSliceY >= 0);

            RENAME(hyscale)(c, lumPixBuf[ lumBufIndex ], dstW, src1, srcW, lumXInc,

                            flags, hLumFilter, hLumFilterPos, hLumFilterSize,

                            c->srcFormat, formatConvBuffer,

                            pal, 0);

            if (CONFIG_SWSCALE_ALPHA && alpPixBuf)

                RENAME(hyscale)(c, alpPixBuf[ lumBufIndex ], dstW, src2, srcW, lumXInc,

                                flags, hLumFilter, hLumFilterPos, hLumFilterSize,

                                c->srcFormat, formatConvBuffer,

                                pal, 1);

            lastInLumBuf++;

        }

        while(lastInChrBuf < lastChrSrcY) {

            uint8_t *src1= src[1]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[1];

            uint8_t *src2= src[2]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[2];

            chrBufIndex++;

            DEBUG_BUFFERS("\t\tchrBufIndex %d: lastInChrBuf: %d\n",

                               chrBufIndex,    lastInChrBuf);

            assert(chrBufIndex < 2*vChrBufSize);

            assert(lastInChrBuf + 1 - chrSrcSliceY < (chrSrcSliceH));

            assert(lastInChrBuf + 1 - chrSrcSliceY >= 0);

            



            if (!(isGray(srcFormat) || isGray(dstFormat)))

                RENAME(hcscale)(c, chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, chrSrcW, chrXInc,

                                flags, hChrFilter, hChrFilterPos, hChrFilterSize,

                                c->srcFormat, formatConvBuffer,

                                pal);

            lastInChrBuf++;

        }

        

        if (lumBufIndex >= vLumBufSize) lumBufIndex-= vLumBufSize;

        if (chrBufIndex >= vChrBufSize) chrBufIndex-= vChrBufSize;

        if (!enough_lines)

            break; 



#if COMPILE_TEMPLATE_MMX

        c->blueDither= ff_dither8[dstY&1];

        if (c->dstFormat == PIX_FMT_RGB555 || c->dstFormat == PIX_FMT_BGR555)

            c->greenDither= ff_dither8[dstY&1];

        else

            c->greenDither= ff_dither4[dstY&1];

        c->redDither= ff_dither8[(dstY+1)&1];

#endif

        if (dstY < dstH-2) {

            const int16_t **lumSrcPtr= (const int16_t **) lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;

            const int16_t **chrSrcPtr= (const int16_t **) chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;

            const int16_t **alpSrcPtr= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **) alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;

#if COMPILE_TEMPLATE_MMX

            int i;

            if (flags & SWS_ACCURATE_RND) {

                int s= APCK_SIZE / 8;

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

                    *(void**)&lumMmxFilter[s*i              ]= lumSrcPtr[i  ];

                    *(void**)&lumMmxFilter[s*i+APCK_PTR2/4  ]= lumSrcPtr[i+(vLumFilterSize>1)];

                              lumMmxFilter[s*i+APCK_COEF/4  ]=

                              lumMmxFilter[s*i+APCK_COEF/4+1]= vLumFilter[dstY*vLumFilterSize + i    ]

                        + (vLumFilterSize>1 ? vLumFilter[dstY*vLumFilterSize + i + 1]<<16 : 0);

                    if (CONFIG_SWSCALE_ALPHA && alpPixBuf) {

                        *(void**)&alpMmxFilter[s*i              ]= alpSrcPtr[i  ];

                        *(void**)&alpMmxFilter[s*i+APCK_PTR2/4  ]= alpSrcPtr[i+(vLumFilterSize>1)];

                                  alpMmxFilter[s*i+APCK_COEF/4  ]=

                                  alpMmxFilter[s*i+APCK_COEF/4+1]= lumMmxFilter[s*i+APCK_COEF/4  ];

                    }

                }

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

                    *(void**)&chrMmxFilter[s*i              ]= chrSrcPtr[i  ];

                    *(void**)&chrMmxFilter[s*i+APCK_PTR2/4  ]= chrSrcPtr[i+(vChrFilterSize>1)];

                              chrMmxFilter[s*i+APCK_COEF/4  ]=

                              chrMmxFilter[s*i+APCK_COEF/4+1]= vChrFilter[chrDstY*vChrFilterSize + i    ]

                        + (vChrFilterSize>1 ? vChrFilter[chrDstY*vChrFilterSize + i + 1]<<16 : 0);

                }

            } else {

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

                    lumMmxFilter[4*i+0]= (int32_t)lumSrcPtr[i];

                    lumMmxFilter[4*i+1]= (uint64_t)lumSrcPtr[i] >> 32;

                    lumMmxFilter[4*i+2]=

                    lumMmxFilter[4*i+3]=

                        ((uint16_t)vLumFilter[dstY*vLumFilterSize + i])*0x10001;

                    if (CONFIG_SWSCALE_ALPHA && alpPixBuf) {

                        alpMmxFilter[4*i+0]= (int32_t)alpSrcPtr[i];

                        alpMmxFilter[4*i+1]= (uint64_t)alpSrcPtr[i] >> 32;

                        alpMmxFilter[4*i+2]=

                        alpMmxFilter[4*i+3]= lumMmxFilter[4*i+2];

                    }

                }

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

                    chrMmxFilter[4*i+0]= (int32_t)chrSrcPtr[i];

                    chrMmxFilter[4*i+1]= (uint64_t)chrSrcPtr[i] >> 32;

                    chrMmxFilter[4*i+2]=

                    chrMmxFilter[4*i+3]=

                        ((uint16_t)vChrFilter[chrDstY*vChrFilterSize + i])*0x10001;

                }

            }

#endif

            if (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21) {

                const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

                if (dstY&chrSkipMask) uDest= NULL; 

                c->yuv2nv12X(c,

                             vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                             vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                             dest, uDest, dstW, chrDstW, dstFormat);

            } else if (isPlanarYUV(dstFormat) || dstFormat==PIX_FMT_GRAY8) { 

                const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

                if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; 

                if (is16BPS(dstFormat)) {

                    yuv2yuvX16inC(

                                  vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                                  vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                  alpSrcPtr, (uint16_t *) dest, (uint16_t *) uDest, (uint16_t *) vDest, (uint16_t *) aDest, dstW, chrDstW,

                                  dstFormat);

                } else if (vLumFilterSize == 1 && vChrFilterSize == 1) { 

                    int16_t *lumBuf = lumSrcPtr[0];

                    int16_t *chrBuf= chrSrcPtr[0];

                    int16_t *alpBuf= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? alpSrcPtr[0] : NULL;

                    c->yuv2yuv1(c, lumBuf, chrBuf, alpBuf, dest, uDest, vDest, aDest, dstW, chrDstW);

                } else { 

                    c->yuv2yuvX(c,

                                vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                                vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                alpSrcPtr, dest, uDest, vDest, aDest, dstW, chrDstW);

                }

            } else {

                assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);

                assert(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);

                if (vLumFilterSize == 1 && vChrFilterSize == 2) { 

                    int chrAlpha= vChrFilter[2*dstY+1];

                    if(flags & SWS_FULL_CHR_H_INT) {

                        yuv2rgbXinC_full(c, 

                                         vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                         vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                         alpSrcPtr, dest, dstW, dstY);

                    } else {

                        c->yuv2packed1(c, *lumSrcPtr, *chrSrcPtr, *(chrSrcPtr+1),

                                       alpPixBuf ? *alpSrcPtr : NULL,

                                       dest, dstW, chrAlpha, dstFormat, flags, dstY);

                    }

                } else if (vLumFilterSize == 2 && vChrFilterSize == 2) { 

                    int lumAlpha= vLumFilter[2*dstY+1];

                    int chrAlpha= vChrFilter[2*dstY+1];

                    lumMmxFilter[2]=

                    lumMmxFilter[3]= vLumFilter[2*dstY   ]*0x10001;

                    chrMmxFilter[2]=

                    chrMmxFilter[3]= vChrFilter[2*chrDstY]*0x10001;

                    if(flags & SWS_FULL_CHR_H_INT) {

                        yuv2rgbXinC_full(c, 

                                         vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                         vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                         alpSrcPtr, dest, dstW, dstY);

                    } else {

                        c->yuv2packed2(c, *lumSrcPtr, *(lumSrcPtr+1), *chrSrcPtr, *(chrSrcPtr+1),

                                       alpPixBuf ? *alpSrcPtr : NULL, alpPixBuf ? *(alpSrcPtr+1) : NULL,

                                       dest, dstW, lumAlpha, chrAlpha, dstY);

                    }

                } else { 

                    if(flags & SWS_FULL_CHR_H_INT) {

                        yuv2rgbXinC_full(c,

                                         vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                         vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                         alpSrcPtr, dest, dstW, dstY);

                    } else {

                        c->yuv2packedX(c,

                                       vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                       vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                       alpSrcPtr, dest, dstW, dstY);

                    }

                }

            }

        } else { 

            const int16_t **lumSrcPtr= (const int16_t **)lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;

            const int16_t **chrSrcPtr= (const int16_t **)chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;

            const int16_t **alpSrcPtr= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **)alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;

            if (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21) {

                const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

                if (dstY&chrSkipMask) uDest= NULL; 

                yuv2nv12XinC(

                             vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                             vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                             dest, uDest, dstW, chrDstW, dstFormat);

            } else if (isPlanarYUV(dstFormat) || dstFormat==PIX_FMT_GRAY8) { 

                const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

                if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; 

                if (is16BPS(dstFormat)) {

                    yuv2yuvX16inC(

                                  vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                                  vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                  alpSrcPtr, (uint16_t *) dest, (uint16_t *) uDest, (uint16_t *) vDest, (uint16_t *) aDest, dstW, chrDstW,

                                  dstFormat);

                } else {

                    yuv2yuvXinC(

                                vLumFilter+dstY*vLumFilterSize   , lumSrcPtr, vLumFilterSize,

                                vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                alpSrcPtr, dest, uDest, vDest, aDest, dstW, chrDstW);

                }

            } else {

                assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);

                assert(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);

                if(flags & SWS_FULL_CHR_H_INT) {

                    yuv2rgbXinC_full(c,

                                     vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                     vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                     alpSrcPtr, dest, dstW, dstY);

                } else {

                    yuv2packedXinC(c,

                                   vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

                                   vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

                                   alpSrcPtr, dest, dstW, dstY);

                }

            }

        }

    }



    if ((dstFormat == PIX_FMT_YUVA420P) && !alpPixBuf)

        fillPlane(dst[3], dstStride[3], dstW, dstY-lastDstY, lastDstY, 255);



#if COMPILE_TEMPLATE_MMX

    if (flags & SWS_CPU_CAPS_MMX2 )  __asm__ volatile("sfence":::"memory");

    

    if (flags & SWS_CPU_CAPS_3DNOW)  __asm__ volatile("femms" :::"memory");

    else                             __asm__ volatile("emms"  :::"memory");

#endif

    

    c->dstY= dstY;

    c->lumBufIndex= lumBufIndex;

    c->chrBufIndex= chrBufIndex;

    c->lastInLumBuf= lastInLumBuf;

    c->lastInChrBuf= lastInChrBuf;



    return dstY - lastDstY;

}

static int FUNC_0(swScale)(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,

                           int srcSliceH, uint8_t* dst[], int dstStride[])

{

    

    const int VAR_0= c->VAR_0;

    const int VAR_1= c->VAR_1;

    const int VAR_2= c->VAR_2;

    const int VAR_3= c->VAR_3;

    const int VAR_4= c->VAR_4;

    const int VAR_5= c->VAR_5;

    const int VAR_6= c->VAR_6;

    const enum PixelFormat VAR_7= c->VAR_7;

    const enum PixelFormat VAR_8= c->VAR_8;

    const int VAR_9= c->VAR_9;

    int16_t *vLumFilterPos= c->vLumFilterPos;

    int16_t *vChrFilterPos= c->vChrFilterPos;

    int16_t *hLumFilterPos= c->hLumFilterPos;

    int16_t *hChrFilterPos= c->hChrFilterPos;

    int16_t *vLumFilter= c->vLumFilter;

    int16_t *vChrFilter= c->vChrFilter;

    int16_t *hLumFilter= c->hLumFilter;

    int16_t *hChrFilter= c->hChrFilter;

    int32_t *lumMmxFilter= c->lumMmxFilter;

    int32_t *chrMmxFilter= c->chrMmxFilter;

    int32_t *alpMmxFilter= c->alpMmxFilter;

    const int VAR_10= c->VAR_10;

    const int VAR_11= c->VAR_11;

    const int VAR_12= c->VAR_12;

    const int VAR_13= c->VAR_13;

    int16_t **lumPixBuf= c->lumPixBuf;

    int16_t **chrPixBuf= c->chrPixBuf;

    int16_t **alpPixBuf= c->alpPixBuf;

    const int VAR_14= c->VAR_14;

    const int VAR_15= c->VAR_15;

    uint8_t *formatConvBuffer= c->formatConvBuffer;

    const int VAR_16= srcSliceY >> c->chrSrcVSubSample;

    const int VAR_17= -((-srcSliceH) >> c->chrSrcVSubSample);

    int VAR_18;

    uint32_t *pal=c->pal_yuv;



    

    int VAR_19= c->VAR_19;

    int VAR_20= c->VAR_20;

    int VAR_21= c->VAR_21;

    int VAR_22= c->VAR_22;

    int VAR_23= c->VAR_23;



    if (isPacked(c->VAR_8)) {

        src[0]=

        src[1]=

        src[2]=

        src[3]= src[0];

        srcStride[0]=

        srcStride[1]=

        srcStride[2]=

        srcStride[3]= srcStride[0];

    }

    srcStride[1]<<= c->vChrDrop;

    srcStride[2]<<= c->vChrDrop;



    DEBUG_BUFFERS("swScale() %p[%d] %p[%d] %p[%d] %p[%d] -> %p[%d] %p[%d] %p[%d] %p[%d]\n",

                  src[0], srcStride[0], src[1], srcStride[1], src[2], srcStride[2], src[3], srcStride[3],

                  dst[0], dstStride[0], dst[1], dstStride[1], dst[2], dstStride[2], dst[3], dstStride[3]);

    DEBUG_BUFFERS("srcSliceY: %d srcSliceH: %d VAR_19: %d VAR_2: %d\n",

                   srcSliceY,    srcSliceH,    VAR_19,    VAR_2);

    DEBUG_BUFFERS("VAR_10: %d VAR_14: %d VAR_11: %d VAR_15: %d\n",

                   VAR_10,    VAR_14,    VAR_11,    VAR_15);



    if (dstStride[0]%8 !=0 || dstStride[1]%8 !=0 || dstStride[2]%8 !=0 || dstStride[3]%8 != 0) {

        static int VAR_24=0; 

        if (VAR_9 & SWS_PRINT_INFO && !VAR_24) {

            av_log(c, AV_LOG_WARNING, "Warning: dstStride is not aligned!\n"

                   "         ->cannot do aligned memory accesses anymore\n");

            VAR_24=1;

        }

    }



    





    if (srcSliceY ==0) {

        VAR_20=0;

        VAR_21=0;

        VAR_19=0;

        VAR_22= -1;

        VAR_23= -1;

    }



    VAR_18= VAR_19;



    for (;VAR_19 < VAR_2; VAR_19++) {

        unsigned char *VAR_25 =dst[0]+dstStride[0]*VAR_19;

        const int VAR_26= VAR_19>>c->chrDstVSubSample;

        unsigned char *VAR_27=dst[1]+dstStride[1]*VAR_26;

        unsigned char *VAR_28=dst[2]+dstStride[2]*VAR_26;

        unsigned char *VAR_29=(CONFIG_SWSCALE_ALPHA && alpPixBuf) ? dst[3]+dstStride[3]*VAR_19 : NULL;



        const int VAR_30= vLumFilterPos[VAR_19]; 

        const int VAR_31= vChrFilterPos[VAR_26]; 

        int VAR_32= VAR_30 + VAR_10 -1; 

        int VAR_33= VAR_31 + VAR_11 -1; 

        int VAR_34;



        

        if (VAR_30 > VAR_22) VAR_22= VAR_30-1;

        if (VAR_31 > VAR_23) VAR_23= VAR_31-1;

        assert(VAR_30 >= VAR_22 - VAR_14 + 1);

        assert(VAR_31 >= VAR_23 - VAR_15 + 1);



        

        VAR_34 = VAR_32 < srcSliceY + srcSliceH && VAR_33 < -((-srcSliceY - srcSliceH)>>c->chrSrcVSubSample);

        if (!VAR_34) {

            VAR_32 = srcSliceY + srcSliceH - 1;

            VAR_33 = VAR_16 + VAR_17 - 1;

        }



        DEBUG_BUFFERS("VAR_19: %d\n", VAR_19);

        DEBUG_BUFFERS("\tfirstLumSrcY: %d VAR_32: %d VAR_22: %d\n",

                         VAR_30,    VAR_32,    VAR_22);

        DEBUG_BUFFERS("\tfirstChrSrcY: %d VAR_33: %d VAR_23: %d\n",

                         VAR_31,    VAR_33,    VAR_23);



        

        while(VAR_22 < VAR_32) {

            uint8_t *src1= src[0]+(VAR_22 + 1 - srcSliceY)*srcStride[0];

            uint8_t *src2= src[3]+(VAR_22 + 1 - srcSliceY)*srcStride[3];

            VAR_20++;

            DEBUG_BUFFERS("\t\tlumBufIndex %d: VAR_22: %d\n",

                               VAR_20,    VAR_22);

            assert(VAR_20 < 2*VAR_14);

            assert(VAR_22 + 1 - srcSliceY < srcSliceH);

            assert(VAR_22 + 1 - srcSliceY >= 0);

            FUNC_0(hyscale)(c, lumPixBuf[ VAR_20 ], VAR_1, src1, VAR_0, VAR_5,

                            VAR_9, hLumFilter, hLumFilterPos, VAR_12,

                            c->VAR_8, formatConvBuffer,

                            pal, 0);

            if (CONFIG_SWSCALE_ALPHA && alpPixBuf)

                FUNC_0(hyscale)(c, alpPixBuf[ VAR_20 ], VAR_1, src2, VAR_0, VAR_5,

                                VAR_9, hLumFilter, hLumFilterPos, VAR_12,

                                c->VAR_8, formatConvBuffer,

                                pal, 1);

            VAR_22++;

        }

        while(VAR_23 < VAR_33) {

            uint8_t *src1= src[1]+(VAR_23 + 1 - VAR_16)*srcStride[1];

            uint8_t *src2= src[2]+(VAR_23 + 1 - VAR_16)*srcStride[2];

            VAR_21++;

            DEBUG_BUFFERS("\t\tchrBufIndex %d: VAR_23: %d\n",

                               VAR_21,    VAR_23);

            assert(VAR_21 < 2*VAR_15);

            assert(VAR_23 + 1 - VAR_16 < (VAR_17));

            assert(VAR_23 + 1 - VAR_16 >= 0);

            



            if (!(isGray(VAR_8) || isGray(VAR_7)))

                FUNC_0(hcscale)(c, chrPixBuf[ VAR_21 ], VAR_3, src1, src2, VAR_4, VAR_6,

                                VAR_9, hChrFilter, hChrFilterPos, VAR_13,

                                c->VAR_8, formatConvBuffer,

                                pal);

            VAR_23++;

        }

        

        if (VAR_20 >= VAR_14) VAR_20-= VAR_14;

        if (VAR_21 >= VAR_15) VAR_21-= VAR_15;

        if (!VAR_34)

            break; 



#if COMPILE_TEMPLATE_MMX

        c->blueDither= ff_dither8[VAR_19&1];

        if (c->VAR_7 == PIX_FMT_RGB555 || c->VAR_7 == PIX_FMT_BGR555)

            c->greenDither= ff_dither8[VAR_19&1];

        else

            c->greenDither= ff_dither4[VAR_19&1];

        c->redDither= ff_dither8[(VAR_19+1)&1];

#endif

        if (VAR_19 < VAR_2-2) {

            const int16_t **VAR_41= (const int16_t **) lumPixBuf + VAR_20 + VAR_30 - VAR_22 + VAR_14;

            const int16_t **VAR_41= (const int16_t **) chrPixBuf + VAR_21 + VAR_31 - VAR_23 + VAR_15;

            const int16_t **VAR_41= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **) alpPixBuf + VAR_20 + VAR_30 - VAR_22 + VAR_14 : NULL;

#if COMPILE_TEMPLATE_MMX

            int i;

            if (VAR_9 & SWS_ACCURATE_RND) {

                int s= APCK_SIZE / 8;

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

                    *(void**)&lumMmxFilter[s*i              ]= VAR_41[i  ];

                    *(void**)&lumMmxFilter[s*i+APCK_PTR2/4  ]= VAR_41[i+(VAR_10>1)];

                              lumMmxFilter[s*i+APCK_COEF/4  ]=

                              lumMmxFilter[s*i+APCK_COEF/4+1]= vLumFilter[VAR_19*VAR_10 + i    ]

                        + (VAR_10>1 ? vLumFilter[VAR_19*VAR_10 + i + 1]<<16 : 0);

                    if (CONFIG_SWSCALE_ALPHA && alpPixBuf) {

                        *(void**)&alpMmxFilter[s*i              ]= VAR_41[i  ];

                        *(void**)&alpMmxFilter[s*i+APCK_PTR2/4  ]= VAR_41[i+(VAR_10>1)];

                                  alpMmxFilter[s*i+APCK_COEF/4  ]=

                                  alpMmxFilter[s*i+APCK_COEF/4+1]= lumMmxFilter[s*i+APCK_COEF/4  ];

                    }

                }

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

                    *(void**)&chrMmxFilter[s*i              ]= VAR_41[i  ];

                    *(void**)&chrMmxFilter[s*i+APCK_PTR2/4  ]= VAR_41[i+(VAR_11>1)];

                              chrMmxFilter[s*i+APCK_COEF/4  ]=

                              chrMmxFilter[s*i+APCK_COEF/4+1]= vChrFilter[VAR_26*VAR_11 + i    ]

                        + (VAR_11>1 ? vChrFilter[VAR_26*VAR_11 + i + 1]<<16 : 0);

                }

            } else {

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

                    lumMmxFilter[4*i+0]= (int32_t)VAR_41[i];

                    lumMmxFilter[4*i+1]= (uint64_t)VAR_41[i] >> 32;

                    lumMmxFilter[4*i+2]=

                    lumMmxFilter[4*i+3]=

                        ((uint16_t)vLumFilter[VAR_19*VAR_10 + i])*0x10001;

                    if (CONFIG_SWSCALE_ALPHA && alpPixBuf) {

                        alpMmxFilter[4*i+0]= (int32_t)VAR_41[i];

                        alpMmxFilter[4*i+1]= (uint64_t)VAR_41[i] >> 32;

                        alpMmxFilter[4*i+2]=

                        alpMmxFilter[4*i+3]= lumMmxFilter[4*i+2];

                    }

                }

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

                    chrMmxFilter[4*i+0]= (int32_t)VAR_41[i];

                    chrMmxFilter[4*i+1]= (uint64_t)VAR_41[i] >> 32;

                    chrMmxFilter[4*i+2]=

                    chrMmxFilter[4*i+3]=

                        ((uint16_t)vChrFilter[VAR_26*VAR_11 + i])*0x10001;

                }

            }

#endif

            if (VAR_7 == PIX_FMT_NV12 || VAR_7 == PIX_FMT_NV21) {

                const int VAR_41= (1<<c->chrDstVSubSample)-1;

                if (VAR_19&VAR_41) VAR_27= NULL; 

                c->yuv2nv12X(c,

                             vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,

                             vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,

                             VAR_25, VAR_27, VAR_1, VAR_3, VAR_7);

            } else if (isPlanarYUV(VAR_7) || VAR_7==PIX_FMT_GRAY8) { 

                const int VAR_41= (1<<c->chrDstVSubSample)-1;

                if ((VAR_19&VAR_41) || isGray(VAR_7)) VAR_27=VAR_28= NULL; 

                if (is16BPS(VAR_7)) {

                    yuv2yuvX16inC(

                                  vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,

                                  vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,

                                  VAR_41, (uint16_t *) VAR_25, (uint16_t *) VAR_27, (uint16_t *) VAR_28, (uint16_t *) VAR_29, VAR_1, VAR_3,

                                  VAR_7);

                } else if (VAR_10 == 1 && VAR_11 == 1) { 

                    int16_t *lumBuf = VAR_41[0];

                    int16_t *chrBuf= VAR_41[0];

                    int16_t *alpBuf= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? VAR_41[0] : NULL;

                    c->yuv2yuv1(c, lumBuf, chrBuf, alpBuf, VAR_25, VAR_27, VAR_28, VAR_29, VAR_1, VAR_3);

                } else { 

                    c->yuv2yuvX(c,

                                vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,

                                vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,

                                VAR_41, VAR_25, VAR_27, VAR_28, VAR_29, VAR_1, VAR_3);

                }

            } else {

                assert(VAR_41 + VAR_10 - 1 < lumPixBuf + VAR_14*2);

                assert(VAR_41 + VAR_11 - 1 < chrPixBuf + VAR_15*2);

                if (VAR_10 == 1 && VAR_11 == 2) { 

                    int VAR_41= vChrFilter[2*VAR_19+1];

                    if(VAR_9 & SWS_FULL_CHR_H_INT) {

                        yuv2rgbXinC_full(c, 

                                         vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,

                                         vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,

                                         VAR_41, VAR_25, VAR_1, VAR_19);

                    } else {

                        c->yuv2packed1(c, *VAR_41, *VAR_41, *(VAR_41+1),

                                       alpPixBuf ? *VAR_41 : NULL,

                                       VAR_25, VAR_1, VAR_41, VAR_7, VAR_9, VAR_19);

                    }

                } else if (VAR_10 == 2 && VAR_11 == 2) { 

                    int VAR_40= vLumFilter[2*VAR_19+1];

                    int VAR_41= vChrFilter[2*VAR_19+1];

                    lumMmxFilter[2]=

                    lumMmxFilter[3]= vLumFilter[2*VAR_19   ]*0x10001;

                    chrMmxFilter[2]=

                    chrMmxFilter[3]= vChrFilter[2*VAR_26]*0x10001;

                    if(VAR_9 & SWS_FULL_CHR_H_INT) {

                        yuv2rgbXinC_full(c, 

                                         vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,

                                         vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,

                                         VAR_41, VAR_25, VAR_1, VAR_19);

                    } else {

                        c->yuv2packed2(c, *VAR_41, *(VAR_41+1), *VAR_41, *(VAR_41+1),

                                       alpPixBuf ? *VAR_41 : NULL, alpPixBuf ? *(VAR_41+1) : NULL,

                                       VAR_25, VAR_1, VAR_40, VAR_41, VAR_19);

                    }

                } else { 

                    if(VAR_9 & SWS_FULL_CHR_H_INT) {

                        yuv2rgbXinC_full(c,

                                         vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,

                                         vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,

                                         VAR_41, VAR_25, VAR_1, VAR_19);

                    } else {

                        c->yuv2packedX(c,

                                       vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,

                                       vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,

                                       VAR_41, VAR_25, VAR_1, VAR_19);

                    }

                }

            }

        } else { 

            const int16_t **VAR_41= (const int16_t **)lumPixBuf + VAR_20 + VAR_30 - VAR_22 + VAR_14;

            const int16_t **VAR_41= (const int16_t **)chrPixBuf + VAR_21 + VAR_31 - VAR_23 + VAR_15;

            const int16_t **VAR_41= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **)alpPixBuf + VAR_20 + VAR_30 - VAR_22 + VAR_14 : NULL;

            if (VAR_7 == PIX_FMT_NV12 || VAR_7 == PIX_FMT_NV21) {

                const int VAR_41= (1<<c->chrDstVSubSample)-1;

                if (VAR_19&VAR_41) VAR_27= NULL; 

                yuv2nv12XinC(

                             vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,

                             vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,

                             VAR_25, VAR_27, VAR_1, VAR_3, VAR_7);

            } else if (isPlanarYUV(VAR_7) || VAR_7==PIX_FMT_GRAY8) { 

                const int VAR_41= (1<<c->chrDstVSubSample)-1;

                if ((VAR_19&VAR_41) || isGray(VAR_7)) VAR_27=VAR_28= NULL; 

                if (is16BPS(VAR_7)) {

                    yuv2yuvX16inC(

                                  vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,

                                  vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,

                                  VAR_41, (uint16_t *) VAR_25, (uint16_t *) VAR_27, (uint16_t *) VAR_28, (uint16_t *) VAR_29, VAR_1, VAR_3,

                                  VAR_7);

                } else {

                    yuv2yuvXinC(

                                vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,

                                vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,

                                VAR_41, VAR_25, VAR_27, VAR_28, VAR_29, VAR_1, VAR_3);

                }

            } else {

                assert(VAR_41 + VAR_10 - 1 < lumPixBuf + VAR_14*2);

                assert(VAR_41 + VAR_11 - 1 < chrPixBuf + VAR_15*2);

                if(VAR_9 & SWS_FULL_CHR_H_INT) {

                    yuv2rgbXinC_full(c,

                                     vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,

                                     vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,

                                     VAR_41, VAR_25, VAR_1, VAR_19);

                } else {

                    yuv2packedXinC(c,

                                   vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,

                                   vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,

                                   VAR_41, VAR_25, VAR_1, VAR_19);

                }

            }

        }

    }



    if ((VAR_7 == PIX_FMT_YUVA420P) && !alpPixBuf)

        fillPlane(dst[3], dstStride[3], VAR_1, VAR_19-VAR_18, VAR_18, 255);



#if COMPILE_TEMPLATE_MMX

    if (VAR_9 & SWS_CPU_CAPS_MMX2 )  __asm__ volatile("sfence":::"memory");

    

    if (VAR_9 & SWS_CPU_CAPS_3DNOW)  __asm__ volatile("femms" :::"memory");

    else                             __asm__ volatile("emms"  :::"memory");

#endif

    

    c->VAR_19= VAR_19;

    c->VAR_20= VAR_20;

    c->VAR_21= VAR_21;

    c->VAR_22= VAR_22;

    c->VAR_23= VAR_23;



    return VAR_19 - VAR_18;

}

static int FUNC_0(swScale)(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
int srcSliceH, uint8_t* dst[], int dstStride[])
{ const int VAR_0= c->VAR_0; const int VAR_1= c->VAR_1; const int VAR_2= c->VAR_2; const int VAR_3= c->VAR_3; const int VAR_4= c->VAR_4; const int VAR_5= c->VAR_5; const int VAR_6= c->VAR_6; const enum PixelFormat VAR_7= c->VAR_7; const enum PixelFormat VAR_8= c->VAR_8; const int VAR_9= c->VAR_9; int16_t *vLumFilterPos= c->vLumFilterPos; int16_t *vChrFilterPos= c->vChrFilterPos; int16_t *hLumFilterPos= c->hLumFilterPos; int16_t *hChrFilterPos= c->hChrFilterPos; int16_t *vLumFilter= c->vLumFilter; int16_t *vChrFilter= c->vChrFilter; int16_t *hLumFilter= c->hLumFilter; int16_t *hChrFilter= c->hChrFilter; int32_t *lumMmxFilter= c->lumMmxFilter; int32_t *chrMmxFilter= c->chrMmxFilter; int32_t *alpMmxFilter= c->alpMmxFilter; const int VAR_10= c->VAR_10; const int VAR_11= c->VAR_11; const int VAR_12= c->VAR_12; const int VAR_13= c->VAR_13; int16_t **lumPixBuf= c->lumPixBuf; int16_t **chrPixBuf= c->chrPixBuf; int16_t **alpPixBuf= c->alpPixBuf; const int VAR_14= c->VAR_14; const int VAR_15= c->VAR_15; uint8_t *formatConvBuffer= c->formatConvBuffer; const int VAR_16= srcSliceY >> c->chrSrcVSubSample; const int VAR_17= -((-srcSliceH) >> c->chrSrcVSubSample); int VAR_18; uint32_t *pal=c->pal_yuv; int VAR_19= c->VAR_19; int VAR_20= c->VAR_20; int VAR_21= c->VAR_21; int VAR_22= c->VAR_22; int VAR_23= c->VAR_23; if (isPacked(c->VAR_8)) { src[0]=
src[1]=
src[2]=
src[3]= src[0]; srcStride[0]=
srcStride[1]=
srcStride[2]=
srcStride[3]= srcStride[0]; } srcStride[1]<<= c->vChrDrop; srcStride[2]<<= c->vChrDrop; DEBUG_BUFFERS("swScale() %p[%d] %p[%d] %p[%d] %p[%d] -> %p[%d] %p[%d] %p[%d] %p[%d]\n",
src[0], srcStride[0], src[1], srcStride[1], src[2], srcStride[2], src[3], srcStride[3],
dst[0], dstStride[0], dst[1], dstStride[1], dst[2], dstStride[2], dst[3], dstStride[3]); DEBUG_BUFFERS("srcSliceY: %d srcSliceH: %d VAR_19: %d VAR_2: %d\n",
srcSliceY,    srcSliceH,    VAR_19,    VAR_2); DEBUG_BUFFERS("VAR_10: %d VAR_14: %d VAR_11: %d VAR_15: %d\n",
VAR_10,    VAR_14,    VAR_11,    VAR_15); if (dstStride[0]%8 !=0 || dstStride[1]%8 !=0 || dstStride[2]%8 !=0 || dstStride[3]%8 != 0) { static int VAR_24=0; if (VAR_9 & SWS_PRINT_INFO && !VAR_24) { av_log(c, AV_LOG_WARNING, "Warning: dstStride is not aligned!\n"
"         ->cannot do aligned memory accesses anymore\n"); VAR_24=1; } } if (srcSliceY ==0) { VAR_20=0; VAR_21=0; VAR_19=0; VAR_22= -1; VAR_23= -1; } VAR_18= VAR_19; for (;VAR_19 < VAR_2; VAR_19++) { unsigned char *VAR_25 =dst[0]+dstStride[0]*VAR_19; const int VAR_26= VAR_19>>c->chrDstVSubSample; unsigned char *VAR_27=dst[1]+dstStride[1]*VAR_26; unsigned char *VAR_28=dst[2]+dstStride[2]*VAR_26; unsigned char *VAR_29=(CONFIG_SWSCALE_ALPHA && alpPixBuf) ? dst[3]+dstStride[3]*VAR_19 : NULL; const int VAR_30= vLumFilterPos[VAR_19]; const int VAR_31= vChrFilterPos[VAR_26]; int VAR_32= VAR_30 + VAR_10 -1; int VAR_33= VAR_31 + VAR_11 -1; int VAR_34; if (VAR_30 > VAR_22) VAR_22= VAR_30-1; if (VAR_31 > VAR_23) VAR_23= VAR_31-1; assert(VAR_30 >= VAR_22 - VAR_14 + 1); assert(VAR_31 >= VAR_23 - VAR_15 + 1); VAR_34 = VAR_32 < srcSliceY + srcSliceH && VAR_33 < -((-srcSliceY - srcSliceH)>>c->chrSrcVSubSample); if (!VAR_34) { VAR_32 = srcSliceY + srcSliceH - 1; VAR_33 = VAR_16 + VAR_17 - 1; } DEBUG_BUFFERS("VAR_19: %d\n", VAR_19); DEBUG_BUFFERS("\tfirstLumSrcY: %d VAR_32: %d VAR_22: %d\n",
VAR_30,    VAR_32,    VAR_22); DEBUG_BUFFERS("\tfirstChrSrcY: %d VAR_33: %d VAR_23: %d\n",
VAR_31,    VAR_33,    VAR_23); while(VAR_22 < VAR_32) { uint8_t *src1= src[0]+(VAR_22 + 1 - srcSliceY)*srcStride[0]; uint8_t *src2= src[3]+(VAR_22 + 1 - srcSliceY)*srcStride[3]; VAR_20++; DEBUG_BUFFERS("\t\tlumBufIndex %d: VAR_22: %d\n",
VAR_20,    VAR_22); assert(VAR_20 < 2*VAR_14); assert(VAR_22 + 1 - srcSliceY < srcSliceH); assert(VAR_22 + 1 - srcSliceY >= 0); FUNC_0(hyscale)(c, lumPixBuf[ VAR_20 ], VAR_1, src1, VAR_0, VAR_5,
VAR_9, hLumFilter, hLumFilterPos, VAR_12,
c->VAR_8, formatConvBuffer,
pal, 0); if (CONFIG_SWSCALE_ALPHA && alpPixBuf)
FUNC_0(hyscale)(c, alpPixBuf[ VAR_20 ], VAR_1, src2, VAR_0, VAR_5,
VAR_9, hLumFilter, hLumFilterPos, VAR_12,
c->VAR_8, formatConvBuffer,
pal, 1); VAR_22++; } while(VAR_23 < VAR_33) { uint8_t *src1= src[1]+(VAR_23 + 1 - VAR_16)*srcStride[1]; uint8_t *src2= src[2]+(VAR_23 + 1 - VAR_16)*srcStride[2]; VAR_21++; DEBUG_BUFFERS("\t\tchrBufIndex %d: VAR_23: %d\n",
VAR_21,    VAR_23); assert(VAR_21 < 2*VAR_15); assert(VAR_23 + 1 - VAR_16 < (VAR_17)); assert(VAR_23 + 1 - VAR_16 >= 0); if (!(isGray(VAR_8) || isGray(VAR_7)))
FUNC_0(hcscale)(c, chrPixBuf[ VAR_21 ], VAR_3, src1, src2, VAR_4, VAR_6,
VAR_9, hChrFilter, hChrFilterPos, VAR_13,
c->VAR_8, formatConvBuffer,
pal); VAR_23++; } if (VAR_20 >= VAR_14) VAR_20-= VAR_14; if (VAR_21 >= VAR_15) VAR_21-= VAR_15; if (!VAR_34)
break; #if COMPILE_TEMPLATE_MMX
c->blueDither= ff_dither8[VAR_19&1]; if (c->VAR_7 == PIX_FMT_RGB555 || c->VAR_7 == PIX_FMT_BGR555)
c->greenDither= ff_dither8[VAR_19&1]; else
c->greenDither= ff_dither4[VAR_19&1]; c->redDither= ff_dither8[(VAR_19+1)&1]; #endif
if (VAR_19 < VAR_2-2) { const int16_t **VAR_41= (const int16_t **) lumPixBuf + VAR_20 + VAR_30 - VAR_22 + VAR_14; const int16_t **VAR_41= (const int16_t **) chrPixBuf + VAR_21 + VAR_31 - VAR_23 + VAR_15; const int16_t **VAR_41= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **) alpPixBuf + VAR_20 + VAR_30 - VAR_22 + VAR_14 : NULL; #if COMPILE_TEMPLATE_MMX
int i; if (VAR_9 & SWS_ACCURATE_RND) { int s= APCK_SIZE / 8; for (i=0; i<VAR_10; i+=2) { *(void**)&lumMmxFilter[s*i              ]= VAR_41[i  ]; *(void**)&lumMmxFilter[s*i+APCK_PTR2/4  ]= VAR_41[i+(VAR_10>1)]; lumMmxFilter[s*i+APCK_COEF/4  ]=
lumMmxFilter[s*i+APCK_COEF/4+1]= vLumFilter[VAR_19*VAR_10 + i    ]
+ (VAR_10>1 ? vLumFilter[VAR_19*VAR_10 + i + 1]<<16 : 0); if (CONFIG_SWSCALE_ALPHA && alpPixBuf) { *(void**)&alpMmxFilter[s*i              ]= VAR_41[i  ]; *(void**)&alpMmxFilter[s*i+APCK_PTR2/4  ]= VAR_41[i+(VAR_10>1)]; alpMmxFilter[s*i+APCK_COEF/4  ]=
alpMmxFilter[s*i+APCK_COEF/4+1]= lumMmxFilter[s*i+APCK_COEF/4  ]; } } for (i=0; i<VAR_11; i+=2) { *(void**)&chrMmxFilter[s*i              ]= VAR_41[i  ]; *(void**)&chrMmxFilter[s*i+APCK_PTR2/4  ]= VAR_41[i+(VAR_11>1)]; chrMmxFilter[s*i+APCK_COEF/4  ]=
chrMmxFilter[s*i+APCK_COEF/4+1]= vChrFilter[VAR_26*VAR_11 + i    ]
+ (VAR_11>1 ? vChrFilter[VAR_26*VAR_11 + i + 1]<<16 : 0); } } else { for (i=0; i<VAR_10; i++) { lumMmxFilter[4*i+0]= (int32_t)VAR_41[i]; lumMmxFilter[4*i+1]= (uint64_t)VAR_41[i] >> 32; lumMmxFilter[4*i+2]=
lumMmxFilter[4*i+3]=
((uint16_t)vLumFilter[VAR_19*VAR_10 + i])*0x10001; if (CONFIG_SWSCALE_ALPHA && alpPixBuf) { alpMmxFilter[4*i+0]= (int32_t)VAR_41[i]; alpMmxFilter[4*i+1]= (uint64_t)VAR_41[i] >> 32; alpMmxFilter[4*i+2]=
alpMmxFilter[4*i+3]= lumMmxFilter[4*i+2]; } } for (i=0; i<VAR_11; i++) { chrMmxFilter[4*i+0]= (int32_t)VAR_41[i]; chrMmxFilter[4*i+1]= (uint64_t)VAR_41[i] >> 32; chrMmxFilter[4*i+2]=
chrMmxFilter[4*i+3]=
((uint16_t)vChrFilter[VAR_26*VAR_11 + i])*0x10001; } } #endif
if (VAR_7 == PIX_FMT_NV12 || VAR_7 == PIX_FMT_NV21) { const int VAR_41= (1<<c->chrDstVSubSample)-1; if (VAR_19&VAR_41) VAR_27= NULL; c->yuv2nv12X(c,
vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,
vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,
VAR_25, VAR_27, VAR_1, VAR_3, VAR_7); } else if (isPlanarYUV(VAR_7) || VAR_7==PIX_FMT_GRAY8) { const int VAR_41= (1<<c->chrDstVSubSample)-1; if ((VAR_19&VAR_41) || isGray(VAR_7)) VAR_27=VAR_28= NULL; if (is16BPS(VAR_7)) { yuv2yuvX16inC(
vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,
vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,
VAR_41, (uint16_t *) VAR_25, (uint16_t *) VAR_27, (uint16_t *) VAR_28, (uint16_t *) VAR_29, VAR_1, VAR_3,
VAR_7); } else if (VAR_10 == 1 && VAR_11 == 1) { int16_t *lumBuf = VAR_41[0]; int16_t *chrBuf= VAR_41[0]; int16_t *alpBuf= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? VAR_41[0] : NULL; c->yuv2yuv1(c, lumBuf, chrBuf, alpBuf, VAR_25, VAR_27, VAR_28, VAR_29, VAR_1, VAR_3); } else { c->yuv2yuvX(c,
vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,
vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,
VAR_41, VAR_25, VAR_27, VAR_28, VAR_29, VAR_1, VAR_3); } } else { assert(VAR_41 + VAR_10 - 1 < lumPixBuf + VAR_14*2); assert(VAR_41 + VAR_11 - 1 < chrPixBuf + VAR_15*2); if (VAR_10 == 1 && VAR_11 == 2) { int VAR_41= vChrFilter[2*VAR_19+1]; if(VAR_9 & SWS_FULL_CHR_H_INT) { yuv2rgbXinC_full(c,
vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,
vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,
VAR_41, VAR_25, VAR_1, VAR_19); } else { c->yuv2packed1(c, *VAR_41, *VAR_41, *(VAR_41+1),
alpPixBuf ? *VAR_41 : NULL,
VAR_25, VAR_1, VAR_41, VAR_7, VAR_9, VAR_19); } } else if (VAR_10 == 2 && VAR_11 == 2) { int VAR_40= vLumFilter[2*VAR_19+1]; int VAR_41= vChrFilter[2*VAR_19+1]; lumMmxFilter[2]=
lumMmxFilter[3]= vLumFilter[2*VAR_19   ]*0x10001; chrMmxFilter[2]=
chrMmxFilter[3]= vChrFilter[2*VAR_26]*0x10001; if(VAR_9 & SWS_FULL_CHR_H_INT) { yuv2rgbXinC_full(c,
vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,
vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,
VAR_41, VAR_25, VAR_1, VAR_19); } else { c->yuv2packed2(c, *VAR_41, *(VAR_41+1), *VAR_41, *(VAR_41+1),
alpPixBuf ? *VAR_41 : NULL, alpPixBuf ? *(VAR_41+1) : NULL,
VAR_25, VAR_1, VAR_40, VAR_41, VAR_19); } } else { if(VAR_9 & SWS_FULL_CHR_H_INT) { yuv2rgbXinC_full(c,
vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,
vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,
VAR_41, VAR_25, VAR_1, VAR_19); } else { c->yuv2packedX(c,
vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,
vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,
VAR_41, VAR_25, VAR_1, VAR_19); } } } } else { const int16_t **VAR_41= (const int16_t **)lumPixBuf + VAR_20 + VAR_30 - VAR_22 + VAR_14; const int16_t **VAR_41= (const int16_t **)chrPixBuf + VAR_21 + VAR_31 - VAR_23 + VAR_15; const int16_t **VAR_41= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t **)alpPixBuf + VAR_20 + VAR_30 - VAR_22 + VAR_14 : NULL; if (VAR_7 == PIX_FMT_NV12 || VAR_7 == PIX_FMT_NV21) { const int VAR_41= (1<<c->chrDstVSubSample)-1; if (VAR_19&VAR_41) VAR_27= NULL; yuv2nv12XinC(
vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,
vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,
VAR_25, VAR_27, VAR_1, VAR_3, VAR_7); } else if (isPlanarYUV(VAR_7) || VAR_7==PIX_FMT_GRAY8) { const int VAR_41= (1<<c->chrDstVSubSample)-1; if ((VAR_19&VAR_41) || isGray(VAR_7)) VAR_27=VAR_28= NULL; if (is16BPS(VAR_7)) { yuv2yuvX16inC(
vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,
vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,
VAR_41, (uint16_t *) VAR_25, (uint16_t *) VAR_27, (uint16_t *) VAR_28, (uint16_t *) VAR_29, VAR_1, VAR_3,
VAR_7); } else { yuv2yuvXinC(
vLumFilter+VAR_19*VAR_10   , VAR_41, VAR_10,
vChrFilter+VAR_26*VAR_11, VAR_41, VAR_11,
VAR_41, VAR_25, VAR_27, VAR_28, VAR_29, VAR_1, VAR_3); } } else { assert(VAR_41 + VAR_10 - 1 < lumPixBuf + VAR_14*2); assert(VAR_41 + VAR_11 - 1 < chrPixBuf + VAR_15*2); if(VAR_9 & SWS_FULL_CHR_H_INT) { yuv2rgbXinC_full(c,
vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,
vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,
VAR_41, VAR_25, VAR_1, VAR_19); } else { yuv2packedXinC(c,
vLumFilter+VAR_19*VAR_10, VAR_41, VAR_10,
vChrFilter+VAR_19*VAR_11, VAR_41, VAR_11,
VAR_41, VAR_25, VAR_1, VAR_19); } } } } if ((VAR_7 == PIX_FMT_YUVA420P) && !alpPixBuf)
fillPlane(dst[3], dstStride[3], VAR_1, VAR_19-VAR_18, VAR_18, 255); #if COMPILE_TEMPLATE_MMX
if (VAR_9 & SWS_CPU_CAPS_MMX2 )  __asm__ volatile("sfence":::"memory"); if (VAR_9 & SWS_CPU_CAPS_3DNOW)  __asm__ volatile("femms" :::"memory"); else                             __asm__ volatile("emms"  :::"memory"); #endif
c->VAR_19= VAR_19; c->VAR_20= VAR_20; c->VAR_21= VAR_21; c->VAR_22= VAR_22; c->VAR_23= VAR_23; return VAR_19 - VAR_18; }