refactor: make demo decode able to initialize without malloc (use Box instead)

Author: DCNick3

src/src/opus_decoder.rs

@@ -63,6 +63,45 @@ pub struct OpusDecoder {
     pub(crate) softclip_mem: [opus_val16; 2],
     pub(crate) rangeFinal: u32,
 }
+impl OpusDecoder {
+    pub unsafe fn new(Fs: i32, channels: usize) -> Result<OpusDecoder, i32> {
+        if Fs != 48000 && Fs != 24000 && Fs != 16000 && Fs != 12000 && Fs != 8000
+            || channels != 1 && channels != 2
+        {
+            return Err(OPUS_BAD_ARG);
+        }
+
+        let mut st = OpusDecoder {
+            celt_dec: celt_decoder_init(Fs, channels),
+            silk_dec: silk_InitDecoder(),
+            channels: channels as i32,
+            Fs,
+            DecControl: silk_DecControlStruct {
+                nChannelsAPI: channels as i32,
+                nChannelsInternal: 0,
+                API_sampleRate: Fs,
+                internalSampleRate: 0,
+                payloadSize_ms: 0,
+                prevPitchLag: 0,
+            },
+            decode_gain: 0,
+            stream_channels: channels as i32,
+            bandwidth: 0,
+            mode: 0,
+            prev_mode: 0,
+            frame_size: Fs / 400,
+            prev_redundancy: 0,
+            last_packet_duration: 0,
+            softclip_mem: [0.0; 2],
+            rangeFinal: 0,
+        };
+
+        opus_custom_decoder_ctl!(&mut st.celt_dec, CELT_SET_SIGNALLING_REQUEST, 0);
+
+        Ok(st)
+    }
+}
+
 unsafe fn validate_opus_decoder(st: &OpusDecoder) {
     assert!((*st).channels == 1 || (*st).channels == 2);
     assert!(
@@ -94,34 +133,27 @@ unsafe fn validate_opus_decoder(st: &OpusDecoder) {
     );
     assert!((*st).stream_channels == 1 || (*st).stream_channels == 2);
 }
-pub fn opus_decoder_get_size(_channels: i32) -> usize {
-    align(core::mem::size_of::<OpusDecoder>() as _) as usize
+#[deprecated]
+pub fn opus_decoder_get_size(channels: i32) -> i32 {
+    if channels < 1 || channels > 2 {
+        return 0;
+    }
+    align(core::mem::size_of::<OpusDecoder>() as _)
 }
+#[deprecated]
 pub unsafe fn opus_decoder_init(st: *mut OpusDecoder, Fs: i32, channels: i32) -> i32 {
-    if Fs != 48000 && Fs != 24000 && Fs != 16000 && Fs != 12000 && Fs != 8000
-        || channels != 1 && channels != 2
-    {
-        return OPUS_BAD_ARG;
+    match OpusDecoder::new(Fs, channels as usize) {
+        Ok(dec) => {
+            *st = dec;
+            return OPUS_OK;
+        }
+        Err(err) => {
+            return err;
+        }
     }
-    memset(
-        st as *mut i8 as *mut core::ffi::c_void,
-        0,
-        (opus_decoder_get_size(channels) as u64).wrapping_mul(::core::mem::size_of::<i8>() as u64),
-    );
-    (*st).channels = channels;
-    (*st).stream_channels = (*st).channels;
-    (*st).Fs = Fs;
-    (*st).DecControl.API_sampleRate = (*st).Fs;
-    (*st).DecControl.nChannelsAPI = (*st).channels;
-    (*st).silk_dec = silk_InitDecoder();
-    (*st).celt_dec = celt_decoder_init(Fs, channels as usize);
-    opus_custom_decoder_ctl!(&mut (*st).celt_dec, CELT_SET_SIGNALLING_REQUEST, 0);
-    (*st).prev_mode = 0;
-    (*st).frame_size = Fs / 400;
-    return OPUS_OK;
 }
+#[deprecated]
 pub unsafe fn opus_decoder_create(Fs: i32, channels: i32, error: *mut i32) -> *mut OpusDecoder {
-    let mut ret: i32 = 0;
     let mut st: *mut OpusDecoder = 0 as *mut OpusDecoder;
     if Fs != 48000 && Fs != 24000 && Fs != 16000 && Fs != 12000 && Fs != 8000
         || channels != 1 && channels != 2
@@ -138,7 +170,7 @@ pub unsafe fn opus_decoder_create(Fs: i32, channels: i32, error: *mut i32) -> *m
         }
         return NULL as *mut OpusDecoder;
     }
-    ret = opus_decoder_init(st, Fs, channels);
+    let ret = opus_decoder_init(st, Fs, channels);
     if !error.is_null() {
         *error = ret;
     }
@@ -999,6 +1031,7 @@ macro_rules! opus_decoder_ctl {
         opus_decoder_ctl!($st, $request,)
     };
 }
+#[deprecated]
 pub unsafe fn opus_decoder_destroy(st: *mut OpusDecoder) {
     free(st as *mut core::ffi::c_void);
 }

src/src/opus_multistream_decoder.rs

@@ -43,7 +43,7 @@ use crate::src::opus_multistream::{
 use crate::src::opus_private::align;
 use crate::varargs::VarArgs;
 use crate::{
-    opus_decoder_ctl, opus_decoder_get_size, opus_decoder_init, opus_multistream_decoder_ctl,
+    opus_decoder_ctl, opus_decoder_get_size, opus_multistream_decoder_ctl,
     opus_packet_get_nb_samples, OpusDecoder,
 };
 
@@ -71,7 +71,6 @@ pub unsafe fn opus_multistream_decoder_init(
     mapping: *const u8,
 ) -> i32 {
     let mut i: i32 = 0;
-    let mut ret: i32 = 0;
     let mut ptr: *mut i8 = 0 as *mut i8;
     if channels > 255
         || channels < 1
@@ -99,18 +98,28 @@ pub unsafe fn opus_multistream_decoder_init(
     let mono_size = opus_decoder_get_size(1);
     i = 0;
     while i < (*st).layout.nb_coupled_streams {
-        ret = opus_decoder_init(ptr as *mut OpusDecoder, Fs, 2);
-        if ret != OPUS_OK {
-            return ret;
+        match OpusDecoder::new(Fs, 2) {
+            Err(e) => {
+                return e;
+            }
+            Ok(dec) => {
+                *(ptr as *mut OpusDecoder) = dec;
+            }
         }
+
         ptr = ptr.offset(align(coupled_size as _) as isize);
         i += 1;
     }
     while i < (*st).layout.nb_streams {
-        ret = opus_decoder_init(ptr as *mut OpusDecoder, Fs, 1);
-        if ret != OPUS_OK {
-            return ret;
+        match OpusDecoder::new(Fs, 2) {
+            Err(e) => {
+                return e;
+            }
+            Ok(dec) => {
+                *(ptr as *mut OpusDecoder) = dec;
+            }
         }
+
         ptr = ptr.offset(align(mono_size as _) as isize);
         i += 1;
     }

unsafe-libopus-tools/src/demo/backend.rs

@@ -12,8 +12,7 @@ pub(crate) trait OpusBackendTrait {
         Fs: i32,
         channels: i32,
         application: i32,
-        error: *mut i32,
-    ) -> Self::Encoder;
+    ) -> Result<Self::Encoder, i32>;
     unsafe fn opus_encoder_ctl_impl(st: &mut Self::Encoder, request: i32, args: VarArgs) -> i32;
     unsafe fn opus_encode(
         st: &mut Self::Encoder,
@@ -24,7 +23,7 @@ pub(crate) trait OpusBackendTrait {
     ) -> i32;
     unsafe fn opus_encoder_destroy(st: Self::Encoder);
 
-    unsafe fn opus_decoder_create(Fs: i32, channels: i32, error: *mut i32) -> Self::Decoder;
+    unsafe fn opus_decoder_create(Fs: i32, channels: i32) -> Result<Self::Decoder, i32>;
     unsafe fn opus_decode(
         st: &mut Self::Decoder,
         data: *const u8,
@@ -38,26 +37,30 @@ pub(crate) trait OpusBackendTrait {
 }
 
 mod unsafe_libopus {
-    use ::unsafe_libopus::varargs::VarArgs;
-    use ::unsafe_libopus::{
-        opus_decode, opus_decoder_create, opus_decoder_ctl_impl, opus_decoder_destroy, opus_encode,
-        opus_encoder_create, opus_encoder_ctl_impl, opus_encoder_destroy,
+    use unsafe_libopus::{
+        opus_decode, opus_decoder_ctl_impl, opus_encode, opus_encoder_create,
+        opus_encoder_ctl_impl, opus_encoder_destroy, varargs::VarArgs, OpusDecoder, OpusEncoder,
     };
-    use unsafe_libopus::{OpusDecoder, OpusEncoder};
 
     pub struct RustLibopusBackend;
 
     impl super::OpusBackendTrait for RustLibopusBackend {
         type Encoder = *mut OpusEncoder;
-        type Decoder = *mut OpusDecoder;
+        type Decoder = Box<OpusDecoder>;
 
         unsafe fn opus_encoder_create(
             Fs: i32,
             channels: i32,
             application: i32,
-            error: *mut i32,
-        ) -> *mut OpusEncoder {
-            opus_encoder_create(Fs, channels, application, error)
+        ) -> Result<*mut OpusEncoder, i32> {
+            let mut error = 0;
+
+            let res = opus_encoder_create(Fs, channels, application, &mut error);
+            if res.is_null() {
+                Err(error)
+            } else {
+                Ok(res)
+            }
         }
 
         unsafe fn opus_encoder_ctl_impl(
@@ -82,31 +85,31 @@ mod unsafe_libopus {
             opus_encoder_destroy(st)
         }
 
-        unsafe fn opus_decoder_create(Fs: i32, channels: i32, error: *mut i32) -> *mut OpusDecoder {
-            opus_decoder_create(Fs, channels, error)
+        unsafe fn opus_decoder_create(Fs: i32, channels: i32) -> Result<Box<OpusDecoder>, i32> {
+            OpusDecoder::new(Fs, channels as usize).map(Box::new)
         }
 
         unsafe fn opus_decode(
-            &mut st: &mut *mut OpusDecoder,
+            st: &mut Box<OpusDecoder>,
             data: *const u8,
             len: i32,
             pcm: *mut i16,
             frame_size: i32,
             decode_fec: i32,
         ) -> i32 {
-            opus_decode(st, data, len, pcm, frame_size, decode_fec)
+            opus_decode(st.as_mut(), data, len, pcm, frame_size, decode_fec)
         }
 
         unsafe fn opus_decoder_ctl_impl(
-            &mut st: &mut *mut OpusDecoder,
+            st: &mut Box<OpusDecoder>,
             request: i32,
             args: VarArgs,
         ) -> i32 {
-            opus_decoder_ctl_impl(st, request, args)
+            opus_decoder_ctl_impl(st.as_mut(), request, args)
         }
 
-        unsafe fn opus_decoder_destroy(st: *mut OpusDecoder) {
-            opus_decoder_destroy(st)
+        unsafe fn opus_decoder_destroy(st: Box<OpusDecoder>) {
+            drop(st)
         }
     }
 }
@@ -130,9 +133,15 @@ mod libopus {
             Fs: i32,
             channels: i32,
             application: i32,
-            error: *mut i32,
-        ) -> *mut OpusEncoder {
-            opus_encoder_create(Fs, channels, application, error)
+        ) -> Result<*mut OpusEncoder, i32> {
+            let mut error = 0;
+
+            let res = opus_encoder_create(Fs, channels, application, &mut error);
+            if res.is_null() {
+                Err(error)
+            } else {
+                Ok(res)
+            }
         }
 
         unsafe fn opus_encoder_ctl_impl(
@@ -163,8 +172,14 @@ mod libopus {
             opus_encoder_destroy(st)
         }
 
-        unsafe fn opus_decoder_create(Fs: i32, channels: i32, error: *mut i32) -> *mut OpusDecoder {
-            opus_decoder_create(Fs, channels, error)
+        unsafe fn opus_decoder_create(Fs: i32, channels: i32) -> Result<*mut OpusDecoder, i32> {
+            let mut error = 0;
+            let res = opus_decoder_create(Fs, channels, &mut error);
+            if res.is_null() {
+                Err(error)
+            } else {
+                Ok(res)
+            }
         }
 
         unsafe fn opus_decode(

unsafe-libopus-tools/src/demo/mod.rs

@@ -103,19 +103,14 @@ fn opus_demo_encode_impl<B: OpusBackendTrait>(
         samples.push(i16::from_le_bytes(data.try_into().unwrap()));
     }
 
-    let mut enc = {
-        let mut err: i32 = 0;
-        let enc = unsafe {
-            B::opus_encoder_create(
-                usize::from(sampling_rate) as i32,
-                channels as i32,
-                application.into_opus(),
-                &mut err,
-            )
-        };
-        handle_opus_error(err, "opus_encoder_create");
-        enc
-    };
+    let mut enc = unsafe {
+        B::opus_encoder_create(
+            usize::from(sampling_rate) as i32,
+            channels as i32,
+            application.into_opus(),
+        )
+    }
+    .expect("opus_encoder_create failed");
 
     let mut skip: i32 = 0;
 
@@ -244,14 +239,9 @@ fn opus_demo_decode_impl<B: OpusBackendTrait>(
 
     let channels: usize = channels.into();
 
-    let mut dec = {
-        let mut err: i32 = 0;
-        let dec = unsafe {
-            B::opus_decoder_create(usize::from(sample_rate) as i32, channels as i32, &mut err)
-        };
-        handle_opus_error(err, "opus_decoder_create()");
-        dec
-    };
+    let mut dec =
+        unsafe { B::opus_decoder_create(usize::from(sample_rate) as i32, channels as i32) }
+            .expect("opus_decoder_create failed");
 
     if options.inbandfec {
         panic!("inbandfec not supported")