Merge pull request #25 from yupferris/remove-transmute

Remove transmute

Author: ferris

src/audio_unit/mod.rs

@@ -157,42 +157,42 @@ impl AudioUnit {
         if let Some(callback) = self.callback {
             // Here, we transfer ownership of the callback back to the current scope so that it
             // is dropped and cleaned up. Without this line, we would leak the Boxed callback.
-            let _: Box<Box<RenderCallback>> = unsafe { mem::transmute(callback) };
+            let _: Box<Box<RenderCallback>> = unsafe { Box::from_raw(callback as *mut Box<RenderCallback>) };
         }
     }
 
     /// Pass a render callback (aka "Input Procedure") to the audio unit.
     pub fn render_callback(&mut self, f: Option<Box<RenderCallback>>) -> Result<(), Error>
     {
-        unsafe {
-            // Setup render callback. Notice that we relinquish ownership of the Callback
-            // here so that it can be used as the C render callback via a void pointer.
-            // We do however store the *mut so that we can transmute back to a
-            // Box<Box<RenderCallback>> within our AudioUnit's Drop implementation
-            // (otherwise it would leak). The double-boxing is due to incompleteness with
-            // Rust's FnMut implemetation and is necessary to be able to transmute to the
-            // correct pointer size.
-            let callback_ptr: *mut libc::c_void = match f {
-                Some(x) => mem::transmute(Box::new(x)),
-                _ => ptr::null_mut()
-            };
-            let render_callback = au::AURenderCallbackStruct {
-                inputProc: Some(input_proc),
-                inputProcRefCon: callback_ptr
-            };
+        // Setup render callback. Notice that we relinquish ownership of the Callback
+        // here so that it can be used as the C render callback via a void pointer.
+        // We do however store the *mut so that we can convert back to a
+        // Box<Box<RenderCallback>> within our AudioUnit's Drop implementation
+        // (otherwise it would leak). The double-boxing is due to incompleteness with
+        // Rust's FnMut implemetation and is necessary to be able to convert to the
+        // correct pointer size.
+        let callback_ptr = match f {
+            Some(x) => Box::into_raw(Box::new(x)) as *mut libc::c_void,
+            _ => ptr::null_mut()
+        };
+        let render_callback = au::AURenderCallbackStruct {
+            inputProc: Some(input_proc),
+            inputProcRefCon: callback_ptr
+        };
 
+        unsafe {
             try_os_status!(au::AudioUnitSetProperty(
                 self.instance,
                 au::kAudioUnitProperty_SetRenderCallback,
                 Scope::Input as libc::c_uint,
                 Element::Output as libc::c_uint,
                 &render_callback as *const _ as *const libc::c_void,
                 mem::size_of::<au::AURenderCallbackStruct>() as u32));
-
-            self.free_render_callback();
-            self.callback = if !callback_ptr.is_null() { Some(callback_ptr) } else { None };
-            Ok(())
         }
+
+        self.free_render_callback();
+        self.callback = if !callback_ptr.is_null() { Some(callback_ptr) } else { None };
+        Ok(())
     }
 
     /// Start the audio unit.