void MV_8BitReverbFast(const char *src, char *dest, int count, int shift) {
  int i;
  unsigned char sh = 0x80 - (0x80 >> shift);
  for (i = 0; i < count; i++) {
    unsigned char a = ((unsigned char)src[i]) >> shift;
    unsigned char c = (((unsigned char)src[i]) ^ 0x80) >> 7;
    dest[i] = (signed char)(a + sh + c);
  }
}


x86 assembly (clang, -O0):
<MV_8BitReverbFast>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x18(%rbp),%ecx
mov    $0x80,%eax
sar    %cl,%eax
mov    %eax,%ecx
mov    $0x80,%eax
sub    %ecx,%eax
mov    %al,-0x1d(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1191 <MV_8BitReverbFast+0x91>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%ecx
sar    %cl,%eax
mov    %al,-0x1e(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
xor    $0x80,%eax
sar    $0x7,%eax
mov    %al,-0x1f(%rbp)
movzbl -0x1e(%rbp),%eax
movzbl -0x1d(%rbp),%ecx
add    %ecx,%eax
movzbl -0x1f(%rbp),%ecx
add    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112f <MV_8BitReverbFast+0x2f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<MV_8BitReverbFast>:
push   %rbx
mov    $0x80,%r9d
mov    $0x80,%eax
shr    %cl,%eax
test   %edx,%edx
jle    11a5 <MV_8BitReverbFast+0xa5>
sub    %eax,%r9d
mov    %edx,%r8d
cmp    $0x8,%edx
jb     1133 <MV_8BitReverbFast+0x33>
lea    (%rdi,%r8,1),%rax
cmp    %rsi,%rax
jbe    11a7 <MV_8BitReverbFast+0xa7>
lea    (%rsi,%r8,1),%rax
cmp    %rdi,%rax
jbe    11a7 <MV_8BitReverbFast+0xa7>
xor    %ebx,%ebx
mov    %rbx,%r10
not    %r10
test   $0x1,%r8b
je     115f <MV_8BitReverbFast+0x5f>
movzbl (%rdi,%rbx,1),%r11d
mov    %r11d,%eax
shr    %cl,%eax
not    %r11b
shr    $0x7,%r11b
add    %r9d,%eax
add    %r11b,%al
mov    %al,(%rsi,%rbx,1)
or     $0x1,%rbx
add    %r8,%r10
je     11a5 <MV_8BitReverbFast+0xa5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rdi,%rbx,1),%edx
mov    %edx,%eax
shr    %cl,%eax
not    %dl
shr    $0x7,%dl
add    %r9d,%eax
add    %dl,%al
mov    %al,(%rsi,%rbx,1)
movzbl 0x1(%rdi,%rbx,1),%eax
mov    %eax,%edx
shr    %cl,%edx
not    %al
shr    $0x7,%al
add    %r9d,%edx
add    %al,%dl
mov    %dl,0x1(%rsi,%rbx,1)
add    $0x2,%rbx
cmp    %rbx,%r8
jne    1170 <MV_8BitReverbFast+0x70>
pop    %rbx
ret
movd   %ecx,%xmm9
movd   %r9d,%xmm8
cmp    $0x10,%edx
jae    1257 <MV_8BitReverbFast+0x157>
xor    %ebx,%ebx
mov    %rbx,%rax
mov    %r8d,%ebx
and    $0xfffffff8,%ebx
pshufd $0x0,%xmm8,%xmm0
pxor   %xmm1,%xmm1
pxor   %xmm2,%xmm2
movss  %xmm9,%xmm2
pcmpeqd %xmm8,%xmm8
movdqa 0xe1b(%rip),%xmm4
movdqa 0xe23(%rip),%xmm5
nopl   (%rax)
movq   (%rdi,%rax,1),%xmm3
movdqa %xmm3,%xmm6
punpcklbw %xmm1,%xmm6
movdqa %xmm6,%xmm7
punpckhwd %xmm1,%xmm6
psrld  %xmm2,%xmm6
punpcklwd %xmm1,%xmm7
psrld  %xmm2,%xmm7
pxor   %xmm8,%xmm3
psrlw  $0x7,%xmm3
pand   %xmm4,%xmm3
paddd  %xmm0,%xmm7
paddd  %xmm0,%xmm6
pand   %xmm5,%xmm6
pand   %xmm5,%xmm7
packuswb %xmm6,%xmm7
packuswb %xmm7,%xmm7
paddb  %xmm3,%xmm7
movq   %xmm7,(%rsi,%rax,1)
add    $0x8,%rax
cmp    %rax,%rbx
jne    11f0 <MV_8BitReverbFast+0xf0>
cmp    %r8,%rbx
jne    1135 <MV_8BitReverbFast+0x35>
jmp    11a5 <MV_8BitReverbFast+0xa5>
mov    %r8d,%ebx
and    $0xfffffff0,%ebx
pshufd $0x0,%xmm8,%xmm2
lea    -0x10(%rbx),%rax
mov    %rax,%r10
shr    $0x4,%r10
add    $0x1,%r10
test   %rax,%rax
je     1484 <MV_8BitReverbFast+0x384>
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
xor    %eax,%eax
pxor   %xmm3,%xmm3
xorps  %xmm4,%xmm4
movss  %xmm9,%xmm4
pcmpeqd %xmm10,%xmm10
movdqa 0xd62(%rip),%xmm11
movdqa 0xd69(%rip),%xmm12
nopw   0x0(%rax,%rax,1)
movdqu (%rdi,%rax,1),%xmm5
movdqa %xmm5,%xmm1
punpcklbw %xmm3,%xmm1
movdqa %xmm1,%xmm0
punpckhwd %xmm3,%xmm1
movdqa %xmm5,%xmm6
punpckhbw %xmm3,%xmm6
movdqa %xmm6,%xmm7
punpcklwd %xmm3,%xmm7
punpckhwd %xmm3,%xmm6
psrld  %xmm4,%xmm6
psrld  %xmm4,%xmm7
psrld  %xmm4,%xmm1
punpcklwd %xmm3,%xmm0
psrld  %xmm4,%xmm0
pxor   %xmm10,%xmm5
psrlw  $0x7,%xmm5
pand   %xmm11,%xmm5
paddd  %xmm2,%xmm0
paddd  %xmm2,%xmm1
paddd  %xmm2,%xmm7
paddd  %xmm2,%xmm6
pand   %xmm12,%xmm6
pand   %xmm12,%xmm7
packuswb %xmm6,%xmm7
pand   %xmm12,%xmm1
pand   %xmm12,%xmm0
packuswb %xmm1,%xmm0
packuswb %xmm7,%xmm0
paddb  %xmm5,%xmm0
movdqu %xmm0,(%rsi,%rax,1)
movdqu 0x10(%rdi,%rax,1),%xmm1
movdqa %xmm1,%xmm5
punpcklbw %xmm3,%xmm5
movdqa %xmm5,%xmm0
punpcklwd %xmm3,%xmm0
punpckhwd %xmm3,%xmm5
movdqa %xmm1,%xmm7
punpckhbw %xmm3,%xmm7
movdqa %xmm7,%xmm6
punpcklwd %xmm3,%xmm6
punpckhwd %xmm3,%xmm7
psrld  %xmm4,%xmm7
psrld  %xmm4,%xmm6
psrld  %xmm4,%xmm5
psrld  %xmm4,%xmm0
pxor   %xmm10,%xmm1
psrlw  $0x7,%xmm1
pand   %xmm11,%xmm1
paddd  %xmm2,%xmm0
paddd  %xmm2,%xmm5
paddd  %xmm2,%xmm6
paddd  %xmm2,%xmm7
pand   %xmm12,%xmm7
pand   %xmm12,%xmm6
packuswb %xmm7,%xmm6
pand   %xmm12,%xmm5
pand   %xmm12,%xmm0
packuswb %xmm5,%xmm0
packuswb %xmm6,%xmm0
paddb  %xmm1,%xmm0
movdqu %xmm0,0x10(%rsi,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%r11
jne    12b0 <MV_8BitReverbFast+0x1b0>
test   $0x1,%r10b
je     146c <MV_8BitReverbFast+0x36c>
movdqu (%rdi,%rax,1),%xmm5
pxor   %xmm6,%xmm6
movdqa %xmm5,%xmm4
movdqa %xmm5,%xmm1
punpcklbw %xmm6,%xmm1
movdqa %xmm1,%xmm0
punpcklwd %xmm6,%xmm0
punpckhwd %xmm6,%xmm1
punpckhbw %xmm6,%xmm4
movdqa %xmm4,%xmm3
punpcklwd %xmm6,%xmm3
punpckhwd %xmm6,%xmm4
movss  %xmm9,%xmm6
psrld  %xmm6,%xmm4
psrld  %xmm6,%xmm3
psrld  %xmm6,%xmm1
pcmpeqd %xmm7,%xmm7
pxor   %xmm5,%xmm7
psrld  %xmm6,%xmm0
psrlw  $0x7,%xmm7
pand   0xbd1(%rip),%xmm7
paddd  %xmm2,%xmm0
paddd  %xmm2,%xmm1
paddd  %xmm2,%xmm3
paddd  %xmm2,%xmm4
movdqa 0xbc9(%rip),%xmm2
pand   %xmm2,%xmm4
pand   %xmm2,%xmm3
packuswb %xmm4,%xmm3
pand   %xmm2,%xmm1
pand   %xmm2,%xmm0
packuswb %xmm1,%xmm0
packuswb %xmm3,%xmm0
paddb  %xmm7,%xmm0
movdqu %xmm0,(%rsi,%rax,1)
cmp    %r8,%rbx
je     11a5 <MV_8BitReverbFast+0xa5>
test   $0x8,%r8b
jne    11bc <MV_8BitReverbFast+0xbc>
jmp    1135 <MV_8BitReverbFast+0x35>
xor    %eax,%eax
test   $0x1,%r10b
jne    13d4 <MV_8BitReverbFast+0x2d4>
jmp    146c <MV_8BitReverbFast+0x36c>

LLVM IR (-O0):
define void @MV_8BitReverbFast(i8* %0, i8* %1, i32 %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8
%11 = alloca i8
%12 = alloca i8
store i8* %0, i8** %5
store i8* %1, i8** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%13 = load i32, i32* %8
%14 = ashr i32 128, %13
%15 = sub nsw i32 128, %14
%16 = trunc i32 %15 to i8
store i8 %16, i8* %10
store i32 0, i32* %9
br label %17
17: ; preds = %53, %4
%18 = load i32, i32* %9
%19 = load i32, i32* %7
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %56
21: ; preds = %17
%22 = load i8*, i8** %5
%23 = load i32, i32* %9
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %22, i64 %24
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
%28 = load i32, i32* %8
%29 = ashr i32 %27, %28
%30 = trunc i32 %29 to i8
store i8 %30, i8* %11
%31 = load i8*, i8** %5
%32 = load i32, i32* %9
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %31, i64 %33
%35 = load i8, i8* %34
%36 = zext i8 %35 to i32
%37 = xor i32 %36, 128
%38 = ashr i32 %37, 7
%39 = trunc i32 %38 to i8
store i8 %39, i8* %12
%40 = load i8, i8* %11
%41 = zext i8 %40 to i32
%42 = load i8, i8* %10
%43 = zext i8 %42 to i32
%44 = add nsw i32 %41, %43
%45 = load i8, i8* %12
%46 = zext i8 %45 to i32
%47 = add nsw i32 %44, %46
%48 = trunc i32 %47 to i8
%49 = load i8*, i8** %6
%50 = load i32, i32* %9
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i8, i8* %49, i64 %51
store i8 %48, i8* %52
br label %53
53: ; preds = %21
%54 = load i32, i32* %9
%55 = add nsw i32 %54, 1
store i32 %55, i32* %9
br label %17
56: ; preds = %17
ret void
}

LLVM IR (-O2):
define void @MV_8BitReverbFast(i8* nocapture %0, i8* nocapture writeonly %1, i32 %2, i32 %3) {
%5 = lshr i32 128, %3
%6 = sub nuw nsw i32 128, %5
%7 = icmp sgt i32 %2, 0
br i1 %7, label %8, label %155
8: ; preds = %4
%9 = zext i32 %2 to i64
%10 = icmp ult i32 %2, 8
br i1 %10, label %109, label %11
11: ; preds = %8
%12 = getelementptr i8, i8* %1, i64 %9
%13 = getelementptr i8, i8* %0, i64 %9
%14 = icmp ugt i8* %13, %1
%15 = icmp ugt i8* %12, %0
%16 = and i1 %14, %15
br i1 %16, label %109, label %17
17: ; preds = %11
%18 = icmp ult i32 %2, 16
br i1 %18, label %84, label %19
19: ; preds = %17
%20 = and i64 %9, 4294967280
%21 = insertelement <16 x i32> poison, i32 %3, i64 0
%22 = shufflevector <16 x i32> %21, <16 x i32> poison, <16 x i32> zeroinitializer
%23 = insertelement <16 x i32> poison, i32 %6, i64 0
%24 = shufflevector <16 x i32> %23, <16 x i32> poison, <16 x i32> zeroinitializer
%25 = add nsw i64 %20, -16
%26 = lshr exact i64 %25, 4
%27 = add nuw nsw i64 %26, 1
%28 = and i64 %27, 1
%29 = icmp eq i64 %25, 0
br i1 %29, label %63, label %30
30: ; preds = %19
%31 = and i64 %27, 2305843009213693950
br label %32
32: ; preds = %32, %30
%33 = phi i64 [ 0, %30 ], [ %60, %32 ]
%34 = phi i64 [ 0, %30 ], [ %61, %32 ]
%35 = getelementptr inbounds i8, i8* %0, i64 %33
%36 = bitcast i8* %35 to <16 x i8>*
%37 = load <16 x i8>, <16 x i8>* %36
%38 = zext <16 x i8> %37 to <16 x i32>
%39 = lshr <16 x i32> %38, %22
%40 = xor <16 x i8> %37, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
%41 = lshr <16 x i8> %40, <i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>
%42 = add <16 x i32> %24, %39
%43 = trunc <16 x i32> %42 to <16 x i8>
%44 = add <16 x i8> %41, %43
%45 = getelementptr inbounds i8, i8* %1, i64 %33
%46 = bitcast i8* %45 to <16 x i8>*
store <16 x i8> %44, <16 x i8>* %46
%47 = or i64 %33, 16
%48 = getelementptr inbounds i8, i8* %0, i64 %47
%49 = bitcast i8* %48 to <16 x i8>*
%50 = load <16 x i8>, <16 x i8>* %49
%51 = zext <16 x i8> %50 to <16 x i32>
%52 = lshr <16 x i32> %51, %22
%53 = xor <16 x i8> %50, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
%54 = lshr <16 x i8> %53, <i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>
%55 = add <16 x i32> %24, %52
%56 = trunc <16 x i32> %55 to <16 x i8>
%57 = add <16 x i8> %54, %56
%58 = getelementptr inbounds i8, i8* %1, i64 %47
%59 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %57, <16 x i8>* %59
%60 = add nuw i64 %33, 32
%61 = add i64 %34, 2
%62 = icmp eq i64 %61, %31
br i1 %62, label %63, label %32
63: ; preds = %32, %19
%64 = phi i64 [ 0, %19 ], [ %60, %32 ]
%65 = icmp eq i64 %28, 0
br i1 %65, label %79, label %66
66: ; preds = %63
%67 = getelementptr inbounds i8, i8* %0, i64 %64
%68 = bitcast i8* %67 to <16 x i8>*
%69 = load <16 x i8>, <16 x i8>* %68
%70 = zext <16 x i8> %69 to <16 x i32>
%71 = lshr <16 x i32> %70, %22
%72 = xor <16 x i8> %69, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
%73 = lshr <16 x i8> %72, <i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>
%74 = add <16 x i32> %24, %71
%75 = trunc <16 x i32> %74 to <16 x i8>
%76 = add <16 x i8> %73, %75
%77 = getelementptr inbounds i8, i8* %1, i64 %64
%78 = bitcast i8* %77 to <16 x i8>*
store <16 x i8> %76, <16 x i8>* %78
br label %79
79: ; preds = %63, %66
%80 = icmp eq i64 %20, %9
br i1 %80, label %155, label %81
81: ; preds = %79
%82 = and i64 %9, 8
%83 = icmp eq i64 %82, 0
br i1 %83, label %109, label %84
84: ; preds = %17, %81
%85 = phi i64 [ %20, %81 ], [ 0, %17 ]
%86 = and i64 %9, 4294967288
%87 = insertelement <8 x i32> poison, i32 %3, i64 0
%88 = shufflevector <8 x i32> %87, <8 x i32> poison, <8 x i32> zeroinitializer
%89 = insertelement <8 x i32> poison, i32 %6, i64 0
%90 = shufflevector <8 x i32> %89, <8 x i32> poison, <8 x i32> zeroinitializer
br label %91
91: ; preds = %91, %84
%92 = phi i64 [ %85, %84 ], [ %105, %91 ]
%93 = getelementptr inbounds i8, i8* %0, i64 %92
%94 = bitcast i8* %93 to <8 x i8>*
%95 = load <8 x i8>, <8 x i8>* %94
%96 = zext <8 x i8> %95 to <8 x i32>
%97 = lshr <8 x i32> %96, %88
%98 = xor <8 x i8> %95, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
%99 = lshr <8 x i8> %98, <i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>
%100 = add <8 x i32> %90, %97
%101 = trunc <8 x i32> %100 to <8 x i8>
%102 = add <8 x i8> %99, %101
%103 = getelementptr inbounds i8, i8* %1, i64 %92
%104 = bitcast i8* %103 to <8 x i8>*
store <8 x i8> %102, <8 x i8>* %104
%105 = add nuw i64 %92, 8
%106 = icmp eq i64 %105, %86
br i1 %106, label %107, label %91
107: ; preds = %91
%108 = icmp eq i64 %86, %9
br i1 %108, label %155, label %109
109: ; preds = %11, %8, %81, %107
%110 = phi i64 [ 0, %8 ], [ 0, %11 ], [ %20, %81 ], [ %86, %107 ]
%111 = xor i64 %110, -1
%112 = and i64 %9, 1
%113 = icmp eq i64 %112, 0
br i1 %113, label %126, label %114
114: ; preds = %109
%115 = getelementptr inbounds i8, i8* %0, i64 %110
%116 = load i8, i8* %115
%117 = zext i8 %116 to i32
%118 = lshr i32 %117, %3
%119 = xor i8 %116, -1
%120 = lshr i8 %119, 7
%121 = add i32 %6, %118
%122 = trunc i32 %121 to i8
%123 = add i8 %120, %122
%124 = getelementptr inbounds i8, i8* %1, i64 %110
store i8 %123, i8* %124
%125 = or i64 %110, 1
br label %126
126: ; preds = %114, %109
%127 = phi i64 [ %110, %109 ], [ %125, %114 ]
%128 = sub nsw i64 0, %9
%129 = icmp eq i64 %111, %128
br i1 %129, label %155, label %130
130: ; preds = %126, %130
%131 = phi i64 [ %153, %130 ], [ %127, %126 ]
%132 = getelementptr inbounds i8, i8* %0, i64 %131
%133 = load i8, i8* %132
%134 = zext i8 %133 to i32
%135 = lshr i32 %134, %3
%136 = xor i8 %133, -1
%137 = lshr i8 %136, 7
%138 = add i32 %6, %135
%139 = trunc i32 %138 to i8
%140 = add i8 %137, %139
%141 = getelementptr inbounds i8, i8* %1, i64 %131
store i8 %140, i8* %141
%142 = add nuw nsw i64 %131, 1
%143 = getelementptr inbounds i8, i8* %0, i64 %142
%144 = load i8, i8* %143
%145 = zext i8 %144 to i32
%146 = lshr i32 %145, %3
%147 = xor i8 %144, -1
%148 = lshr i8 %147, 7
%149 = add i32 %6, %146
%150 = trunc i32 %149 to i8
%151 = add i8 %148, %150
%152 = getelementptr inbounds i8, i8* %1, i64 %142
store i8 %151, i8* %152
%153 = add nuw nsw i64 %131, 2
%154 = icmp eq i64 %153, %9
br i1 %154, label %155, label %130
155: ; preds = %126, %130, %79, %107, %4
ret void
}