Advertisement
Guest User

Untitled

a guest
Jan 11th, 2018
87
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Rust 8.46 KB | None | 0 0
  1. pub unsafe extern fn opus_pcm_soft_clip(
  2.     mut _x : *mut f32,
  3.     mut N : i32,
  4.     mut C : i32,
  5.     mut declip_mem : *mut f32
  6. ) {
  7.     let mut _currentBlock;
  8.     let mut c : i32;
  9.     let mut i : i32;
  10.     let mut x : *mut f32;
  11.     if C < 1i32 || N < 1i32 || _x.is_null() || declip_mem.is_null() {
  12.     } else {
  13.         i = 0i32;
  14.         'loop2: loop {
  15.            if !(i < N * C) {
  16.                break;
  17.            }
  18.            *_x.offset(i as (isize)) = if -2.f32 > if 2.f32 < *_x.offset(
  19.                                                                   i as (isize)
  20.                                                               ) {
  21.                                                       2.f32
  22.                                                   } else {
  23.                                                       *_x.offset(i as (isize))
  24.                                                   } {
  25.                                           -2.f32
  26.                                       } else if 2.f32 < *_x.offset(i as (isize)) {
  27.                                           2.f32
  28.                                       } else {
  29.                                           *_x.offset(i as (isize))
  30.                                       };
  31.            i = i + 1;
  32.        }
  33.        c = 0i32;
  34.        'loop4: loop {
  35.             if !(c < C) {
  36.                 break;
  37.             }
  38.             let mut a : f32;
  39.             let mut x0 : f32;
  40.             let mut curr : i32;
  41.             x = _x.offset(c as (isize));
  42.             a = *declip_mem.offset(c as (isize));
  43.             i = 0i32;
  44.             'loop7: loop {
  45.                if !(i < N) {
  46.                    break;
  47.                }
  48.                if *x.offset((i * C) as (isize)) * a >= 0i32 as (f32) {
  49.                    break;
  50.                }
  51.                *x.offset((i * C) as (isize)) = *x.offset(
  52.                                                     (i * C) as (isize)
  53.                                                 ) + a * *x.offset((i * C) as (isize)) * *x.offset(
  54.                                                                                              (i * C) as (isize)
  55.                                                                                          );
  56.                i = i + 1;
  57.            }
  58.            curr = 0i32;
  59.            x0 = *x.offset(0isize);
  60.            'loop12: loop {
  61.                 let mut start : i32;
  62.                 let mut end : i32;
  63.                 let mut maxval : f32;
  64.                 let mut special : i32 = 0i32;
  65.                 let mut peak_pos : i32;
  66.                 i = curr;
  67.                 'loop13: loop {
  68.                    if !(i < N) {
  69.                        break;
  70.                    }
  71.                    if *x.offset((i * C) as (isize)) > 1i32 as (f32) || *x.offset(
  72.                                                                             (i * C) as (isize)
  73.                                                                         ) < -1i32 as (f32) {
  74.                        break;
  75.                    }
  76.                    i = i + 1;
  77.                }
  78.                if i == N {
  79.                    _currentBlock = 36;
  80.                    break;
  81.                }
  82.                peak_pos = i;
  83.                start = {
  84.                            end = i;
  85.                            end
  86.                        };
  87.                maxval = if *x.offset((i * C) as (isize)) < 0i32 as (f32) {
  88.                             -*x.offset((i * C) as (isize))
  89.                         } else {
  90.                             *x.offset((i * C) as (isize))
  91.                         };
  92.                'loop18: loop {
  93.                     if !(start > 0i32 && (*x.offset((i * C) as (isize)) * *x.offset(
  94.                                                                                ((start - 1i32) * C) as (isize)
  95.                                                                            ) >= 0i32 as (f32))) {
  96.                         break;
  97.                     }
  98.                     start = start - 1;
  99.                 }
  100.                 'loop19: loop {
  101.                    if !(end < N && (*x.offset((i * C) as (isize)) * *x.offset(
  102.                                                                          (end * C) as (isize)
  103.                                                                      ) >= 0i32 as (f32))) {
  104.                        break;
  105.                    }
  106.                    if if *x.offset((end * C) as (isize)) < 0i32 as (f32) {
  107.                           -*x.offset((end * C) as (isize))
  108.                       } else {
  109.                           *x.offset((end * C) as (isize))
  110.                       } > maxval {
  111.                        maxval = if *x.offset((end * C) as (isize)) < 0i32 as (f32) {
  112.                                     -*x.offset((end * C) as (isize))
  113.                                 } else {
  114.                                     *x.offset((end * C) as (isize))
  115.                                 };
  116.                        peak_pos = end;
  117.                    }
  118.                    end = end + 1;
  119.                }
  120.                special = (start == 0i32 && (*x.offset(
  121.                                                  (i * C) as (isize)
  122.                                              ) * *x.offset(0isize) >= 0i32 as (f32))) as (i32);
  123.                a = (maxval - 1i32 as (f32)) / (maxval * maxval);
  124.                a = a + a * 2.4e-7f32;
  125.                if *x.offset((i * C) as (isize)) > 0i32 as (f32) {
  126.                    a = -a;
  127.                }
  128.                i = start;
  129.                'loop23: loop {
  130.                     if !(i < end) {
  131.                         break;
  132.                     }
  133.                     *x.offset((i * C) as (isize)) = *x.offset(
  134.                                                          (i * C) as (isize)
  135.                                                      ) + a * *x.offset(
  136.                                                                   (i * C) as (isize)
  137.                                                               ) * *x.offset((i * C) as (isize));
  138.                     i = i + 1;
  139.                 }
  140.                 if special != 0 && (peak_pos >= 2i32) {
  141.                     let mut delta : f32;
  142.                     let mut offset : f32 = x0 - *x.offset(0isize);
  143.                     delta = offset / peak_pos as (f32);
  144.                     i = curr;
  145.                     'loop26: loop {
  146.                        if !(i < peak_pos) {
  147.                            break;
  148.                        }
  149.                        offset = offset - delta;
  150.                        let _rhs = offset;
  151.                        let _lhs = &mut *x.offset((i * C) as (isize));
  152.                        *_lhs = *_lhs + _rhs;
  153.                        *x.offset((i * C) as (isize)) = if -1.f32 > if 1.f32 < *x.offset(
  154.                                                                                    (i * C) as (isize)
  155.                                                                                ) {
  156.                                                                        1.f32
  157.                                                                    } else {
  158.                                                                        *x.offset(
  159.                                                                             (i * C) as (isize)
  160.                                                                         )
  161.                                                                    } {
  162.                                                            -1.f32
  163.                                                        } else if 1.f32 < *x.offset(
  164.                                                                               (i * C) as (isize)
  165.                                                                           ) {
  166.                                                            1.f32
  167.                                                        } else {
  168.                                                            *x.offset((i * C) as (isize))
  169.                                                        };
  170.                        i = i + 1;
  171.                    }
  172.                }
  173.                curr = end;
  174.                if curr == N {
  175.                    _currentBlock = 37;
  176.                    break;
  177.                }
  178.            }
  179.            if _currentBlock == 36 {
  180.                a = 0i32 as (f32);
  181.            }
  182.            *declip_mem.offset(c as (isize)) = a;
  183.            c = c + 1;
  184.        }
  185.    }
  186. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement