#ifndef __MUTILS__ #define __MUTILS__ #include "Mmx.h" #include "Sse.h" #include "Sse2.h" #include #include #include #include #include #include // memcpy, memset #include // sqrt #include #include #include #include static int WithMmxSseUse= 0; void MSetWithMmxSseUse(int w); int MWithMmxSseUse(); double MTime(); double MTime2(); // ***************************** CPU informations ***************************** #define M_MM_ACCEL_MLIB 0x00000001 #define M_MM_ACCEL_X86_MMX 0x80000000 #define M_MM_ACCEL_X86_3DNOW 0x40000000 #define M_MM_ACCEL_X86_MMXEXT 0x20000000 // MMXEXT is SSE int MCpuid(); void Memms(); // Check if char, short, int, float, double are 8, 16, 32, 32, 64 bits // Check if mmx and sse are both available void MCheckCpu(); #ifdef ARCH_X86 static sse_t sse_mask000f, sse_maskfff0, sse_mask0ff0; #endif // They allow simple MMX conversion index-coordinate of image point. const int MxStride= 1024, MxShift= 10, MxMask= 0x3ff; // maximal x-image size inline int* MAlign16ByteNew(int NbInt) { // usefull for SSE int *P= new int[NbInt+4], *AlignedP=(int*)((int(P)+16)&(~15)); AlignedP[-1]= P-AlignedP; return AlignedP; } inline void MAlign16ByteDelete(int* AlignedP) { // usefull for SSE int *P= AlignedP+AlignedP[-1]; delete[] P; } //--------------------------------------------------------------------------------------------- // Max, Min, Swap //--------------------------------------------------------------------------------------------- template inline T Max(T a, T b) { return (a inline T Max(T a, T b, T c) { return ((a inline T Min(T a, T b) { return (a>b)? b:a; } template inline T Abs(T a) { return (a>0)? a: -a; } template inline void Swap(T& a, T& b) { T c= a; a=b; b=c; } int MExists(const char* FileName); const char* MExistingFileName(const char* PrefixSuffix, int Number); //--------------------------------------------------------------------------------------------- // Fonctions stats de base //--------------------------------------------------------------------------------------------- float CalcMoyenne(float *Tab,int n); float CalcEcartType(float *Tab,int n); float CalcEcartType(float *Tab,float Moy,int n); float CalcVariance(float *Tab,int n); float CalcVariance(float *Tab,float Moy,int n); float CalcMediane(float *Tab,int n); //--------------------------------------------------------------------------------------------- // Distance Euclidienne //--------------------------------------------------------------------------------------------- inline float DistEucl(float x1,float y1,float x2,float y2) { return sqrt( (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2) ); } // **************** convert yuv to rgb for 16 bit screen using MMX ************ /* These conversion functions are from the GNU mpeg2dec source. * Copyright (C) 2000-2001 Silicon Integrated System Corp. * All Rights Reserved. * Author: Olie Lho */ static inline void mmx_yuv2rgb (uint8_t *py, uint8_t *pu, uint8_t *pv) { static mmx_t mmx_80w = {0x0080008000800080ull}; static mmx_t mmx_U_green = {0xf37df37df37df37dull}; static mmx_t mmx_U_blue = {0x4093409340934093ull}; static mmx_t mmx_V_red = {0x3312331233123312ull}; static mmx_t mmx_V_green = {0xe5fce5fce5fce5fcull}; static mmx_t mmx_10w = {0x1010101010101010ull}; static mmx_t mmx_00ffw = {0x00ff00ff00ff00ffull}; static mmx_t mmx_Y_coeff = {0x253f253f253f253full}; movd_m2r (*pu, mm0); // mm0 = 00 00 00 00 u3 u2 u1 u0 movd_m2r (*pv, mm1); // mm1 = 00 00 00 00 v3 v2 v1 v0 movq_m2r (*py, mm6); // mm6 = Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0 pxor_r2r (mm4, mm4); // mm4 = 0 /* XXX might do cache preload for image here */ /* * Do the multiply part of the conversion for even and odd pixels * register usage: * mm0 -> Cblue, mm1 -> Cred, mm2 -> Cgreen even pixels * mm3 -> Cblue, mm4 -> Cred, mm5 -> Cgreen odd pixels * mm6 -> Y even, mm7 -> Y odd */ punpcklbw_r2r (mm4, mm0); // mm0 = u3 u2 u1 u0 punpcklbw_r2r (mm4, mm1); // mm1 = v3 v2 v1 v0 psubsw_m2r (mmx_80w, mm0); // u -= 128 psubsw_m2r (mmx_80w, mm1); // v -= 128 psllw_i2r (3, mm0); // promote precision psllw_i2r (3, mm1); // promote precision movq_r2r (mm0, mm2); // mm2 = u3 u2 u1 u0 movq_r2r (mm1, mm3); // mm3 = v3 v2 v1 v0 pmulhw_m2r (mmx_U_green, mm2); // mm2 = u * u_green pmulhw_m2r (mmx_V_green, mm3); // mm3 = v * v_green pmulhw_m2r (mmx_U_blue, mm0); // mm0 = chroma_b pmulhw_m2r (mmx_V_red, mm1); // mm1 = chroma_r paddsw_r2r (mm3, mm2); // mm2 = chroma_g psubusb_m2r (mmx_10w, mm6); // Y -= 16 movq_r2r (mm6, mm7); // mm7 = Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0 pand_m2r (mmx_00ffw, mm6); // mm6 = Y6 Y4 Y2 Y0 psrlw_i2r (8, mm7); // mm7 = Y7 Y5 Y3 Y1 psllw_i2r (3, mm6); // promote precision psllw_i2r (3, mm7); // promote precision pmulhw_m2r (mmx_Y_coeff, mm6); // mm6 = luma_rgb even pmulhw_m2r (mmx_Y_coeff, mm7); // mm7 = luma_rgb odd /* * Do the addition part of the conversion for even and odd pixels * register usage: * mm0 -> Cblue, mm1 -> Cred, mm2 -> Cgreen even pixels * mm3 -> Cblue, mm4 -> Cred, mm5 -> Cgreen odd pixels * mm6 -> Y even, mm7 -> Y odd */ movq_r2r (mm0, mm3); // mm3 = chroma_b movq_r2r (mm1, mm4); // mm4 = chroma_r movq_r2r (mm2, mm5); // mm5 = chroma_g paddsw_r2r (mm6, mm0); // mm0 = B6 B4 B2 B0 paddsw_r2r (mm7, mm3); // mm3 = B7 B5 B3 B1 paddsw_r2r (mm6, mm1); // mm1 = R6 R4 R2 R0 paddsw_r2r (mm7, mm4); // mm4 = R7 R5 R3 R1 paddsw_r2r (mm6, mm2); // mm2 = G6 G4 G2 G0 paddsw_r2r (mm7, mm5); // mm5 = G7 G5 G3 G1 packuswb_r2r (mm0, mm0); // saturate to 0-255 packuswb_r2r (mm1, mm1); // saturate to 0-255 packuswb_r2r (mm2, mm2); // saturate to 0-255 packuswb_r2r (mm3, mm3); // saturate to 0-255 packuswb_r2r (mm4, mm4); // saturate to 0-255 packuswb_r2r (mm5, mm5); // saturate to 0-255 punpcklbw_r2r (mm3, mm0); // mm0 = B7 B6 B5 B4 B3 B2 B1 B0 punpcklbw_r2r (mm4, mm1); // mm1 = R7 R6 R5 R4 R3 R2 R1 R0 punpcklbw_r2r (mm5, mm2); // mm2 = G7 G6 G5 G4 G3 G2 G1 G0 } static inline void mmx_unpack_16rgb (uint8_t *image, int cpu) { static mmx_t mmx_bluemask = {0xf8f8f8f8f8f8f8f8ull}; static mmx_t mmx_greenmask = {0xfcfcfcfcfcfcfcfcull}; static mmx_t mmx_redmask = {0xf8f8f8f8f8f8f8f8ull}; /* * convert RGB plane to RGB 16 bits * mm0 -> B, mm1 -> R, mm2 -> G * mm4 -> GB, mm5 -> AR pixel 4-7 * mm6 -> GB, mm7 -> AR pixel 0-3 */ pand_m2r (mmx_bluemask, mm0); // mm0 = b7b6b5b4b3______ pand_m2r (mmx_greenmask, mm2); // mm2 = g7g6g5g4g3g2____ pand_m2r (mmx_redmask, mm1); // mm1 = r7r6r5r4r3______ psrlq_i2r (3, mm0); // mm0 = ______b7b6b5b4b3 pxor_r2r (mm4, mm4); // mm4 = 0 movq_r2r (mm0, mm5); // mm5 = ______b7b6b5b4b3 movq_r2r (mm2, mm7); // mm7 = g7g6g5g4g3g2____ punpcklbw_r2r (mm4, mm2); punpcklbw_r2r (mm1, mm0); psllq_i2r (3, mm2); por_r2r (mm2, mm0); #ifdef __WITH_MOVNTQ_ movntq (mm0, *image); #else movq_r2m (mm0, *image); #endif punpckhbw_r2r (mm4, mm7); punpckhbw_r2r (mm1, mm5); psllq_i2r (3, mm7); por_r2r (mm7, mm5); #ifdef __WITH_MOVNTQ_ movntq (mm5, *(image+8)); #else movq_r2m (mm5, *(image+8)); #endif } static inline void yuv420_rgb16 (uint8_t * image, uint8_t * py, uint8_t * pu, uint8_t * pv, int width, int height, int rgb_stride, int y_stride, int uv_stride, int cpu) { int i; rgb_stride -= 2 * width; y_stride -= width; uv_stride -= width >> 1; width >>= 3; do { i = width; do { mmx_yuv2rgb (py, pu, pv); mmx_unpack_16rgb (image, cpu); py += 8; pu += 4; pv += 4; image += 16; } while (--i); py += y_stride; image += rgb_stride; if (height & 1) { pu += uv_stride; pv += uv_stride; } else { pu -= 4 * width; pv -= 4 * width; } } while (--height); } #endif