blob: 095797b1ebdc1fc42602e363475407d09ba11d36 [file] [log] [blame]
/*
* Copyright (c) 2010 The VP8 project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license and patent
* grant that can be found in the LICENSE file in the root of the source
* tree. All contributing project authors may be found in the AUTHORS
* file in the root of the source tree.
*/
#include <math.h>
#include <stdlib.h>
#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