Implement Drop for FrameData

The types `Frame` and `FrameData` are mutually recursive, and the
incidental linked lists that can be formed as a result can be long (at
least in the order of thousands of elements). As a result, when a frame
is deallocated, rust appears to recursively call `drop_in_place` down
the list, causing stack overflows for long lists.

Author: gridbugs

src/source/buffered.rs

@@ -1,4 +1,5 @@
 use std::cmp;
+use std::mem;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
@@ -66,6 +67,31 @@ where
     next: Mutex<Arc<Frame<I>>>,
 }
 
+impl<I> Drop for FrameData<I>
+where
+    I: Source,
+    I::Item: Sample,
+{
+    fn drop(&mut self) {
+        loop {
+            if let Ok(arc_next) = self.next.get_mut() {
+                if let Some(next_ref) = Arc::get_mut(arc_next) {
+                    let next = mem::replace(next_ref, Frame::End);
+                    if let Frame::Data(next_data) = next {
+                        mem::replace(self, next_data);
+                    } else {
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            } else {
+                break;
+            }
+        }
+    }
+}
+
 /// Builds a frame from the input iterator.
 fn extract<I>(mut input: I) -> Arc<Frame<I>>
 where