/* * Copyright (c) 2010 The WebM project authors. All Rights Reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include #include #include "vpx_scale/yv12config.h" #include "pragmas.h" #define VP8_FILTER_WEIGHT 128 #define VP8_FILTER_SHIFT 7 /* static constants */ __declspec(align(16)) const static short Blur[48] = { 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 64, 64, 64, 64, 64, 64, 64, 64, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, }; #define RD __declspec(align(16)) __int64 rd = 0x0040004000400040; #define R4D2 __declspec(align(16)) __int64 rd42[2] = {0x0004000400040004,0x0004000400040004}; #ifndef RELOCATEABLE const static RD; const static R4D2; #endif /* external references */ extern double vp8_gaussian(double sigma, double mu, double x); extern short vp8_rv[]; extern int vp8_q2mbl(int x) ; void vp8_post_proc_down_and_across_mmx ( unsigned char *src_ptr, unsigned char *dst_ptr, int src_pixels_per_line, int dst_pixels_per_line, int rows, int cols, int flimit ) { #ifdef RELOCATEABLE RD R4D2 #endif __asm { push ebx lea ebx, Blur movd mm2, flimit punpcklwd mm2, mm2 punpckldq mm2, mm2 mov esi, src_ptr mov edi, dst_ptr mov ecx, DWORD PTR rows mov eax, src_pixels_per_line ; destination pitch? pxor mm0, mm0 ; mm0 = 00000000 nextrow: xor edx, edx ; clear out edx for use as loop counter nextcol: pxor mm7, mm7 ; mm7 = 00000000 movq mm6, [ebx + 32 ] ; mm6 = kernel 2 taps movq mm3, [esi] ; mm4 = r0 p0..p7 punpcklbw mm3, mm0 ; mm3 = p0..p3 movq mm1, mm3 ; mm1 = p0..p3 pmullw mm3, mm6 ; mm3 *= kernel 2 modifiers movq mm6, [ebx + 48] ; mm6 = kernel 3 taps movq mm5, [esi + eax] ; mm4 = r1 p0..p7 punpcklbw mm5, mm0 ; mm5 = r1 p0..p3 pmullw mm6, mm5 ; mm6 *= p0..p3 * kernel 3 modifiers paddusw mm3, mm6 ; mm3 += mm6 ; thresholding movq mm7, mm1 ; mm7 = r0 p0..p3 psubusw mm7, mm5 ; mm7 = r0 p0..p3 - r1 p0..p3 psubusw mm5, mm1 ; mm5 = r1 p0..p3 - r0 p0..p3 paddusw mm7, mm5 ; mm7 = abs(r0 p0..p3 - r1 p0..p3) pcmpgtw mm7, mm2 movq mm6, [ebx + 64 ] ; mm6 = kernel 4 modifiers movq mm5, [esi + 2*eax] ; mm4 = r2 p0..p7 punpcklbw mm5, mm0 ; mm5 = r2 p0..p3 pmullw mm6, mm5 ; mm5 *= kernel 4 modifiers paddusw mm3, mm6 ; mm3 += mm5 ; thresholding movq mm6, mm1 ; mm6 = r0 p0..p3 psubusw mm6, mm5 ; mm6 = r0 p0..p3 - r2 p0..p3 psubusw mm5, mm1 ; mm5 = r2 p0..p3 - r2 p0..p3 paddusw mm6, mm5 ; mm6 = abs(r0 p0..p3 - r2 p0..p3) pcmpgtw mm6, mm2 por mm7, mm6 ; accumulate thresholds neg eax movq mm6, [ebx ] ; kernel 0 taps movq mm5, [esi+2*eax] ; mm4 = r-2 p0..p7 punpcklbw mm5, mm0 ; mm5 = r-2 p0..p3 pmullw mm6, mm5 ; mm5 *= kernel 0 modifiers paddusw mm3, mm6 ; mm3 += mm5 ; thresholding movq mm6, mm1 ; mm6 = r0 p0..p3 psubusw mm6, mm5 ; mm6 = p0..p3 - r-2 p0..p3 psubusw mm5, mm1 ; mm5 = r-2 p0..p3 - p0..p3 paddusw mm6, mm5 ; mm6 = abs(r0 p0..p3 - r-2 p0..p3) pcmpgtw mm6, mm2 por mm7, mm6 ; accumulate thresholds movq mm6, [ebx + 16] ; kernel 1 taps movq mm4, [esi+eax] ; mm4 = r-1 p0..p7 punpcklbw mm4, mm0 ; mm4 = r-1 p0..p3 pmullw mm6, mm4 ; mm4 *= kernel 1 modifiers. paddusw mm3, mm6 ; mm3 += mm5 ; thresholding movq mm6, mm1 ; mm6 = r0 p0..p3 psubusw mm6, mm4 ; mm6 = p0..p3 - r-2 p0..p3 psubusw mm4, mm1 ; mm5 = r-1 p0..p3 - p0..p3 paddusw mm6, mm4 ; mm6 = abs(r0 p0..p3 - r-1 p0..p3) pcmpgtw mm6, mm2 por mm7, mm6 ; accumulate thresholds paddusw mm3, rd ; mm3 += round value psraw mm3, VP8_FILTER_SHIFT ; mm3 /= 128 pand mm1, mm7 ; mm1 select vals > thresh from source pandn mm7, mm3 ; mm7 select vals < thresh from blurred result paddusw mm1, mm7 ; combination packuswb mm1, mm0 ; pack to bytes movd [edi], mm1 ; neg eax ; pitch is positive add esi, 4 add edi, 4 add edx, 4 cmp edx, cols jl nextcol // done with the all cols, start the across filtering in place sub esi, edx sub edi, edx push eax xor edx, edx mov eax, [edi-4]; acrossnextcol: pxor mm7, mm7 ; mm7 = 00000000 movq mm6, [ebx + 32 ] ; movq mm4, [edi+edx] ; mm4 = p0..p7 movq mm3, mm4 ; mm3 = p0..p7 punpcklbw mm3, mm0 ; mm3 = p0..p3 movq mm1, mm3 ; mm1 = p0..p3 pmullw mm3, mm6 ; mm3 *= kernel 2 modifiers movq mm6, [ebx + 48] psrlq mm4, 8 ; mm4 = p1..p7 movq mm5, mm4 ; mm5 = p1..p7 punpcklbw mm5, mm0 ; mm5 = p1..p4 pmullw mm6, mm5 ; mm6 *= p1..p4 * kernel 3 modifiers paddusw mm3, mm6 ; mm3 += mm6 ; thresholding movq mm7, mm1 ; mm7 = p0..p3 psubusw mm7, mm5 ; mm7 = p0..p3 - p1..p4 psubusw mm5, mm1 ; mm5 = p1..p4 - p0..p3 paddusw mm7, mm5 ; mm7 = abs(p0..p3 - p1..p4) pcmpgtw mm7, mm2 movq mm6, [ebx + 64 ] psrlq mm4, 8 ; mm4 = p2..p7 movq mm5, mm4 ; mm5 = p2..p7 punpcklbw mm5, mm0 ; mm5 = p2..p5 pmullw mm6, mm5 ; mm5 *= kernel 4 modifiers paddusw mm3, mm6 ; mm3 += mm5 ; thresholding movq mm6, mm1 ; mm6 = p0..p3 psubusw mm6, mm5 ; mm6 = p0..p3 - p1..p4 psubusw mm5, mm1 ; mm5 = p1..p4 - p0..p3 paddusw mm6, mm5 ; mm6 = abs(p0..p3 - p1..p4) pcmpgtw mm6, mm2 por mm7, mm6 ; accumulate thresholds movq mm6, [ebx ] movq mm4, [edi+edx-2] ; mm4 = p-2..p5 movq mm5, mm4 ; mm5 = p-2..p5 punpcklbw mm5, mm0 ; mm5 = p-2..p1 pmullw mm6, mm5 ; mm5 *= kernel 0 modifiers paddusw mm3, mm6 ; mm3 += mm5 ; thresholding movq mm6, mm1 ; mm6 = p0..p3 psubusw mm6, mm5 ; mm6 = p0..p3 - p1..p4 psubusw mm5, mm1 ; mm5 = p1..p4 - p0..p3 paddusw mm6, mm5 ; mm6 = abs(p0..p3 - p1..p4) pcmpgtw mm6, mm2 por mm7, mm6 ; accumulate thresholds movq mm6, [ebx + 16] psrlq mm4, 8 ; mm4 = p-1..p5 punpcklbw mm4, mm0 ; mm4 = p-1..p2 pmullw mm6, mm4 ; mm4 *= kernel 1 modifiers. paddusw mm3, mm6 ; mm3 += mm5 ; thresholding movq mm6, mm1 ; mm6 = p0..p3 psubusw mm6, mm4 ; mm6 = p0..p3 - p1..p4 psubusw mm4, mm1 ; mm5 = p1..p4 - p0..p3 paddusw mm6, mm4 ; mm6 = abs(p0..p3 - p1..p4) pcmpgtw mm6, mm2 por mm7, mm6 ; accumulate thresholds paddusw mm3, rd ; mm3 += round value psraw mm3, VP8_FILTER_SHIFT ; mm3 /= 128 pand mm1, mm7 ; mm1 select vals > thresh from source pandn mm7, mm3 ; mm7 select vals < thresh from blurred result paddusw mm1, mm7 ; combination packuswb mm1, mm0 ; pack to bytes mov DWORD PTR [edi+edx-4], eax ; store previous four bytes movd eax, mm1 add edx, 4 cmp edx, cols jl acrossnextcol; mov DWORD PTR [edi+edx-4], eax pop eax // done with this rwo add esi, eax ; next line mov eax, dst_pixels_per_line ; destination pitch? add edi, eax ; next destination mov eax, src_pixels_per_line ; destination pitch? dec ecx ; decrement count jnz nextrow ; next row pop ebx } } void vp8_post_proc_down_and_across_xmm ( unsigned char *src_ptr, unsigned char *dst_ptr, int src_pixels_per_line, int dst_pixels_per_line, int rows, int cols, int flimit ) { #ifdef RELOCATEABLE R4D2 #endif __asm { movd xmm2, flimit punpcklwd xmm2, xmm2 punpckldq xmm2, xmm2 punpcklqdq xmm2, xmm2 mov esi, src_ptr mov edi, dst_ptr mov ecx, DWORD PTR rows mov eax, src_pixels_per_line ; destination pitch? pxor xmm0, xmm0 ; mm0 = 00000000 nextrow: xor edx, edx ; clear out edx for use as loop counter nextcol: movq xmm3, QWORD PTR [esi] ; mm4 = r0 p0..p7 punpcklbw xmm3, xmm0 ; mm3 = p0..p3 movdqa xmm1, xmm3 ; mm1 = p0..p3 psllw xmm3, 2 ; movq xmm5, QWORD PTR [esi + eax] ; mm4 = r1 p0..p7 punpcklbw xmm5, xmm0 ; mm5 = r1 p0..p3 paddusw xmm3, xmm5 ; mm3 += mm6 ; thresholding movdqa xmm7, xmm1 ; mm7 = r0 p0..p3 psubusw xmm7, xmm5 ; mm7 = r0 p0..p3 - r1 p0..p3 psubusw xmm5, xmm1 ; mm5 = r1 p0..p3 - r0 p0..p3 paddusw xmm7, xmm5 ; mm7 = abs(r0 p0..p3 - r1 p0..p3) pcmpgtw xmm7, xmm2 movq xmm5, QWORD PTR [esi + 2*eax] ; mm4 = r2 p0..p7 punpcklbw xmm5, xmm0 ; mm5 = r2 p0..p3 paddusw xmm3, xmm5 ; mm3 += mm5 ; thresholding movdqa xmm6, xmm1 ; mm6 = r0 p0..p3 psubusw xmm6, xmm5 ; mm6 = r0 p0..p3 - r2 p0..p3 psubusw xmm5, xmm1 ; mm5 = r2 p0..p3 - r2 p0..p3 paddusw xmm6, xmm5 ; mm6 = abs(r0 p0..p3 - r2 p0..p3) pcmpgtw xmm6, xmm2 por xmm7, xmm6 ; accumulate thresholds neg eax movq xmm5, QWORD PTR [esi+2*eax] ; mm4 = r-2 p0..p7 punpcklbw xmm5, xmm0 ; mm5 = r-2 p0..p3 paddusw xmm3, xmm5 ; mm3 += mm5 ; thresholding movdqa xmm6, xmm1 ; mm6 = r0 p0..p3 psubusw xmm6, xmm5 ; mm6 = p0..p3 - r-2 p0..p3 psubusw xmm5, xmm1 ; mm5 = r-2 p0..p3 - p0..p3 paddusw xmm6, xmm5 ; mm6 = abs(r0 p0..p3 - r-2 p0..p3) pcmpgtw xmm6, xmm2 por xmm7, xmm6 ; accumulate thresholds movq xmm4, QWORD PTR [esi+eax] ; mm4 = r-1 p0..p7 punpcklbw xmm4, xmm0 ; mm4 = r-1 p0..p3 paddusw xmm3, xmm4 ; mm3 += mm5 ; thresholding movdqa xmm6, xmm1 ; mm6 = r0 p0..p3 psubusw xmm6, xmm4 ; mm6 = p0..p3 - r-2 p0..p3 psubusw xmm4, xmm1 ; mm5 = r-1 p0..p3 - p0..p3 paddusw xmm6, xmm4 ; mm6 = abs(r0 p0..p3 - r-1 p0..p3) pcmpgtw xmm6, xmm2 por xmm7, xmm6 ; accumulate thresholds paddusw xmm3, rd42 ; mm3 += round value psraw xmm3, 3 ; mm3 /= 8 pand xmm1, xmm7 ; mm1 select vals > thresh from source pandn xmm7, xmm3 ; mm7 select vals < thresh from blurred result paddusw xmm1, xmm7 ; combination packuswb xmm1, xmm0 ; pack to bytes movq QWORD PTR [edi], xmm1 ; neg eax ; pitch is positive add esi, 8 add edi, 8 add edx, 8 cmp edx, cols jl nextcol // done with the all cols, start the across filtering in place sub esi, edx sub edi, edx xor edx, edx movq mm0, QWORD PTR [edi-8]; acrossnextcol: movq xmm7, QWORD PTR [edi +edx -2] movd xmm4, DWORD PTR [edi +edx +6] pslldq xmm4, 8 por xmm4, xmm7 movdqa xmm3, xmm4 psrldq xmm3, 2 punpcklbw xmm3, xmm0 ; mm3 = p0..p3 movdqa xmm1, xmm3 ; mm1 = p0..p3 psllw xmm3, 2 movdqa xmm5, xmm4 psrldq xmm5, 3 punpcklbw xmm5, xmm0 ; mm5 = p1..p4 paddusw xmm3, xmm5 ; mm3 += mm6 ; thresholding movdqa xmm7, xmm1 ; mm7 = p0..p3 psubusw xmm7, xmm5 ; mm7 = p0..p3 - p1..p4 psubusw xmm5, xmm1 ; mm5 = p1..p4 - p0..p3 paddusw xmm7, xmm5 ; mm7 = abs(p0..p3 - p1..p4) pcmpgtw xmm7, xmm2 movdqa xmm5, xmm4 psrldq xmm5, 4 punpcklbw xmm5, xmm0 ; mm5 = p2..p5 paddusw xmm3, xmm5 ; mm3 += mm5 ; thresholding movdqa xmm6, xmm1 ; mm6 = p0..p3 psubusw xmm6, xmm5 ; mm6 = p0..p3 - p1..p4 psubusw xmm5, xmm1 ; mm5 = p1..p4 - p0..p3 paddusw xmm6, xmm5 ; mm6 = abs(p0..p3 - p1..p4) pcmpgtw xmm6, xmm2 por xmm7, xmm6 ; accumulate thresholds movdqa xmm5, xmm4 ; mm5 = p-2..p5 punpcklbw xmm5, xmm0 ; mm5 = p-2..p1 paddusw xmm3, xmm5 ; mm3 += mm5 ; thresholding movdqa xmm6, xmm1 ; mm6 = p0..p3 psubusw xmm6, xmm5 ; mm6 = p0..p3 - p1..p4 psubusw xmm5, xmm1 ; mm5 = p1..p4 - p0..p3 paddusw xmm6, xmm5 ; mm6 = abs(p0..p3 - p1..p4) pcmpgtw xmm6, xmm2 por xmm7, xmm6 ; accumulate thresholds psrldq xmm4, 1 ; mm4 = p-1..p5 punpcklbw xmm4, xmm0 ; mm4 = p-1..p2 paddusw xmm3, xmm4 ; mm3 += mm5 ; thresholding movdqa xmm6, xmm1 ; mm6 = p0..p3 psubusw xmm6, xmm4 ; mm6 = p0..p3 - p1..p4 psubusw xmm4, xmm1 ; mm5 = p1..p4 - p0..p3 paddusw xmm6, xmm4 ; mm6 = abs(p0..p3 - p1..p4) pcmpgtw xmm6, xmm2 por xmm7, xmm6 ; accumulate thresholds paddusw xmm3, rd42 ; mm3 += round value psraw xmm3, 3 ; mm3 /= 8 pand xmm1, xmm7 ; mm1 select vals > thresh from source pandn xmm7, xmm3 ; mm7 select vals < thresh from blurred result paddusw xmm1, xmm7 ; combination packuswb xmm1, xmm0 ; pack to bytes movq QWORD PTR [edi+edx-8], mm0 ; store previous four bytes movdq2q mm0, xmm1 add edx, 8 cmp edx, cols jl acrossnextcol; // last 8 pixels movq QWORD PTR [edi+edx-8], mm0 // done with this rwo add esi, eax ; next line mov eax, dst_pixels_per_line ; destination pitch? add edi, eax ; next destination mov eax, src_pixels_per_line ; destination pitch? dec ecx ; decrement count jnz nextrow ; next row } } void vp8_mbpost_proc_down_mmx(unsigned char *dst, int pitch, int rows, int cols, int flimit) { int c, i; __declspec(align(16)) int flimit2[2]; __declspec(align(16)) unsigned char d[16][8]; flimit = vp8_q2mbl(flimit); for (i = 0; i < 2; i++) flimit2[i] = flimit; rows += 8; for (c = 0; c < cols; c += 4) { unsigned char *s = &dst[c]; __asm { mov esi, s ; pxor mm0, mm0 ; mov eax, pitch ; neg eax // eax = -pitch lea esi, [esi + eax*8]; // edi = s[-pitch*8] neg eax pxor mm5, mm5 pxor mm6, mm6 ; pxor mm7, mm7 ; mov edi, esi mov ecx, 15 ; loop_initvar: movd mm1, DWORD PTR [edi]; punpcklbw mm1, mm0 ; paddw mm5, mm1 ; pmullw mm1, mm1 ; movq mm2, mm1 ; punpcklwd mm1, mm0 ; punpckhwd mm2, mm0 ; paddd mm6, mm1 ; paddd mm7, mm2 ; lea edi, [edi+eax] ; dec ecx jne loop_initvar //save the var and sum xor edx, edx loop_row: movd mm1, DWORD PTR [esi] // [s-pitch*8] movd mm2, DWORD PTR [edi] // [s+pitch*7] punpcklbw mm1, mm0 punpcklbw mm2, mm0 paddw mm5, mm2 psubw mm5, mm1 pmullw mm2, mm2 movq mm4, mm2 punpcklwd mm2, mm0 punpckhwd mm4, mm0 paddd mm6, mm2 paddd mm7, mm4 pmullw mm1, mm1 movq mm2, mm1 punpcklwd mm1, mm0 psubd mm6, mm1 punpckhwd mm2, mm0 psubd mm7, mm2 movq mm3, mm6 pslld mm3, 4 psubd mm3, mm6 movq mm1, mm5 movq mm4, mm5 pmullw mm1, mm1 pmulhw mm4, mm4 movq mm2, mm1 punpcklwd mm1, mm4 punpckhwd mm2, mm4 movq mm4, mm7 pslld mm4, 4 psubd mm4, mm7 psubd mm3, mm1 psubd mm4, mm2 psubd mm3, flimit2 psubd mm4, flimit2 psrad mm3, 31 psrad mm4, 31 packssdw mm3, mm4 packsswb mm3, mm0 movd mm1, DWORD PTR [esi+eax*8] movq mm2, mm1 punpcklbw mm1, mm0 paddw mm1, mm5 mov ecx, edx and ecx, 127 movq mm4, vp8_rv[ecx*2] paddw mm1, mm4 //paddw xmm1, eight8s psraw mm1, 4 packuswb mm1, mm0 pand mm1, mm3 pandn mm3, mm2 por mm1, mm3 and ecx, 15 movd DWORD PTR d[ecx*4], mm1 mov ecx, edx sub ecx, 8 and ecx, 15 movd mm1, DWORD PTR d[ecx*4] movd [esi], mm1 lea esi, [esi+eax] lea edi, [edi+eax] add edx, 1 cmp edx, rows jl loop_row } } } void vp8_mbpost_proc_down_xmm(unsigned char *dst, int pitch, int rows, int cols, int flimit) { int c, i; __declspec(align(16)) int flimit4[4]; __declspec(align(16)) unsigned char d[16][8]; flimit = vp8_q2mbl(flimit); for (i = 0; i < 4; i++) flimit4[i] = flimit; rows += 8; for (c = 0; c < cols; c += 8) { unsigned char *s = &dst[c]; __asm { mov esi, s ; pxor xmm0, xmm0 ; mov eax, pitch ; neg eax // eax = -pitch lea esi, [esi + eax*8]; // edi = s[-pitch*8] neg eax pxor xmm5, xmm5 pxor xmm6, xmm6 ; pxor xmm7, xmm7 ; mov edi, esi mov ecx, 15 ; loop_initvar: movq xmm1, QWORD PTR [edi]; punpcklbw xmm1, xmm0 ; paddw xmm5, xmm1 ; pmullw xmm1, xmm1 ; movdqa xmm2, xmm1 ; punpcklwd xmm1, xmm0 ; punpckhwd xmm2, xmm0 ; paddd xmm6, xmm1 ; paddd xmm7, xmm2 ; lea edi, [edi+eax] ; dec ecx jne loop_initvar //save the var and sum xor edx, edx loop_row: movq xmm1, QWORD PTR [esi] // [s-pitch*8] movq xmm2, QWORD PTR [edi] // [s+pitch*7] punpcklbw xmm1, xmm0 punpcklbw xmm2, xmm0 paddw xmm5, xmm2 psubw xmm5, xmm1 pmullw xmm2, xmm2 movdqa xmm4, xmm2 punpcklwd xmm2, xmm0 punpckhwd xmm4, xmm0 paddd xmm6, xmm2 paddd xmm7, xmm4 pmullw xmm1, xmm1 movdqa xmm2, xmm1 punpcklwd xmm1, xmm0 psubd xmm6, xmm1 punpckhwd xmm2, xmm0 psubd xmm7, xmm2 movdqa xmm3, xmm6 pslld xmm3, 4 psubd xmm3, xmm6 movdqa xmm1, xmm5 movdqa xmm4, xmm5 pmullw xmm1, xmm1 pmulhw xmm4, xmm4 movdqa xmm2, xmm1 punpcklwd xmm1, xmm4 punpckhwd xmm2, xmm4 movdqa xmm4, xmm7 pslld xmm4, 4 psubd xmm4, xmm7 psubd xmm3, xmm1 psubd xmm4, xmm2 psubd xmm3, flimit4 psubd xmm4, flimit4 psrad xmm3, 31 psrad xmm4, 31 packssdw xmm3, xmm4 packsswb xmm3, xmm0 movq xmm1, QWORD PTR [esi+eax*8] movq xmm2, xmm1 punpcklbw xmm1, xmm0 paddw xmm1, xmm5 mov ecx, edx and ecx, 127 movdqu xmm4, vp8_rv[ecx*2] paddw xmm1, xmm4 //paddw xmm1, eight8s psraw xmm1, 4 packuswb xmm1, xmm0 pand xmm1, xmm3 pandn xmm3, xmm2 por xmm1, xmm3 and ecx, 15 movq QWORD PTR d[ecx*8], xmm1 mov ecx, edx sub ecx, 8 and ecx, 15 movq mm0, d[ecx*8] movq [esi], mm0 lea esi, [esi+eax] lea edi, [edi+eax] add edx, 1 cmp edx, rows jl loop_row } } } #if 0 /**************************************************************************** * * ROUTINE : plane_add_noise_wmt * * INPUTS : unsigned char *Start starting address of buffer to add gaussian * noise to * unsigned int Width width of plane * unsigned int Height height of plane * int Pitch distance between subsequent lines of frame * int q quantizer used to determine amount of noise * to add * * OUTPUTS : None. * * RETURNS : void. * * FUNCTION : adds gaussian noise to a plane of pixels * * SPECIAL NOTES : None. * ****************************************************************************/ void vp8_plane_add_noise_wmt(unsigned char *Start, unsigned int Width, unsigned int Height, int Pitch, int q, int a) { unsigned int i; __declspec(align(16)) unsigned char blackclamp[16]; __declspec(align(16)) unsigned char whiteclamp[16]; __declspec(align(16)) unsigned char bothclamp[16]; char char_dist[300]; char Rand[2048]; double sigma; // return; __asm emms sigma = a + .5 + .6 * (63 - q) / 63.0; // set up a lookup table of 256 entries that matches // a gaussian distribution with sigma determined by q. // { double i; int next, j; next = 0; for (i = -32; i < 32; i++) { double g = 256 * vp8_gaussian(sigma, 0, 1.0 * i); int a = (int)(g + .5); if (a) { for (j = 0; j < a; j++) { char_dist[next+j] = (char) i; } next = next + j; } } for (next = next; next < 256; next++) char_dist[next] = 0; } for (i = 0; i < 2048; i++) { Rand[i] = char_dist[rand() & 0xff]; } for (i = 0; i < 16; i++) { blackclamp[i] = -char_dist[0]; whiteclamp[i] = -char_dist[0]; bothclamp[i] = -2 * char_dist[0]; } for (i = 0; i < Height; i++) { unsigned char *Pos = Start + i * Pitch; char *Ref = Rand + (rand() & 0xff); __asm { mov ecx, [Width] mov esi, Pos mov edi, Ref xor eax, eax nextset: movdqu xmm1, [esi+eax] // get the source psubusb xmm1, blackclamp // clamp both sides so we don't outrange adding noise paddusb xmm1, bothclamp psubusb xmm1, whiteclamp movdqu xmm2, [edi+eax] // get the noise for this line paddb xmm1, xmm2 // add it in movdqu [esi+eax], xmm1 // store the result add eax, 16 // move to the next line cmp eax, ecx jl nextset } } } #endif __declspec(align(16)) static const int four8s[4] = { 8, 8, 8, 8}; void vp8_mbpost_proc_across_ip_xmm(unsigned char *src, int pitch, int rows, int cols, int flimit) { int r, i; __declspec(align(16)) int flimit4[4]; unsigned char *s = src; int sumsq; int sum; flimit = vp8_q2mbl(flimit); flimit4[0] = flimit4[1] = flimit4[2] = flimit4[3] = flimit; for (r = 0; r < rows; r++) { sumsq = 0; sum = 0; for (i = -8; i <= 6; i++) { sumsq += s[i] * s[i]; sum += s[i]; } __asm { mov eax, sumsq movd xmm7, eax mov eax, sum movd xmm6, eax mov esi, s xor ecx, ecx mov edx, cols add edx, 8 pxor mm0, mm0 pxor mm1, mm1 pxor xmm0, xmm0 nextcol4: movd xmm1, DWORD PTR [esi+ecx-8] // -8 -7 -6 -5 movd xmm2, DWORD PTR [esi+ecx+7] // +7 +8 +9 +10 punpcklbw xmm1, xmm0 // expanding punpcklbw xmm2, xmm0 // expanding punpcklwd xmm1, xmm0 // expanding to dwords punpcklwd xmm2, xmm0 // expanding to dwords psubd xmm2, xmm1 // 7--8 8--7 9--6 10--5 paddd xmm1, xmm1 // -8*2 -7*2 -6*2 -5*2 paddd xmm1, xmm2 // 7+-8 8+-7 9+-6 10+-5 pmaddwd xmm1, xmm2 // squared of 7+-8 8+-7 9+-6 10+-5 paddd xmm6, xmm2 paddd xmm7, xmm1 pshufd xmm6, xmm6, 0 // duplicate the last ones pshufd xmm7, xmm7, 0 // duplicate the last ones psrldq xmm1, 4 // 8--7 9--6 10--5 0000 psrldq xmm2, 4 // 8--7 9--6 10--5 0000 pshufd xmm3, xmm1, 3 // 0000 8--7 8--7 8--7 squared pshufd xmm4, xmm2, 3 // 0000 8--7 8--7 8--7 squared paddd xmm6, xmm4 paddd xmm7, xmm3 pshufd xmm3, xmm1, 01011111b // 0000 0000 9--6 9--6 squared pshufd xmm4, xmm2, 01011111b // 0000 0000 9--6 9--6 squared paddd xmm7, xmm3 paddd xmm6, xmm4 pshufd xmm3, xmm1, 10111111b // 0000 0000 8--7 8--7 squared pshufd xmm4, xmm2, 10111111b // 0000 0000 8--7 8--7 squared paddd xmm7, xmm3 paddd xmm6, xmm4 movdqa xmm3, xmm6 pmaddwd xmm3, xmm3 movdqa xmm5, xmm7 pslld xmm5, 4 psubd xmm5, xmm7 psubd xmm5, xmm3 psubd xmm5, flimit4 psrad xmm5, 31 packssdw xmm5, xmm0 packsswb xmm5, xmm0 movd xmm1, DWORD PTR [esi+ecx] movq xmm2, xmm1 punpcklbw xmm1, xmm0 punpcklwd xmm1, xmm0 paddd xmm1, xmm6 paddd xmm1, four8s psrad xmm1, 4 packssdw xmm1, xmm0 packuswb xmm1, xmm0 pand xmm1, xmm5 pandn xmm5, xmm2 por xmm5, xmm1 movd [esi+ecx-8], mm0 movq mm0, mm1 movdq2q mm1, xmm5 psrldq xmm7, 12 psrldq xmm6, 12 add ecx, 4 cmp ecx, edx jl nextcol4 } s += pitch; } } #if 0 /**************************************************************************** * * ROUTINE : plane_add_noise_mmx * * INPUTS : unsigned char *Start starting address of buffer to add gaussian * noise to * unsigned int Width width of plane * unsigned int Height height of plane * int Pitch distance between subsequent lines of frame * int q quantizer used to determine amount of noise * to add * * OUTPUTS : None. * * RETURNS : void. * * FUNCTION : adds gaussian noise to a plane of pixels * * SPECIAL NOTES : None. * ****************************************************************************/ void vp8_plane_add_noise_mmx(unsigned char *Start, unsigned int Width, unsigned int Height, int Pitch, int q, int a) { unsigned int i; int Pitch4 = Pitch * 4; const int noise_amount = 2; const int noise_adder = 2 * noise_amount + 1; __declspec(align(16)) unsigned char blackclamp[16]; __declspec(align(16)) unsigned char whiteclamp[16]; __declspec(align(16)) unsigned char bothclamp[16]; char char_dist[300]; char Rand[2048]; double sigma; __asm emms sigma = a + .5 + .6 * (63 - q) / 63.0; // set up a lookup table of 256 entries that matches // a gaussian distribution with sigma determined by q. // { double i, sum = 0; int next, j; next = 0; for (i = -32; i < 32; i++) { int a = (int)(.5 + 256 * vp8_gaussian(sigma, 0, i)); if (a) { for (j = 0; j < a; j++) { char_dist[next+j] = (char) i; } next = next + j; } } for (next = next; next < 256; next++) char_dist[next] = 0; } for (i = 0; i < 2048; i++) { Rand[i] = char_dist[rand() & 0xff]; } for (i = 0; i < 16; i++) { blackclamp[i] = -char_dist[0]; whiteclamp[i] = -char_dist[0]; bothclamp[i] = -2 * char_dist[0]; } for (i = 0; i < Height; i++) { unsigned char *Pos = Start + i * Pitch; char *Ref = Rand + (rand() & 0xff); __asm { mov ecx, [Width] mov esi, Pos mov edi, Ref xor eax, eax nextset: movq mm1, [esi+eax] // get the source psubusb mm1, blackclamp // clamp both sides so we don't outrange adding noise paddusb mm1, bothclamp psubusb mm1, whiteclamp movq mm2, [edi+eax] // get the noise for this line paddb mm1, mm2 // add it in movq [esi+eax], mm1 // store the result add eax, 8 // move to the next line cmp eax, ecx jl nextset } } } #else extern char an[8][64][3072]; extern int cd[8][64]; void vp8_plane_add_noise_mmx(unsigned char *Start, unsigned int Width, unsigned int Height, int Pitch, int q, int a) { unsigned int i; __declspec(align(16)) unsigned char blackclamp[16]; __declspec(align(16)) unsigned char whiteclamp[16]; __declspec(align(16)) unsigned char bothclamp[16]; __asm emms for (i = 0; i < 16; i++) { blackclamp[i] = -cd[a][q]; whiteclamp[i] = -cd[a][q]; bothclamp[i] = -2 * cd[a][q]; } for (i = 0; i < Height; i++) { unsigned char *Pos = Start + i * Pitch; char *Ref = an[a][q] + (rand() & 0xff); __asm { mov ecx, [Width] mov esi, Pos mov edi, Ref xor eax, eax nextset: movq mm1, [esi+eax] // get the source psubusb mm1, blackclamp // clamp both sides so we don't outrange adding noise paddusb mm1, bothclamp psubusb mm1, whiteclamp movq mm2, [edi+eax] // get the noise for this line paddb mm1, mm2 // add it in movq [esi+eax], mm1 // store the result add eax, 8 // move to the next line cmp eax, ecx jl nextset } } } void vp8_plane_add_noise_wmt(unsigned char *Start, unsigned int Width, unsigned int Height, int Pitch, int q, int a) { unsigned int i; __declspec(align(16)) unsigned char blackclamp[16]; __declspec(align(16)) unsigned char whiteclamp[16]; __declspec(align(16)) unsigned char bothclamp[16]; __asm emms for (i = 0; i < 16; i++) { blackclamp[i] = -cd[a][q]; whiteclamp[i] = -cd[a][q]; bothclamp[i] = -2 * cd[a][q]; } for (i = 0; i < Height; i++) { unsigned char *Pos = Start + i * Pitch; char *Ref = an[a][q] + (rand() & 0xff); __asm { mov ecx, [Width] mov esi, Pos mov edi, Ref xor eax, eax nextset: movdqu xmm1, [esi+eax] // get the source psubusb xmm1, blackclamp // clamp both sides so we don't outrange adding noise paddusb xmm1, bothclamp psubusb xmm1, whiteclamp movdqu xmm2, [edi+eax] // get the noise for this line paddb xmm1, xmm2 // add it in movdqu [esi+eax], xmm1 // store the result add eax, 16 // move to the next line cmp eax, ecx jl nextset } } } #endif