libpostproc.hg: postprocess_template.c comparison

comparison postprocess_template.c @ 112:d4d919ebc31c libpostproc

Convert asm keyword into __asm__. Neither the asm() nor the __asm__() keyword is part of the C99 standard, but while GCC accepts the former in C89 syntax, it is not accepted in C99 unless GNU extensions are turned on (with -fasm). The latter form is accepted in any syntax as an extension (without requiring further command-line options). Sun Studio C99 compiler also does not accept asm() while accepting __asm__(), albeit reporting warnings that it's not valid C99 syntax.

author	flameeyes
date	Thu, 16 Oct 2008 13:34:09 +0000
parents	83d51d1fb580
children	bf8f52662dc3

comparison

equal deleted inserted replaced

-:bf39174d9785
+:d4d919ebc31c
 * Check if the middle 8x8 Block in the given 8x16 block is flat
 */
 static inline int RENAME(vertClassify)(uint8_t src[], int stride, PPContext *c){
 int numEq= 0, dcOk;
 src+= stride*4; // src points to begin of the 8x8 Block
-asm volatile(
+__asm__ volatile(
 "movq %0, %%mm7                         \n\t"
 "movq %1, %%mm6                         \n\t"
 : : "m" (c->mmxDcOffset[c->nonBQP]),  "m" (c->mmxDcThreshold[c->nonBQP])
 );
-asm volatile(
+__asm__ volatile(
 "lea (%2, %3), %%"REG_a"                \n\t"
 //      0       1       2       3       4       5       6       7       8       9
 //      %1      eax     eax+%2  eax+2%2 %1+4%2  ecx     ecx+%2  ecx+2%2 %1+8%2  ecx+4%2
 "movq (%2), %%mm0                       \n\t"
 #ifndef HAVE_ALTIVEC
 static inline void RENAME(doVertLowPass)(uint8_t *src, int stride, PPContext *c)
 {
 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
 src+= stride*3;
-asm volatile(        //"movv %0 %1 %2\n\t"
+__asm__ volatile(        //"movv %0 %1 %2\n\t"
 "movq %2, %%mm0                         \n\t"  // QP,..., QP
 "pxor %%mm4, %%mm4                      \n\t"
 "movq (%0), %%mm6                       \n\t"
 "movq (%0, %1), %%mm5                   \n\t"
 static inline void RENAME(vertRK1Filter)(uint8_t *src, int stride, int QP)
 {
 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
 src+= stride*3;
 // FIXME rounding
-asm volatile(
+__asm__ volatile(
 "pxor %%mm7, %%mm7                      \n\t" // 0
 "movq "MANGLE(b80)", %%mm6              \n\t" // MIN_SIGNED_BYTE
 "leal (%0, %1), %%"REG_a"               \n\t"
 "leal (%%"REG_a", %1, 4), %%"REG_c"     \n\t"
 //      0       1       2       3       4       5       6       7       8       9
 static inline void RENAME(vertX1Filter)(uint8_t *src, int stride, PPContext *co)
 {
 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
 src+= stride*3;
-asm volatile(
+__asm__ volatile(
 "pxor %%mm7, %%mm7                      \n\t" // 0
 "lea (%0, %1), %%"REG_a"                \n\t"
 "lea (%%"REG_a", %1, 4), %%"REG_c"      \n\t"
 //      0       1       2       3       4       5       6       7       8       9
 //      %0      eax     eax+%1  eax+2%1 %0+4%1  ecx     ecx+%1  ecx+2%1 %0+8%1  ecx+4%1
 memcpy(tmp, src+stride*7, 8);
 memcpy(tmp+8, src+stride*8, 8);
 */
 src+= stride*4;
-asm volatile(
+__asm__ volatile(
 #if 0 //slightly more accurate and slightly slower
 "pxor %%mm7, %%mm7                      \n\t" // 0
 "lea (%0, %1), %%"REG_a"                \n\t"
 "lea (%%"REG_a", %1, 4), %%"REG_c"      \n\t"
 }
 }
 */
 #elif defined (HAVE_MMX)
 src+= stride*4;
-asm volatile(
+__asm__ volatile(
 "pxor %%mm7, %%mm7                      \n\t"
 "lea -40(%%"REG_SP"), %%"REG_c"         \n\t" // make space for 4 8-byte vars
 "and "ALIGN_MASK", %%"REG_c"            \n\t" // align
 //      0       1       2       3       4       5       6       7
 //      %0      %0+%1   %0+2%1  eax+2%1 %0+4%1  eax+4%1 edx+%1  edx+2%1
 #ifndef HAVE_ALTIVEC
 static inline void RENAME(dering)(uint8_t src[], int stride, PPContext *c)
 {
 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
-asm volatile(
+__asm__ volatile(
 "pxor %%mm6, %%mm6                      \n\t"
 "pcmpeqb %%mm7, %%mm7                   \n\t"
 "movq %2, %%mm0                         \n\t"
 "punpcklbw %%mm6, %%mm0                 \n\t"
 "psrlw $1, %%mm0                        \n\t"
 +2*(*(p     -1)) + 4*(*p         ) + 2*(*(p     +1))
 +(*(p+stride-1)) + 2*(*(p+stride)) + (*(p+stride+1));
 f= (f + 8)>>4;
 #ifdef DEBUG_DERING_THRESHOLD
-asm volatile("emms\n\t":);
+__asm__ volatile("emms\n\t":);
 {
 static long long numPixels=0;
 if(x!=1 && x!=8 && y!=1 && y!=8) numPixels++;
 //                    if((max-min)<20 || (max-min)*QP<200)
 //                    if((max-min)*QP < 500)
 */
 static inline void RENAME(deInterlaceInterpolateLinear)(uint8_t src[], int stride)
 {
 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
 src+= 4*stride;
-asm volatile(
+__asm__ volatile(
 "lea (%0, %1), %%"REG_a"                \n\t"
 "lea (%%"REG_a", %1, 4), %%"REG_c"      \n\t"
 //      0       1       2       3       4       5       6       7       8       9
 //      %0      eax     eax+%1  eax+2%1 %0+4%1  ecx     ecx+%1  ecx+2%1 %0+8%1  ecx+4%1
 */
 static inline void RENAME(deInterlaceInterpolateCubic)(uint8_t src[], int stride)
 {
 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
 src+= stride*3;
-asm volatile(
+__asm__ volatile(
 "lea (%0, %1), %%"REG_a"                \n\t"
 "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 "lea (%%"REG_d", %1, 4), %%"REG_c"      \n\t"
 "add %1, %%"REG_c"                      \n\t"
 "pxor %%mm7, %%mm7                      \n\t"
 */
 static inline void RENAME(deInterlaceFF)(uint8_t src[], int stride, uint8_t *tmp)
 {
 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
 src+= stride*4;
-asm volatile(
+__asm__ volatile(
 "lea (%0, %1), %%"REG_a"                \n\t"
 "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 "pxor %%mm7, %%mm7                      \n\t"
 "movq (%2), %%mm0                       \n\t"
 //      0       1       2       3       4       5       6       7       8       9       10
 */
 static inline void RENAME(deInterlaceL5)(uint8_t src[], int stride, uint8_t *tmp, uint8_t *tmp2)
 {
 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
 src+= stride*4;
-asm volatile(
+__asm__ volatile(
 "lea (%0, %1), %%"REG_a"                \n\t"
 "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 "pxor %%mm7, %%mm7                      \n\t"
 "movq (%2), %%mm0                       \n\t"
 "movq (%3), %%mm1                       \n\t"
 */
 static inline void RENAME(deInterlaceBlendLinear)(uint8_t src[], int stride, uint8_t *tmp)
 {
 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
 src+= 4*stride;
-asm volatile(
+__asm__ volatile(
 "lea (%0, %1), %%"REG_a"                \n\t"
 "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 //      0       1       2       3       4       5       6       7       8       9
 //      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1
 static inline void RENAME(deInterlaceMedian)(uint8_t src[], int stride)
 {
 #ifdef HAVE_MMX
 src+= 4*stride;
 #ifdef HAVE_MMX2
-asm volatile(
+__asm__ volatile(
 "lea (%0, %1), %%"REG_a"                \n\t"
 "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 //      0       1       2       3       4       5       6       7       8       9
 //      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1
 : : "r" (src), "r" ((long)stride)
 : "%"REG_a, "%"REG_d
 );
 #else // MMX without MMX2
-asm volatile(
+__asm__ volatile(
 "lea (%0, %1), %%"REG_a"                \n\t"
 "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t"
 //      0       1       2       3       4       5       6       7       8       9
 //      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1
 "pxor %%mm7, %%mm7                      \n\t"
 /**
 * transposes and shift the given 8x8 Block into dst1 and dst2
 */
 static inline void RENAME(transpose1)(uint8_t *dst1, uint8_t *dst2, uint8_t *src, int srcStride)
 {
-asm(
+__asm__(
 "lea (%0, %1), %%"REG_a"                \n\t"
 //      0       1       2       3       4       5       6       7       8       9
 //      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1
 "movq (%0), %%mm0                       \n\t" // 12345678
 "movq (%%"REG_a"), %%mm1                \n\t" // abcdefgh
 /**
 * transposes the given 8x8 block
 */
 static inline void RENAME(transpose2)(uint8_t *dst, int dstStride, uint8_t *src)
 {
-asm(
+__asm__(
 "lea (%0, %1), %%"REG_a"                \n\t"
 "lea (%%"REG_a",%1,4), %%"REG_d"        \n\t"
 //      0       1       2       3       4       5       6       7       8       9
 //      %0      eax     eax+%1  eax+2%1 %0+4%1  edx     edx+%1  edx+2%1 %0+8%1  edx+4%1
 "movq (%2), %%mm0                       \n\t" // 12345678
 tempBlurredPast[129]= maxNoise[2];
 #define FAST_L2_DIFF
 //#define L1_DIFF //u should change the thresholds too if u try that one
 #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
-asm volatile(
+__asm__ volatile(
 "lea (%2, %2, 2), %%"REG_a"             \n\t" // 3*stride
 "lea (%2, %2, 4), %%"REG_d"             \n\t" // 5*stride
 "lea (%%"REG_d", %2, 2), %%"REG_c"      \n\t" // 7*stride
 //      0       1       2       3       4       5       6       7       8       9
 //      %x      %x+%2   %x+2%2  %x+eax  %x+4%2  %x+edx  %x+2eax %x+ecx  %x+8%2
 static av_always_inline void RENAME(do_a_deblock)(uint8_t *src, int step, int stride, PPContext *c){
 int64_t dc_mask, eq_mask, both_masks;
 int64_t sums[10*8*2];
 src+= step*3; // src points to begin of the 8x8 Block
 //START_TIMER
-asm volatile(
+__asm__ volatile(
 "movq %0, %%mm7                         \n\t"
 "movq %1, %%mm6                         \n\t"
 : : "m" (c->mmxDcOffset[c->nonBQP]),  "m" (c->mmxDcThreshold[c->nonBQP])
 );
-asm volatile(
+__asm__ volatile(
 "lea (%2, %3), %%"REG_a"                \n\t"
 //      0       1       2       3       4       5       6       7       8       9
 //      %1      eax     eax+%2  eax+2%2 %1+4%2  ecx     ecx+%2  ecx+2%2 %1+8%2  ecx+4%2
 "movq (%2), %%mm0                       \n\t"
 if(both_masks){
 long offset= -8*step;
 int64_t *temp_sums= sums;
-asm volatile(
+__asm__ volatile(
 "movq %2, %%mm0                         \n\t"  // QP,..., QP
 "pxor %%mm4, %%mm4                      \n\t"
 "movq (%0), %%mm6                       \n\t"
 "movq (%0, %1), %%mm5                   \n\t"
 : "r" ((long)step), "m" (c->pQPb), "r"(sums), "g"(src)
 );
 src+= step; // src points to begin of the 8x8 Block
-asm volatile(
+__asm__ volatile(
 "movq %4, %%mm6                         \n\t"
 "pcmpeqb %%mm5, %%mm5                   \n\t"
 "pxor %%mm6, %%mm5                      \n\t"
 "pxor %%mm7, %%mm7                      \n\t"
 }else
 src+= step; // src points to begin of the 8x8 Block
 if(eq_mask != -1LL){
 uint8_t *temp_src= src;
-asm volatile(
+__asm__ volatile(
 "pxor %%mm7, %%mm7                      \n\t"
 "lea -40(%%"REG_SP"), %%"REG_c"         \n\t" // make space for 4 8-byte vars
 "and "ALIGN_MASK", %%"REG_c"            \n\t" // align
 //      0       1       2       3       4       5       6       7       8       9
 //      %0      eax     eax+%1  eax+2%1 %0+4%1  ecx     ecx+%1  ecx+2%1 %1+8%1  ecx+4%1
 #ifndef HAVE_MMX
 int i;
 #endif
 if(levelFix){
 #ifdef HAVE_MMX
-asm volatile(
+__asm__ volatile(
 "movq (%%"REG_a"), %%mm2        \n\t" // packedYOffset
 "movq 8(%%"REG_a"), %%mm3       \n\t" // packedYScale
 "lea (%2,%4), %%"REG_a"         \n\t"
 "lea (%3,%5), %%"REG_d"         \n\t"
 "pxor %%mm4, %%mm4              \n\t"
 memcpy( &(dst[dstStride*i]),
 &(src[srcStride*i]), BLOCK_SIZE);
 #endif //HAVE_MMX
 }else{
 #ifdef HAVE_MMX
-asm volatile(
+__asm__ volatile(
 "lea (%0,%2), %%"REG_a"                 \n\t"
 "lea (%1,%3), %%"REG_d"                 \n\t"
 #define REAL_SIMPLE_CPY(src1, src2, dst1, dst2)                              \
 "movq " #src1 ", %%mm0          \n\t"\
 * Duplicates the given 8 src pixels ? times upward
 */
 static inline void RENAME(duplicate)(uint8_t src[], int stride)
 {
 #ifdef HAVE_MMX
-asm volatile(
+__asm__ volatile(
 "movq (%0), %%mm0               \n\t"
 "add %1, %0                     \n\t"
 "movq %%mm0, (%0)               \n\t"
 "movq %%mm0, (%0, %1)           \n\t"
 "movq %%mm0, (%0, %1, 2)        \n\t"
 prefetchnta(srcBlock + (((x>>2)&6) + 6)*srcStride + 32);
 prefetcht0(dstBlock + (((x>>2)&6) + 5)*dstStride + 32);
 prefetcht0(dstBlock + (((x>>2)&6) + 6)*dstStride + 32);
 */
-asm(
+__asm__(
 "mov %4, %%"REG_a"              \n\t"
 "shr $2, %%"REG_a"              \n\t"
 "and $6, %%"REG_a"              \n\t"
 "add %5, %%"REG_a"              \n\t"
 "mov %%"REG_a", %%"REG_d"       \n\t"
 c.nonBQP= (c.nonBQP* QPCorrecture + 256*128)>>16;
 yHistogram[ srcBlock[srcStride*12 + 4] ]++;
 }
 c.QP= QP;
 #ifdef HAVE_MMX
-asm volatile(
+__asm__ volatile(
 "movd %1, %%mm7         \n\t"
 "packuswb %%mm7, %%mm7  \n\t" // 0, 0, 0, QP, 0, 0, 0, QP
 "packuswb %%mm7, %%mm7  \n\t" // 0,QP, 0, QP, 0,QP, 0, QP
 "packuswb %%mm7, %%mm7  \n\t" // QP,..., QP
 "movq %%mm7, %0         \n\t"
 prefetchnta(srcBlock + (((x>>2)&6) + 6)*srcStride + 32);
 prefetcht0(dstBlock + (((x>>2)&6) + 5)*dstStride + 32);
 prefetcht0(dstBlock + (((x>>2)&6) + 6)*dstStride + 32);
 */
-asm(
+__asm__(
 "mov %4, %%"REG_a"              \n\t"
 "shr $2, %%"REG_a"              \n\t"
 "and $6, %%"REG_a"              \n\t"
 "add %5, %%"REG_a"              \n\t"
 "mov %%"REG_a", %%"REG_d"       \n\t"
 + dstBlock[x +13*dstStride]
 + dstBlock[x +14*dstStride] + dstBlock[x +15*dstStride];
 }*/
 }
 #ifdef HAVE_3DNOW
-asm volatile("femms");
+__asm__ volatile("femms");
 #elif defined (HAVE_MMX)
-asm volatile("emms");
+__asm__ volatile("emms");
 #endif
 #ifdef DEBUG_BRIGHTNESS
 if(!isColor){
 int max=1;

Mercurial > libpostproc.hg

comparison postprocess_template.c @ 112:d4d919ebc31c libpostproc