comparison libswscale/swscale_template.c @ 27158:65b8334df960

spelling/grammar/wording overhaul

27157:e2797c291ba9

 *
 * You should have received a copy of the GNU General Public License
 * along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * the C code (not assembly, mmx, ...) of this file can be used
 * under the LGPL license too
 */

#undef REAL_MOVNTQ
#undef MOVNTQ
#undef PAVGB

#undef PREFETCHW
#undef EMMS
#undef SFENCE

#ifdef HAVE_3DNOW
/* On K6 femms is faster of emms. On K7 femms is directly mapped on emms. */
#define EMMS     "femms"
#else
#define EMMS     "emms"
#endif

                          uint8_t *dest, int dstW, int uvalpha, int dstFormat, int flags, int y)
{
    const int yalpha1=0;
    int i;

    uint16_t *buf1= buf0; //FIXME needed for the rgb1/bgr1
    const int yalpha= 4096; //FIXME ...

    if (flags&SWS_FULL_CHR_H_INT)
    {
        RENAME(yuv2packed2)(c, buf0, buf0, uvbuf0, uvbuf1, dest, dstW, 0, uvalpha, y);

    }else{
        YSCALE_YUV_2_ANYRGB_C(YSCALE_YUV_2_RGB1B_C, YSCALE_YUV_2_PACKED1B_C)
    }
}

//FIXME yuy2* can read upto 7 samples to much

static inline void RENAME(yuy2ToY)(uint8_t *dst, uint8_t *src, long width)
{
#ifdef HAVE_MMX
    asm volatile(

        dstU[i]= p>>8;
        dstV[i]= p>>16;
    }
}

// Bilinear / Bicubic scaling
static inline void RENAME(hScale)(int16_t *dst, int dstW, uint8_t *src, int srcW, int xInc,
                                  int16_t *filter, int16_t *filterPos, long filterSize)
{
#ifdef HAVE_MMX
    assert(filterSize % 4 == 0 && filterSize>0);

        RENAME(palToY)(formatConvBuffer, src, srcW, (uint32_t*)pal);
        src= formatConvBuffer;
    }

#ifdef HAVE_MMX
    // use the new MMX scaler if the mmx2 can't be used (it is faster than the x86 ASM one)
    if (!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))
#else
    if (!(flags&SWS_FAST_BILINEAR))
#endif
    {
        RENAME(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);
    }
    else // Fast Bilinear upscale / crap downscale
    {
#if defined(ARCH_X86)
#ifdef HAVE_MMX2
        int i;
#if defined(PIC)

        src1= formatConvBuffer;
        src2= formatConvBuffer+VOFW;
    }

#ifdef HAVE_MMX
    // use the new MMX scaler if the mmx2 can't be used (it is faster than the x86 ASM one)
    if (!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))
#else
    if (!(flags&SWS_FAST_BILINEAR))
#endif
    {
        RENAME(hScale)(dst     , dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);
        RENAME(hScale)(dst+VOFW, dstWidth, src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);
    }
    else // Fast Bilinear upscale / crap downscale
    {
#if defined(ARCH_X86)
#ifdef HAVE_MMX2
        int i;
#if defined(PIC)

            "adc        %3, %%"REG_d"               \n\t" //xx+= xInc>>8 + carry
            "add        $1, %%"REG_a"               \n\t"
            "cmp        %2, %%"REG_a"               \n\t"
            " jb        1b                          \n\t"

/* GCC-3.3 makes MPlayer crash on IA-32 machines when using "g" operand here,
   which is needed to support GCC-4.0 */
#if defined(ARCH_X86_64) && ((__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
            :: "m" (src1), "m" (dst), "g" ((long)dstWidth), "m" (xInc_shr16), "m" (xInc_mask),
#else
            :: "m" (src1), "m" (dst), "m" ((long)dstWidth), "m" (xInc_shr16), "m" (xInc_mask),
#endif

    const int chrSrcSliceY= srcSliceY >> c->chrSrcVSubSample;
    const int chrSrcSliceH= -((-srcSliceH) >> c->chrSrcVSubSample);
    int lastDstY;
    uint8_t *pal=NULL;

    /* vars whch will change and which we need to storw back in the context */
    int dstY= c->dstY;
    int lumBufIndex= c->lumBufIndex;
    int chrBufIndex= c->chrBufIndex;
    int lastInLumBuf= c->lastInLumBuf;
    int lastInChrBuf= c->lastInChrBuf;

    {
        static int firstTime=1; //FIXME move this into the context perhaps
        if (flags & SWS_PRINT_INFO && firstTime)
        {
            av_log(c, AV_LOG_WARNING, "Warning: dstStride is not aligned!\n"
                   "         ->cannot do aligned memory acesses anymore\n");
            firstTime=0;
        }
    }

    /* 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 ppl might do it */
    if (srcSliceY ==0){
        lumBufIndex=0;
        chrBufIndex=0;
        dstY=0;
        lastInLumBuf= -1;

            }
            else if (isPlanarYUV(dstFormat) || isGray(dstFormat)) //YV12 like
            {
                const int chrSkipMask= (1<<c->chrDstVSubSample)-1;
                if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi
                if (vLumFilterSize == 1 && vChrFilterSize == 1) // Unscaled YV12
                {
                    int16_t *lumBuf = lumPixBuf[0];
                    int16_t *chrBuf= chrPixBuf[0];
                    RENAME(yuv2yuv1)(lumBuf, chrBuf, dest, uDest, vDest, 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];
                    RENAME(yuv2packed1)(c, *lumSrcPtr, *chrSrcPtr, *(chrSrcPtr+1),
                        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;
                    RENAME(yuv2packed2)(c, *lumSrcPtr, *(lumSrcPtr+1), *chrSrcPtr, *(chrSrcPtr+1),
                        dest, dstW, lumAlpha, chrAlpha, dstY);
                }
                else //General RGB
                {
                    RENAME(yuv2packedX)(c,
                        vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
                        vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
                        dest, dstW, dstY);

27158:65b8334df960

 *
 * You should have received a copy of the GNU General Public License
 * along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * The C code (not assembly, MMX, ...) of this file can be used
 * under the LGPL license.
 */

#undef REAL_MOVNTQ
#undef MOVNTQ
#undef PAVGB

#undef PREFETCHW
#undef EMMS
#undef SFENCE

#ifdef HAVE_3DNOW
/* On K6 femms is faster than emms. On K7 femms is directly mapped on emms. */
#define EMMS     "femms"
#else
#define EMMS     "emms"
#endif

                          uint8_t *dest, int dstW, int uvalpha, int dstFormat, int flags, int y)
{
    const int yalpha1=0;
    int i;

    uint16_t *buf1= buf0; //FIXME needed for RGB1/BGR1
    const int yalpha= 4096; //FIXME ...

    if (flags&SWS_FULL_CHR_H_INT)
    {
        RENAME(yuv2packed2)(c, buf0, buf0, uvbuf0, uvbuf1, dest, dstW, 0, uvalpha, y);

    }else{
        YSCALE_YUV_2_ANYRGB_C(YSCALE_YUV_2_RGB1B_C, YSCALE_YUV_2_PACKED1B_C)
    }
}

//FIXME yuy2* can read up to 7 samples too much

static inline void RENAME(yuy2ToY)(uint8_t *dst, uint8_t *src, long width)
{
#ifdef HAVE_MMX
    asm volatile(

        dstU[i]= p>>8;
        dstV[i]= p>>16;
    }
}

// bilinear / bicubic scaling
static inline void RENAME(hScale)(int16_t *dst, int dstW, uint8_t *src, int srcW, int xInc,
                                  int16_t *filter, int16_t *filterPos, long filterSize)
{
#ifdef HAVE_MMX
    assert(filterSize % 4 == 0 && filterSize>0);

        RENAME(palToY)(formatConvBuffer, src, srcW, (uint32_t*)pal);
        src= formatConvBuffer;
    }

#ifdef HAVE_MMX
    // Use the new MMX scaler if the MMX2 one can't be used (it is faster than the x86 ASM one).
    if (!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))
#else
    if (!(flags&SWS_FAST_BILINEAR))
#endif
    {
        RENAME(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);
    }
    else // fast bilinear upscale / crap downscale
    {
#if defined(ARCH_X86)
#ifdef HAVE_MMX2
        int i;
#if defined(PIC)

        src1= formatConvBuffer;
        src2= formatConvBuffer+VOFW;
    }

#ifdef HAVE_MMX
    // Use the new MMX scaler if the MMX2 one can't be used (it is faster than the x86 ASM one).
    if (!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))
#else
    if (!(flags&SWS_FAST_BILINEAR))
#endif
    {
        RENAME(hScale)(dst     , dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);
        RENAME(hScale)(dst+VOFW, dstWidth, src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);
    }
    else // fast bilinear upscale / crap downscale
    {
#if defined(ARCH_X86)
#ifdef HAVE_MMX2
        int i;
#if defined(PIC)

            "adc        %3, %%"REG_d"               \n\t" //xx+= xInc>>8 + carry
            "add        $1, %%"REG_a"               \n\t"
            "cmp        %2, %%"REG_a"               \n\t"
            " jb        1b                          \n\t"

/* GCC 3.3 makes MPlayer crash on IA-32 machines when using "g" operand here,
   which is needed to support GCC 4.0. */
#if defined(ARCH_X86_64) && ((__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
            :: "m" (src1), "m" (dst), "g" ((long)dstWidth), "m" (xInc_shr16), "m" (xInc_mask),
#else
            :: "m" (src1), "m" (dst), "m" ((long)dstWidth), "m" (xInc_shr16), "m" (xInc_mask),
#endif

    const int chrSrcSliceY= srcSliceY >> c->chrSrcVSubSample;
    const int chrSrcSliceH= -((-srcSliceH) >> c->chrSrcVSubSample);
    int lastDstY;
    uint8_t *pal=NULL;

    /* 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;

    {
        static int firstTime=1; //FIXME move this into the context perhaps
        if (flags & SWS_PRINT_INFO && firstTime)
        {
            av_log(c, AV_LOG_WARNING, "Warning: dstStride is not aligned!\n"
                   "         ->cannot do aligned memory accesses anymore\n");
            firstTime=0;
        }
    }

    /* 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;

            }
            else if (isPlanarYUV(dstFormat) || isGray(dstFormat)) //YV12 like
            {
                const int chrSkipMask= (1<<c->chrDstVSubSample)-1;
                if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi
                if (vLumFilterSize == 1 && vChrFilterSize == 1) // unscaled YV12
                {
                    int16_t *lumBuf = lumPixBuf[0];
                    int16_t *chrBuf= chrPixBuf[0];
                    RENAME(yuv2yuv1)(lumBuf, chrBuf, dest, uDest, vDest, 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];
                    RENAME(yuv2packed1)(c, *lumSrcPtr, *chrSrcPtr, *(chrSrcPtr+1),
                        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;
                    RENAME(yuv2packed2)(c, *lumSrcPtr, *(lumSrcPtr+1), *chrSrcPtr, *(chrSrcPtr+1),
                        dest, dstW, lumAlpha, chrAlpha, dstY);
                }
                else //general RGB
                {
                    RENAME(yuv2packedX)(c,
                        vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
                        vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
                        dest, dstW, dstY);