refactor: make silk_stereo_MS_to_LR safe

Author: DCNick3

src/silk/dec_API.rs

@@ -357,10 +357,10 @@ pub unsafe fn silk_Decode(
     if decControl.nChannelsAPI == 2 && decControl.nChannelsInternal == 2 {
         silk_stereo_MS_to_LR(
             &mut psDec.sStereo,
-            samplesOut1_tmp[0 as usize],
-            samplesOut1_tmp[1 as usize],
-            MS_pred_Q13.as_mut_ptr() as *const i32,
-            channel_state[0].fs_kHz,
+            std::slice::from_raw_parts_mut(samplesOut1_tmp[0], nSamplesOutDec as usize + 2),
+            std::slice::from_raw_parts_mut(samplesOut1_tmp[1], nSamplesOutDec as usize + 2),
+            &MS_pred_Q13,
+            channel_state[0].fs_kHz as usize,
             nSamplesOutDec,
         );
     } else {

src/silk/define.rs

@@ -10,7 +10,7 @@ pub const MAX_SHAPE_LPC_ORDER: i32 = 24;
 pub const HARM_SHAPE_FIR_TAPS: i32 = 3;
 pub const LTP_ORDER: i32 = 5;
 pub const NSQ_LPC_BUF_LENGTH: i32 = MAX_LPC_ORDER;
-pub const STEREO_INTERP_LEN_MS: i32 = 8;
+pub const STEREO_INTERP_LEN_MS: usize = 8;
 pub const LA_SHAPE_MS: i32 = 5;
 pub const STEREO_QUANT_SUB_STEPS: i32 = 5;
 pub const STEREO_QUANT_TAB_SIZE: i32 = 16;

src/silk/macros.rs

@@ -21,6 +21,12 @@ pub fn silk_SMLAWB(a32: i32, b32: i32, c32: i32) -> i32 {
     (a32 as i64 + ((b32 as i64 * c32 as i16 as i64) >> 16)) as i32
 }
 
+/// (opus_int32)((opus_int16)(a3))) * (opus_int32)((opus_int16)(b32)) output have to be 32bit int
+#[inline]
+pub fn silk_SMULBB(a32: i32, b32: i32) -> i32 {
+    a32 as i16 as i32 * b32 as i16 as i32
+}
+
 /// a32 + (b32 * (opus_int32)((opus_int16)(c32))) >> 16 output have to be 32bit int
 #[inline]
 pub fn silk_SMULWW(a32: i32, b32: i32) -> i32 {

src/silk/stereo_LR_to_MS.rs

@@ -277,7 +277,7 @@ pub unsafe fn silk_stereo_LR_to_MS(
     }
     if *mid_only_flag as i32 == 1 {
         (*state).silent_side_len = ((*state).silent_side_len as i32
-            + (frame_length - STEREO_INTERP_LEN_MS * fs_kHz))
+            + (frame_length - STEREO_INTERP_LEN_MS as i32 * fs_kHz))
             as i16;
         if ((*state).silent_side_len as i32) < LA_SHAPE_MS * fs_kHz {
             *mid_only_flag = 0;
@@ -328,7 +328,7 @@ pub unsafe fn silk_stereo_LR_to_MS(
         >> 16) as i32 as u32)
         << 10) as i32;
     n = 0;
-    while n < STEREO_INTERP_LEN_MS * fs_kHz {
+    while n < STEREO_INTERP_LEN_MS as i32 * fs_kHz {
         pred0_Q13 += delta0_Q13;
         pred1_Q13 += delta1_Q13;
         w_Q24 += deltaw_Q24;
@@ -367,7 +367,7 @@ pub unsafe fn silk_stereo_LR_to_MS(
     pred0_Q13 = -pred_Q13[0 as usize];
     pred1_Q13 = -pred_Q13[1 as usize];
     w_Q24 = ((width_Q14 as u32) << 10) as i32;
-    n = STEREO_INTERP_LEN_MS * fs_kHz;
+    n = STEREO_INTERP_LEN_MS as i32 * fs_kHz;
     while n < frame_length {
         sum = (((*mid.offset(n as isize) as i32
             + *mid.offset((n + 2) as isize) as i32

src/silk/stereo_MS_to_LR.rs

@@ -1,172 +1,81 @@
-pub mod typedef_h {
-    pub const silk_int16_MIN: i32 = i16::MIN as i32;
-    pub const silk_int16_MAX: i32 = i16::MAX as i32;
-}
 use crate::silk::define::STEREO_INTERP_LEN_MS;
 
-pub use self::typedef_h::{silk_int16_MAX, silk_int16_MIN};
 use crate::silk::structs::stereo_dec_state;
 
-use crate::externs::memcpy;
-pub unsafe fn silk_stereo_MS_to_LR(
-    state: *mut stereo_dec_state,
-    x1: *mut i16,
-    x2: *mut i16,
-    pred_Q13: *const i32,
-    fs_kHz: i32,
+use crate::silk::macros::{silk_SMLAWB, silk_SMULBB};
+use crate::silk::SigProc_FIX::{silk_RSHIFT_ROUND, silk_SAT16};
+
+/// Convert adaptive Mid/Side representation to Left/Right stereo signal
+///
+/// ```text
+/// state          I/O   State
+/// x1[]           I/O   Left input signal, becomes mid signal
+/// x2[]           I/O   Right input signal, becomes side signal
+/// pred_Q13[]     I     Predictors
+/// fs_kHz         I     Samples rate (kHz)
+/// frame_length   I     Number of samples
+/// ```
+pub fn silk_stereo_MS_to_LR(
+    state: &mut stereo_dec_state,
+    x1: &mut [i16],
+    x2: &mut [i16],
+    pred_Q13: &[i32; 2],
+    fs_kHz: usize,
     frame_length: i32,
 ) {
-    let mut n: i32 = 0;
-    let mut denom_Q16: i32 = 0;
-    let mut delta0_Q13: i32 = 0;
-    let mut delta1_Q13: i32 = 0;
-    let mut sum: i32 = 0;
-    let mut diff: i32 = 0;
-    let mut pred0_Q13: i32 = 0;
-    let mut pred1_Q13: i32 = 0;
-    memcpy(
-        x1 as *mut core::ffi::c_void,
-        ((*state).sMid).as_mut_ptr() as *const core::ffi::c_void,
-        2_u64.wrapping_mul(::core::mem::size_of::<i16>() as u64),
-    );
-    memcpy(
-        x2 as *mut core::ffi::c_void,
-        ((*state).sSide).as_mut_ptr() as *const core::ffi::c_void,
-        2_u64.wrapping_mul(::core::mem::size_of::<i16>() as u64),
-    );
-    memcpy(
-        ((*state).sMid).as_mut_ptr() as *mut core::ffi::c_void,
-        &mut *x1.offset(frame_length as isize) as *mut i16 as *const core::ffi::c_void,
-        2_u64.wrapping_mul(::core::mem::size_of::<i16>() as u64),
+    let frame_length = frame_length as usize;
+
+    assert_eq!(x1.len(), x2.len());
+    assert_eq!(x1.len(), frame_length + 2);
+    assert!(STEREO_INTERP_LEN_MS * fs_kHz <= frame_length);
+
+    /* Buffering */
+    x1[..2].copy_from_slice(&state.sMid);
+    x2[..2].copy_from_slice(&state.sSide);
+
+    state.sMid[..2].copy_from_slice(&x1[frame_length..]);
+    state.sSide[..2].copy_from_slice(&x2[frame_length..]);
+
+    /* Interpolate predictors and add prediction to side channel */
+    let mut pred0_Q13 = state.pred_prev_Q13[0] as i32;
+    let mut pred1_Q13 = state.pred_prev_Q13[1] as i32;
+    let denom_Q16 = ((1) << 16) / (8 * fs_kHz) as i32;
+    let delta0_Q13 = silk_RSHIFT_ROUND(
+        silk_SMULBB(pred_Q13[0] - state.pred_prev_Q13[0] as i32, denom_Q16),
+        16,
     );
-    memcpy(
-        ((*state).sSide).as_mut_ptr() as *mut core::ffi::c_void,
-        &mut *x2.offset(frame_length as isize) as *mut i16 as *const core::ffi::c_void,
-        2_u64.wrapping_mul(::core::mem::size_of::<i16>() as u64),
+    let delta1_Q13 = silk_RSHIFT_ROUND(
+        silk_SMULBB(pred_Q13[1] - state.pred_prev_Q13[1] as i32, denom_Q16),
+        16,
     );
-    pred0_Q13 = (*state).pred_prev_Q13[0 as usize] as i32;
-    pred1_Q13 = (*state).pred_prev_Q13[1 as usize] as i32;
-    denom_Q16 = ((1) << 16) / (8 * fs_kHz);
-    delta0_Q13 = if 16 == 1 {
-        ((*pred_Q13.offset(0 as isize) - (*state).pred_prev_Q13[0 as usize] as i32) as i16 as i32
-            * denom_Q16 as i16 as i32
-            >> 1)
-            + ((*pred_Q13.offset(0 as isize) - (*state).pred_prev_Q13[0 as usize] as i32) as i16
-                as i32
-                * denom_Q16 as i16 as i32
-                & 1)
-    } else {
-        ((*pred_Q13.offset(0 as isize) - (*state).pred_prev_Q13[0 as usize] as i32) as i16 as i32
-            * denom_Q16 as i16 as i32
-            >> 16 - 1)
-            + 1
-            >> 1
-    };
-    delta1_Q13 = if 16 == 1 {
-        ((*pred_Q13.offset(1 as isize) - (*state).pred_prev_Q13[1 as usize] as i32) as i16 as i32
-            * denom_Q16 as i16 as i32
-            >> 1)
-            + ((*pred_Q13.offset(1 as isize) - (*state).pred_prev_Q13[1 as usize] as i32) as i16
-                as i32
-                * denom_Q16 as i16 as i32
-                & 1)
-    } else {
-        ((*pred_Q13.offset(1 as isize) - (*state).pred_prev_Q13[1 as usize] as i32) as i16 as i32
-            * denom_Q16 as i16 as i32
-            >> 16 - 1)
-            + 1
-            >> 1
-    };
-    n = 0;
-    while n < STEREO_INTERP_LEN_MS * fs_kHz {
+
+    for n in 0..STEREO_INTERP_LEN_MS * fs_kHz {
         pred0_Q13 += delta0_Q13;
         pred1_Q13 += delta1_Q13;
-        sum = (((*x1.offset(n as isize) as i32
-            + *x1.offset((n + 2) as isize) as i32
-            + ((*x1.offset((n + 1) as isize) as u32) << 1) as i32) as u32)
-            << 9) as i32;
-        sum = (((*x2.offset((n + 1) as isize) as i32 as u32) << 8) as i32 as i64
-            + (sum as i64 * pred0_Q13 as i16 as i64 >> 16)) as i32;
-        sum = (sum as i64
-            + (((*x1.offset((n + 1) as isize) as i32 as u32) << 11) as i32 as i64
-                * pred1_Q13 as i16 as i64
-                >> 16)) as i32;
-        *x2.offset((n + 1) as isize) = (if (if 8 == 1 {
-            (sum >> 1) + (sum & 1)
-        } else {
-            (sum >> 8 - 1) + 1 >> 1
-        }) > silk_int16_MAX
-        {
-            silk_int16_MAX
-        } else if (if 8 == 1 {
-            (sum >> 1) + (sum & 1)
-        } else {
-            (sum >> 8 - 1) + 1 >> 1
-        }) < silk_int16_MIN
-        {
-            silk_int16_MIN
-        } else if 8 == 1 {
-            (sum >> 1) + (sum & 1)
-        } else {
-            (sum >> 8 - 1) + 1 >> 1
-        }) as i16;
-        n += 1;
+        let sum = (x1[n] as i32 + x1[n + 2] as i32 + (x1[n + 1] << 1) as i32) << 9; /* Q11 */
+        let sum = silk_SMLAWB((x2[n + 1] as i32) << 8, sum, pred0_Q13); /* Q8  */
+        let sum = silk_SMLAWB(sum, (x1[n + 1] as i32) << 11, pred1_Q13); /* Q8  */
+        x2[n + 1] = silk_SAT16(silk_RSHIFT_ROUND(sum, 8)) as i16;
     }
-    pred0_Q13 = *pred_Q13.offset(0 as isize);
-    pred1_Q13 = *pred_Q13.offset(1 as isize);
-    n = STEREO_INTERP_LEN_MS * fs_kHz;
-    while n < frame_length {
-        sum = (((*x1.offset(n as isize) as i32
-            + *x1.offset((n + 2) as isize) as i32
-            + ((*x1.offset((n + 1) as isize) as u32) << 1) as i32) as u32)
-            << 9) as i32;
-        sum = (((*x2.offset((n + 1) as isize) as i32 as u32) << 8) as i32 as i64
-            + (sum as i64 * pred0_Q13 as i16 as i64 >> 16)) as i32;
-        sum = (sum as i64
-            + (((*x1.offset((n + 1) as isize) as i32 as u32) << 11) as i32 as i64
-                * pred1_Q13 as i16 as i64
-                >> 16)) as i32;
-        *x2.offset((n + 1) as isize) = (if (if 8 == 1 {
-            (sum >> 1) + (sum & 1)
-        } else {
-            (sum >> 8 - 1) + 1 >> 1
-        }) > silk_int16_MAX
-        {
-            silk_int16_MAX
-        } else if (if 8 == 1 {
-            (sum >> 1) + (sum & 1)
-        } else {
-            (sum >> 8 - 1) + 1 >> 1
-        }) < silk_int16_MIN
-        {
-            silk_int16_MIN
-        } else if 8 == 1 {
-            (sum >> 1) + (sum & 1)
-        } else {
-            (sum >> 8 - 1) + 1 >> 1
-        }) as i16;
-        n += 1;
+
+    let pred0_Q13 = pred_Q13[0];
+    let pred1_Q13 = pred_Q13[1];
+
+    for n in STEREO_INTERP_LEN_MS * fs_kHz..frame_length {
+        let sum = (x1[n] as i32 + x1[n + 2] as i32 + ((x1[n + 1] as i32) << 1)) << 9; /* Q11 */
+        let sum = silk_SMLAWB((x2[n + 1] as i32) << 8, sum, pred0_Q13); /* Q8  */
+        let sum = silk_SMLAWB(sum, (x1[n + 1] as i32) << 11, pred1_Q13); /* Q8  */
+        x2[n + 1] = silk_SAT16(silk_RSHIFT_ROUND(sum, 8)) as i16;
     }
-    (*state).pred_prev_Q13[0 as usize] = *pred_Q13.offset(0 as isize) as i16;
-    (*state).pred_prev_Q13[1 as usize] = *pred_Q13.offset(1 as isize) as i16;
-    n = 0;
-    while n < frame_length {
-        sum = *x1.offset((n + 1) as isize) as i32 + *x2.offset((n + 1) as isize) as i32;
-        diff = *x1.offset((n + 1) as isize) as i32 - *x2.offset((n + 1) as isize) as i32;
-        *x1.offset((n + 1) as isize) = (if sum > silk_int16_MAX {
-            silk_int16_MAX
-        } else if sum < silk_int16_MIN {
-            silk_int16_MIN
-        } else {
-            sum
-        }) as i16;
-        *x2.offset((n + 1) as isize) = (if diff > silk_int16_MAX {
-            silk_int16_MAX
-        } else if diff < silk_int16_MIN {
-            silk_int16_MIN
-        } else {
-            diff
-        }) as i16;
-        n += 1;
+    state.pred_prev_Q13[0] = pred_Q13[0] as i16;
+    state.pred_prev_Q13[1] = pred_Q13[1] as i16;
+
+    /* Convert to left/right signals */
+    for n in 0..frame_length {
+        let sum = x1[n + 1] as i32 + x2[n + 1] as i32;
+        let diff = x1[n + 1] as i32 - x2[n + 1] as i32;
+
+        x1[n + 1] = silk_SAT16(sum) as i16;
+        x2[n + 1] = silk_SAT16(diff) as i16;
     }
 }

src/silk/stereo_decode_pred.rs

@@ -34,7 +34,7 @@ pub fn silk_stereo_decode_pred(psRangeDec: &mut ec_dec, pred_Q13: &mut [i32; 2])
         ix[n][0] += 3 * ix[n][2];
         let low_Q13 = silk_stereo_pred_quant_Q13[ix[n][0]] as i32;
         let step_Q13 = silk_SMULWB(
-            (silk_stereo_pred_quant_Q13[ix[n][0] + 1] as i32 - low_Q13),
+            silk_stereo_pred_quant_Q13[ix[n][0] + 1] as i32 - low_Q13,
             SILK_FIX_CONST!(0.5 / STEREO_QUANT_SUB_STEPS as f64, 16),
         );