Skip to content

GitLab

Commit e0a64041 authored by Loren Merritt's avatar Loren Merritt
Browse files

cosmetics. 

silence some gcc warnings.
amd64 doesn't need a separate copy of the c/h files, only the asm.


git-svn-id: svn://svn.videolan.org/x264/trunk@217 df754926-b1dd-0310-bc7b-ec298dee348c
parent d2ad6a20
Hide whitespace changes
Inline Side-by-side
Makefile
View file @ e0a64041
......@@ -20,7 +20,7 @@ endif
# MMX/SSE optims
ifeq ($(ARCH),X86_64)
SRCS += common/amd64/mc-c.c common/amd64/dct-c.c common/amd64/predict.c
SRCS += common/i386/mc-c.c common/i386/dct-c.c common/i386/predict.c
ASMSRC = common/amd64/dct-a.asm common/amd64/cpu-a.asm \
common/amd64/pixel-a.asm common/amd64/mc-a.asm \
common/amd64/mc-a2.asm common/amd64/predict-a.asm
......
common/amd64/dct-c.c deleted 100644 → 0
View file @ d2ad6a20
/*****************************************************************************
* dct.c: h264 encoder library
*****************************************************************************
* Copyright (C) 2003 Laurent Aimar
* $Id: dct-c.c,v 1.1 2004/06/03 19:27:07 fenrir Exp $
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/
#ifdef HAVE_STDINT_H
#include <stdint.h>
#else
#include <inttypes.h>
#endif
#include <stdlib.h>
#include <stdarg.h>
#include "x264.h"
#include "common/dct.h"
#include "dct.h"
#if 0
#define MMX_ZERO( MMZ ) \
asm volatile( "pxor " #MMZ ", " #MMZ "\n" :: )
/* MMP : diff, MMT: temp */
#define MMX_LOAD_DIFF_4P( MMP, MMT, MMZ, pix1, pix2 ) \
asm volatile( "movd (%0), " #MMP "\n" \
"punpcklbw " #MMZ ", " #MMP "\n" \
"movd (%1), " #MMT "\n" \
"punpcklbw " #MMZ ", " #MMT "\n" \
"psubw " #MMT ", " #MMP "\n" : : "r"(pix1), "r"(pix2) )
/* in: out: mma=mma+mmb, mmb=mmb-mma */
#define MMX_SUMSUB_BA( MMA, MMB ) \
asm volatile( "paddw " #MMB ", " #MMA "\n"\
"paddw " #MMB ", " #MMB "\n"\
"psubw " #MMA ", " #MMB "\n" :: )
#define MMX_SUMSUB_BADC( MMA, MMB, MMC, MMD ) \
asm volatile( "paddw " #MMB ", " #MMA "\n"\
"paddw " #MMD ", " #MMC "\n"\
"paddw " #MMB ", " #MMB "\n"\
"paddw " #MMD ", " #MMD "\n"\
"psubw " #MMA ", " #MMB "\n"\
"psubw " #MMC ", " #MMD "\n" :: )
/* inputs MMA, MMB output MMA MMT */
#define MMX_SUMSUB2_AB( MMA, MMB, MMT ) \
asm volatile( "movq " #MMA ", " #MMT "\n" \
"paddw " #MMA ", " #MMA "\n" \
"paddw " #MMB ", " #MMA "\n" \
"psubw " #MMB ", " #MMT "\n" \
"psubw " #MMB ", " #MMT "\n" :: )
/* inputs MMA, MMB output MMA MMS */
#define MMX_SUMSUBD2_AB( MMA, MMB, MMT, MMS ) \
asm volatile( "movq " #MMA ", " #MMS "\n" \
"movq " #MMB ", " #MMT "\n" \
"psraw $1 , " #MMB "\n" \
"psraw $1 , " #MMS "\n" \
"paddw " #MMB ", " #MMA "\n" \
"psubw " #MMT ", " #MMS "\n" :: )
#define SBUTTERFLYwd(a,b,t )\
asm volatile( "movq " #a ", " #t " \n\t" \
"punpcklwd " #b ", " #a " \n\t" \
"punpckhwd " #b ", " #t " \n\t" :: )
#define SBUTTERFLYdq(a,b,t )\
asm volatile( "movq " #a ", " #t " \n\t" \
"punpckldq " #b ", " #a " \n\t" \
"punpckhdq " #b ", " #t " \n\t" :: )
/* input ABCD output ADTC */
#define MMX_TRANSPOSE( MMA, MMB, MMC, MMD, MMT ) \
SBUTTERFLYwd( MMA, MMB, MMT ); \
SBUTTERFLYwd( MMC, MMD, MMB ); \
SBUTTERFLYdq( MMA, MMC, MMD ); \
SBUTTERFLYdq( MMT, MMB, MMC )
#define MMX_STORE_DIFF_4P( MMP, MMT, MM32, MMZ, dst ) \
asm volatile( "paddw " #MM32 "," #MMP "\n" \
"psraw $6, " #MMP "\n" \
"movd (%0), " #MMT "\n" \
"punpcklbw " #MMZ ", " #MMT "\n" \
"paddsw " #MMT ", " #MMP "\n" \
"packuswb " #MMZ ", " #MMP "\n" \
"movd " #MMP ", (%0)\n" :: "r"(dst) )
#define UNUSED_LONGLONG( foo ) \
static const unsigned long long foo __asm__ (#foo) __attribute__((unused)) __attribute__((aligned(16)))
UNUSED_LONGLONG( x264_mmx_32 ) = 0x0020002000200020ULL;
UNUSED_LONGLONG( x264_mmx_1 ) = 0x0001000100010001ULL;
/*
* XXX For all dct dc : input could be equal to output so ...
*/
void x264_dct4x4dc_mmxext( int16_t d[4][4] )
{
/* load DCT */
asm volatile(
"movq (%0), %%mm0\n"
"movq 8(%0), %%mm1\n"
"movq 16(%0), %%mm2\n"
"movq 24(%0), %%mm3\n" :: "r"(d) );
MMX_SUMSUB_BADC( %%mm1, %%mm0, %%mm3, %%mm2 ); /* mm1=s01 mm0=d01 mm3=s23 mm2=d23 */
MMX_SUMSUB_BADC( %%mm3, %%mm1, %%mm2, %%mm0 ); /* mm3=s01+s23 mm1=s01-s23 mm2=d01+d23 mm0=d01-d23 */
/* in: mm3, mm1, mm0, mm2 out: mm3, mm2, mm4, mm0 */
MMX_TRANSPOSE ( %%mm3, %%mm1, %%mm0, %%mm2, %%mm4 );
MMX_SUMSUB_BADC( %%mm2, %%mm3, %%mm0, %%mm4 ); /* mm2=s01 mm3=d01 mm0=s23 mm4=d23 */
MMX_SUMSUB_BADC( %%mm0, %%mm2, %%mm4, %%mm3 ); /* mm0=s01+s23 mm2=s01-s23 mm4=d01+d23 mm3=d01-d23 */
/* in: mm0, mm2, mm3, mm4 out: mm0, mm4, mm1, mm3 */
MMX_TRANSPOSE ( %%mm0, %%mm2, %%mm3, %%mm4, %%mm1 );
asm volatile( "movq x264_mmx_1, %%mm6" :: );
/* Store back */
asm volatile(
"paddw %%mm6, %%mm0\n"
"paddw %%mm6, %%mm4\n"
"psraw $1, %%mm0\n"
"movq %%mm0, (%0)\n"
"psraw $1, %%mm4\n"
"movq %%mm4, 8(%0)\n"
"paddw %%mm6, %%mm1\n"
"paddw %%mm6, %%mm3\n"
"psraw $1, %%mm1\n"
"movq %%mm1, 16(%0)\n"
"psraw $1, %%mm3\n"
"movq %%mm3, 24(%0)\n" :: "r"(d) );
}
void x264_idct4x4dc_mmxext( int16_t d[4][4] )
{
/* load DCT */
asm volatile(
"movq (%0), %%mm0\n"
"movq 8(%0), %%mm1\n"
"movq 16(%0), %%mm2\n"
"movq 24(%0), %%mm3\n" :: "r"(d) );
MMX_SUMSUB_BADC( %%mm1, %%mm0, %%mm3, %%mm2 ); /* mm1=s01 mm0=d01 mm3=s23 mm2=d23 */
MMX_SUMSUB_BADC( %%mm3, %%mm1, %%mm2, %%mm0 ); /* mm3=s01+s23 mm1=s01-s23 mm2=d01+d23 mm0=d01-d23 */
/* in: mm3, mm1, mm0, mm2 out: mm3, mm2, mm4, mm0 */
MMX_TRANSPOSE( %%mm3, %%mm1, %%mm0, %%mm2, %%mm4 );
MMX_SUMSUB_BADC( %%mm2, %%mm3, %%mm0, %%mm4 ); /* mm2=s01 mm3=d01 mm0=s23 mm4=d23 */
MMX_SUMSUB_BADC( %%mm0, %%mm2, %%mm4, %%mm3 ); /* mm0=s01+s23 mm2=s01-s23 mm4=d01+d23 mm3=d01-d23 */
/* in: mm0, mm2, mm3, mm4 out: mm0, mm4, mm1, mm3 */
MMX_TRANSPOSE( %%mm0, %%mm2, %%mm3, %%mm4, %%mm1 );
/* Store back */
asm volatile(
"movq %%mm0, (%0)\n"
"movq %%mm4, 8(%0)\n"
"movq %%mm1, 16(%0)\n"
"movq %%mm3, 24(%0)\n" :: "r"(d) );
}
/****************************************************************************
* subXxX_dct:
****************************************************************************/
inline void x264_sub4x4_dct_mmxext( int16_t dct[4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
{
/* Reset mm7 */
MMX_ZERO( %%mm7 );
/* Load 4 lines */
MMX_LOAD_DIFF_4P( %%mm0, %%mm6, %%mm7, &pix1[0*i_pix1], &pix2[0*i_pix2] );
MMX_LOAD_DIFF_4P( %%mm1, %%mm6, %%mm7, &pix1[1*i_pix1], &pix2[1*i_pix2] );
MMX_LOAD_DIFF_4P( %%mm2, %%mm6, %%mm7, &pix1[2*i_pix1], &pix2[2*i_pix2] );
MMX_LOAD_DIFF_4P( %%mm3, %%mm6, %%mm7, &pix1[3*i_pix1], &pix2[3*i_pix2] );
MMX_SUMSUB_BADC( %%mm3, %%mm0, %%mm2, %%mm1 ); /* mm3=s03 mm0=d03 mm2=s12 mm1=d12 */
MMX_SUMSUB_BA( %%mm2, %%mm3 ); /* mm2=s03+s12 mm3=s03-s12 */
MMX_SUMSUB2_AB( %%mm0, %%mm1, %%mm4 ); /* mm0=2.d03+d12 mm4=d03-2.d12 */
/* transpose in: mm2, mm0, mm3, mm4, out: mm2, mm4, mm1, mm3 */
MMX_TRANSPOSE( %%mm2, %%mm0, %%mm3, %%mm4, %%mm1 );
MMX_SUMSUB_BADC( %%mm3, %%mm2, %%mm1, %%mm4 ); /* mm3=s03 mm2=d03 mm1=s12 mm4=d12 */
MMX_SUMSUB_BA( %%mm1, %%mm3 ); /* mm1=s03+s12 mm3=s03-s12 */
MMX_SUMSUB2_AB( %%mm2, %%mm4, %%mm0 ); /* mm2=2.d03+d12 mm0=d03-2.d12 */
/* transpose in: mm1, mm2, mm3, mm0, out: mm1, mm0, mm4, mm3 */
MMX_TRANSPOSE( %%mm1, %%mm2, %%mm3, %%mm0, %%mm4 );
/* Store back */
asm volatile(
"movq %%mm1, (%0)\n"
"movq %%mm0, 8(%0)\n"
"movq %%mm4, 16(%0)\n"
"movq %%mm3, 24(%0)\n" :: "r"(dct) );
}
#endif
void x264_sub8x8_dct_mmxext( int16_t dct[4][4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
{
x264_sub4x4_dct_mmxext( dct[0], &pix1[0], i_pix1, &pix2[0], i_pix2 );
x264_sub4x4_dct_mmxext( dct[1], &pix1[4], i_pix1, &pix2[4], i_pix2 );
x264_sub4x4_dct_mmxext( dct[2], &pix1[4*i_pix1+0], i_pix1, &pix2[4*i_pix2+0], i_pix2 );
x264_sub4x4_dct_mmxext( dct[3], &pix1[4*i_pix1+4], i_pix1, &pix2[4*i_pix2+4], i_pix2 );
}
void x264_sub16x16_dct_mmxext( int16_t dct[16][4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
{
x264_sub8x8_dct_mmxext( &dct[ 0], &pix1[0], i_pix1, &pix2[0], i_pix2 );
x264_sub8x8_dct_mmxext( &dct[ 4], &pix1[8], i_pix1, &pix2[8], i_pix2 );
x264_sub8x8_dct_mmxext( &dct[ 8], &pix1[8*i_pix1], i_pix1, &pix2[8*i_pix2], i_pix2 );
x264_sub8x8_dct_mmxext( &dct[12], &pix1[8*i_pix1+8], i_pix1, &pix2[8*i_pix2+8], i_pix2 );
}
/****************************************************************************
* addXxX_idct:
****************************************************************************/
#if 0
inline void x264_add4x4_idct_mmxext( uint8_t *p_dst, int i_dst, int16_t dct[4][4] )
{
/* Load dct coeffs */
asm volatile(
"movq (%0), %%mm0\n"
"movq 8(%0), %%mm1\n"
"movq 16(%0), %%mm2\n"
"movq 24(%0), %%mm3\n" :: "r"(dct) );
MMX_SUMSUB_BA ( %%mm2, %%mm0 ); /* mm2=s02 mm0=d02 */
MMX_SUMSUBD2_AB( %%mm1, %%mm3, %%mm5, %%mm4 ); /* mm1=s13 mm4=d13 ( well 1 + 3>>1 and 1>>1 + 3) */
MMX_SUMSUB_BADC( %%mm1, %%mm2, %%mm4, %%mm0 ); /* mm1=s02+s13 mm2=s02-s13 mm4=d02+d13 mm0=d02-d13 */
/* in: mm1, mm4, mm0, mm2 out: mm1, mm2, mm3, mm0 */
MMX_TRANSPOSE ( %%mm1, %%mm4, %%mm0, %%mm2, %%mm3 );
MMX_SUMSUB_BA ( %%mm3, %%mm1 ); /* mm3=s02 mm1=d02 */
MMX_SUMSUBD2_AB( %%mm2, %%mm0, %%mm5, %%mm4 ); /* mm2=s13 mm4=d13 ( well 1 + 3>>1 and 1>>1 + 3) */
MMX_SUMSUB_BADC( %%mm2, %%mm3, %%mm4, %%mm1 ); /* mm2=s02+s13 mm3=s02-s13 mm4=d02+d13 mm1=d02-d13 */
/* in: mm2, mm4, mm1, mm3 out: mm2, mm3, mm0, mm1 */
MMX_TRANSPOSE ( %%mm2, %%mm4, %%mm1, %%mm3, %%mm0 );
MMX_ZERO( %%mm7 );
asm volatile( "movq x264_mmx_32, %%mm6\n" :: );
MMX_STORE_DIFF_4P( %%mm2, %%mm4, %%mm6, %%mm7, &p_dst[0*i_dst] );
MMX_STORE_DIFF_4P( %%mm3, %%mm4, %%mm6, %%mm7, &p_dst[1*i_dst] );
MMX_STORE_DIFF_4P( %%mm0, %%mm4, %%mm6, %%mm7, &p_dst[2*i_dst] );
MMX_STORE_DIFF_4P( %%mm1, %%mm4, %%mm6, %%mm7, &p_dst[3*i_dst] );
}
#endif
void x264_add8x8_idct_mmxext( uint8_t *p_dst, int i_dst, int16_t dct[4][4][4] )
{
x264_add4x4_idct_mmxext( p_dst, i_dst, dct[0] );
x264_add4x4_idct_mmxext( &p_dst[4], i_dst, dct[1] );
x264_add4x4_idct_mmxext( &p_dst[4*i_dst+0], i_dst, dct[2] );
x264_add4x4_idct_mmxext( &p_dst[4*i_dst+4], i_dst, dct[3] );
}
void x264_add16x16_idct_mmxext( uint8_t *p_dst, int i_dst, int16_t dct[16][4][4] )
{
x264_add8x8_idct_mmxext( &p_dst[0], i_dst, &dct[0] );
x264_add8x8_idct_mmxext( &p_dst[8], i_dst, &dct[4] );
x264_add8x8_idct_mmxext( &p_dst[8*i_dst], i_dst, &dct[8] );
x264_add8x8_idct_mmxext( &p_dst[8*i_dst+8], i_dst, &dct[12] );
}
common/amd64/dct.h deleted 100644 → 0
View file @ d2ad6a20
/*****************************************************************************
* dct.h: h264 encoder library
*****************************************************************************
* Copyright (C) 2003 Laurent Aimar
* $Id: dct.h,v 1.1 2004/06/03 19:27:07 fenrir Exp $
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/
#ifndef _I386_DCT_H
#define _I386_DCT_H 1
void x264_sub4x4_dct_mmxext( int16_t dct[4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 );
void x264_sub8x8_dct_mmxext( int16_t dct[4][4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 );
void x264_sub16x16_dct_mmxext( int16_t dct[16][4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 );
void x264_add4x4_idct_mmxext( uint8_t *p_dst, int i_dst, int16_t dct[4][4] );
void x264_add8x8_idct_mmxext( uint8_t *p_dst, int i_dst, int16_t dct[4][4][4] );
void x264_add16x16_idct_mmxext( uint8_t *p_dst, int i_dst, int16_t dct[16][4][4] );
void x264_dct4x4dc_mmxext( int16_t d[4][4] );
void x264_idct4x4dc_mmxext( int16_t d[4][4] );
#endif
common/amd64/mc-c.c deleted 100644 → 0
View file @ d2ad6a20
/*****************************************************************************
* mc.c: h264 encoder library (Motion Compensation)
*****************************************************************************
* Copyright (C) 2003 Laurent Aimar
* $Id: mc-c.c,v 1.5 2004/06/18 01:59:58 chenm001 Exp $
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/
#ifdef HAVE_STDINT_H
#include <stdint.h>
#else
#include <inttypes.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include "x264.h" /* DECLARE_ALIGNED */
#include "common/mc.h"
#include "common/clip1.h"
#include "mc.h"
#if 0
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
#define USED_UINT64(foo) \
static const uint64_t foo __asm__ (#foo) __attribute__((used))
#else
#define USED_UINT64(foo) \
static const uint64_t foo __asm__ (#foo) __attribute__((unused))
#endif
USED_UINT64( x264_w0x10 ) = 0x0010001000100010ULL;
#define MMX_ZERO( MMZ ) \
asm volatile( "pxor " #MMZ ", " #MMZ "\n" :: )
#define MMX_INIT( MMV, NAME ) \
asm volatile( "movq " #NAME ", " #MMV "\n" :: )
#define MMX_SAVE_4P( MMP, MMZ, dst ) \
asm volatile( "packuswb " #MMZ "," #MMP "\n" \
"movd " #MMP ", (%0)" :: "r"(dst) )
#define MMX_LOAD_4P( MMP, MMZ, pix ) \
asm volatile( "movd (%0), " #MMP "\n" \
"punpcklbw " #MMZ ", " #MMP "\n" : : "r"(pix) )
#define MMX_LOAD_4x4( MMP1, MMP2, MMP3, MMP4, MMZ, pix, i_pix )\
MMX_LOAD_4P( MMP1, MMZ, &(pix)[0*(i_pix)] ); \
MMX_LOAD_4P( MMP2, MMZ, &(pix)[1*(i_pix)] ); \
MMX_LOAD_4P( MMP3, MMZ, &(pix)[2*(i_pix)] ); \
MMX_LOAD_4P( MMP4, MMZ, &(pix)[3*(i_pix)] )
#define MMX_LOAD_2x4( MMP1, MMP2, MMZ, pix, i_pix )\
MMX_LOAD_4P( MMP1, MMZ, &(pix)[0*(i_pix)] ); \
MMX_LOAD_4P( MMP2, MMZ, &(pix)[1*(i_pix)] )
#define MMX_SAVEPACK_8P( MMP1, MMP2, MMZ, dst ) \
asm volatile( "packuswb " #MMP2 "," #MMP1 "\n" \
"movq " #MMP1 ", (%0)\n" :: "r"(dst) )
#define MMX_LOAD_8P( MMP1, MMP2, MMZ, pix ) \
asm volatile( "movq (%0) , " #MMP1 "\n" \
"movq " #MMP1 ", " #MMP2 "\n" \
"punpcklbw " #MMZ ", " #MMP1 "\n" \
"punpckhbw " #MMZ ", " #MMP2 "\n" : : "r"(pix) )
#define MMX_LOAD_2x8( MMP1, MMP2, MMP3, MMP4, MMZ, pix, i_pix )\
MMX_LOAD_8P( MMP1, MMP2, MMZ, &(pix)[0*(i_pix)] ); \
MMX_LOAD_8P( MMP3, MMP4, MMZ, &(pix)[1*(i_pix)] )
#define SBUTTERFLYwd(a,b,t )\
asm volatile( "movq " #a ", " #t " \n\t" \
"punpcklwd " #b ", " #a " \n\t" \
"punpckhwd " #b ", " #t " \n\t" :: )
#define SBUTTERFLYdq(a,b,t )\
asm volatile( "movq " #a ", " #t " \n\t" \
"punpckldq " #b ", " #a " \n\t" \
"punpckhdq " #b ", " #t " \n\t" :: )
/* input ABCD output ADTC ( or 0?31-2->0123 ) */
#define MMX_TRANSPOSE( MMA, MMB, MMC, MMD, MMT ) \
SBUTTERFLYwd( MMA, MMB, MMT ); \
SBUTTERFLYwd( MMC, MMD, MMB ); \
SBUTTERFLYdq( MMA, MMC, MMD ); \
SBUTTERFLYdq( MMT, MMB, MMC )
/* first pass MM0 = MM0 -5*MM1 */
#define MMX_FILTERTAP_P1( MMP0, MMP1 ) \
asm volatile( "psubw " #MMP1 "," #MMP0 "\n" \
"psllw $2, " #MMP1 "\n" \
"psubw " #MMP1 "," #MMP0 "\n" :: )
\
/* second pass MM0 = MM0 + 20*(MM2+MM3) */
#define MMX_FILTERTAP_P2( MMP0, MMP2, MMP3 ) \
asm volatile( "paddw " #MMP3 "," #MMP2 "\n" \
\
"psllw $2, " #MMP2 "\n" \
"paddw " #MMP2 "," #MMP0 "\n" \
"psllw $2, " #MMP2 "\n" \
"paddw " #MMP2 "," #MMP0 "\n" :: )
/* last pass: MM0 = ( MM0 -5*MM1 + MM2 + MMV ) >> 5 */
#define MMX_FILTERTAP_P3( MMP0, MMP1, MMP2, MMV, MMZ ) \
asm volatile( "psubw " #MMP1 "," #MMP0 "\n" \
"psllw $2, " #MMP1 "\n" \
"psubw " #MMP1 "," #MMP0 "\n" \
\
"paddw " #MMP2 "," #MMP0 "\n" \
"paddw " #MMV "," #MMP0 "\n" \
"psraw $5, " #MMP0 "\n" :: )
#define MMX_FILTERTAP2_P1( MMP0, MMP1, MMP2, MMP3 ) \
asm volatile( "psubw " #MMP1 "," #MMP0 "\n" \
"psubw " #MMP3 "," #MMP2 "\n" \
"psllw $2, " #MMP1 "\n" \
"psllw $2, " #MMP3 "\n" \
"psubw " #MMP1 "," #MMP0 "\n" \
"psubw " #MMP3 "," #MMP2 "\n" :: )
/* second pass MM0 = MM0 + 20*(MM1+MM2) */
#define MMX_FILTERTAP2_P2( MMP0, MMP1, MMP2, MMP3, MMP4, MMP5 ) \
asm volatile( "paddw " #MMP2 "," #MMP1 "\n" \
"paddw " #MMP5 "," #MMP4 "\n" \
\
"psllw $2, " #MMP1 "\n" \
"psllw $2, " #MMP4 "\n" \
"paddw " #MMP1 "," #MMP0 "\n" \
"paddw " #MMP4 "," #MMP3 "\n" \
"psllw $2, " #MMP1 "\n" \
"psllw $2, " #MMP4 "\n" \
"paddw " #MMP1 "," #MMP0 "\n" \
"paddw " #MMP4 "," #MMP3 "\n" :: )
#define MMX_LOAD_1r( m1, dst ) \
asm volatile( "movq (%0), " #m1 "\n" :: "r"(dst) ); \
#define MMX_SAVE_1r( m1, dst ) \
asm volatile( "movq " #m1 ", (%0)\n" :: "r"(dst) ); \
#define MMX_LOAD_2r( m1, m2, dst, i_dst ) \
asm volatile( "movq (%0), " #m1 "\n" :: "r"(&((uint8_t*)dst)[0*(i_dst)]) ); \
asm volatile( "movq (%0), " #m2 "\n" :: "r"(&((uint8_t*)dst)[1*(i_dst)]) )
#define MMX_SAVE_2r( m1, m2, dst, i_dst ) \
asm volatile( "movq " #m1 ", (%0)\n" :: "r"(&((uint8_t*)dst)[0*(i_dst)]) ); \
asm volatile( "movq " #m2 ", (%0)\n" :: "r"(&((uint8_t*)dst)[1*(i_dst)]) )
#define MMX_SAVE_4r( m1, m2, m3, m4, dst, i_dst ) \
asm volatile( "movq " #m1 ", (%0)\n" :: "r"(&((uint8_t*)dst)[0*(i_dst)]) ); \
asm volatile( "movq " #m2 ", (%0)\n" :: "r"(&((uint8_t*)dst)[1*(i_dst)]) ); \
asm volatile( "movq " #m3 ", (%0)\n" :: "r"(&((uint8_t*)dst)[2*(i_dst)]) ); \
asm volatile( "movq " #m4 ", (%0)\n" :: "r"(&((uint8_t*)dst)[3*(i_dst)]) )
#define MMX_LOAD_4r( m1, m2, m3, m4, dst, i_dst ) \
asm volatile( "movq (%0), " #m1 "\n" :: "r"(&((uint8_t*)dst)[0*(i_dst)]) ); \
asm volatile( "movq (%0), " #m2 "\n" :: "r"(&((uint8_t*)dst)[1*(i_dst)]) ); \
asm volatile( "movq (%0), " #m3 "\n" :: "r"(&((uint8_t*)dst)[2*(i_dst)]) ); \
asm volatile( "movq (%0), " #m4 "\n" :: "r"(&((uint8_t*)dst)[3*(i_dst)]) )
static inline int x264_tapfilter( uint8_t *pix, int i_pix_next )
{
return pix[-2*i_pix_next] - 5*pix[-1*i_pix_next] + 20*(pix[0] + pix[1*i_pix_next]) - 5*pix[ 2*i_pix_next] + pix[ 3*i_pix_next];
}
static inline int x264_tapfilter1( uint8_t *pix )
{
return pix[-2] - 5*pix[-1] + 20*(pix[0] + pix[1]) - 5*pix[ 2] + pix[ 3];
}
typedef void (*pf_mc_t)(uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_height );
/* NASM functions */
extern void x264_pixel_avg_w4_mmxext( uint8_t *, int, uint8_t *, int, uint8_t *, int, int );
extern void x264_pixel_avg_w8_mmxext( uint8_t *, int, uint8_t *, int, uint8_t *, int, int );
extern void x264_pixel_avg_w16_mmxext( uint8_t *, int, uint8_t *, int, uint8_t *, int, int );
extern void x264_pixel_avg_w16_sse2( uint8_t *, int, uint8_t *, int, uint8_t *, int, int );
/* Macro to define NxM functions */
/* mc I+H */
#define MC_IH( name, cpu, width, height, off ) \
static void name##_w##width##_##cpu( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_height ) \
{ \
DECLARE_ALIGNED( uint8_t, tmp[width*height], width ); \
\
mc_hh_w##width( src, i_src_stride, tmp, width, i_height ); \
x264_pixel_avg_w##width##_##cpu( dst, i_dst_stride, \
src+(off), i_src_stride, \
tmp, width, i_height ); \
}
/* mc I+V */
#define MC_IV( name, cpu, width, height, off ) \
static void name##_w##width##_##cpu( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_height ) \
{ \
DECLARE_ALIGNED( uint8_t, tmp[width*height], width ); \
\
mc_hv_w##width( src, i_src_stride, tmp, width, i_height ); \
x264_pixel_avg_w##width##_##cpu( dst, i_dst_stride, \
src+(off), i_src_stride, \
tmp, width, i_height ); \
}
/* mc H+V */
#define MC_HV( name, cpu, width, height, off1, off2 ) \
static void name##_w##width##_##cpu( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_height ) \
{ \
DECLARE_ALIGNED( uint8_t, tmp1[width*height], width ); \
DECLARE_ALIGNED( uint8_t, tmp2[width*height], width ); \
\
mc_hv_w##width( src+(off1), i_src_stride, tmp1, width, i_height ); \
mc_hh_w##width( src+(off2), i_src_stride, tmp2, width, i_height ); \
x264_pixel_avg_w##width##_##cpu( dst, i_dst_stride, \
tmp1, width, tmp2, width, \
i_height ); \
}
/* mc C+H */
#define MC_CH( name, cpu, width, height, off ) \
static void name##_w##width##_##cpu( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_height ) \
{ \
DECLARE_ALIGNED( uint8_t, tmp1[width*height], width ); \
DECLARE_ALIGNED( uint8_t, tmp2[width*height], width ); \
\
mc_hc_w##width( src, i_src_stride, tmp1, width, i_height ); \
mc_hh_w##width( src+(off), i_src_stride, tmp2, width, i_height ); \
x264_pixel_avg_w##width##_##cpu( dst, i_dst_stride, \
tmp1, width, tmp2, width, \
i_height ); \
}
/* mc C+V */
#define MC_CV( name, cpu, width, height, off ) \
static void name##_w##width##_##cpu( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_height ) \
{ \
DECLARE_ALIGNED( uint8_t, tmp1[width*height], width ); \
DECLARE_ALIGNED( uint8_t, tmp2[width*height], width ); \
\
mc_hc_w##width( src, i_src_stride, tmp1, width, i_height ); \
mc_hv_w##width( src+(off), i_src_stride, tmp2, width, i_height ); \
x264_pixel_avg_w##width##_##cpu( dst, i_dst_stride, \
tmp1, width, tmp2, width, \
i_height ); \
}
/*****************************************************************************
* MC with width == 4 (height <= 8)
*****************************************************************************/
extern void x264_mc_copy_w4_mmxext( uint8_t *, int, uint8_t *, int, int );
static inline void mc_hh_w4( uint8_t *src, int i_src, uint8_t *dst, int i_dst, int i_height )
{
const int h4 = i_height / 4;
uint8_t srct[4*8*3];
uint64_t tmp[4];
int y;
src -= 2;
MMX_ZERO( %%mm7 );
MMX_INIT( %%mm6, x264_w0x10 );
for( y = 0; y < h4; y++ )
{
int i;