1 files changed, 41 insertions, 49 deletions

diff --git a/src/audio/play_queue.rs b/src/audio/play_queue.rs
index 4bb6ade..fcbb4f9 100644
--- a/src/audio/play_queue.rs
+++ b/src/audio/play_queue.rs
@@ -1,20 +1,13 @@
 use std::{
     collections::VecDeque,
-    io::{self, Cursor},
-    iter,
-    process::{
-        Command,
-        Stdio,
-    },
+    io::{self, BufRead, BufReader, Cursor},
+    process,
     sync::{Arc, RwLock},
     thread,
     time::Duration,
 };
 
-use byteorder::{ByteOrder, NativeEndian};
 use either::{Left, Right};
-use itertools::Itertools;
-use lame_sys;
 use serenity::{
     prelude::*,
     voice,
@@ -114,52 +107,51 @@ impl PlayQueue {
                             }
                         }
                     },
-                    Right(ref mut v) => {
-
-//                        let out = unsafe {
-//                            let hip_t = lame_sys::hip_decode_init();
-//
-//                            let mut pcm_l = vec![0; 5 * 1024 * 1024 / 2];
-//                            let mut pcm_r = vec![0; 5 * 1024 * 1024 / 2];
-//
-//                            let count = lame_sys::hip_decode(hip_t,
-//                                                 v.as_mut_ptr(),
-//                                                 v.len(),
-//                                                 pcm_l.as_mut_ptr(),
-//                                                 pcm_r.as_mut_ptr());
-//
-//                            lame_sys::hip_decode_exit(hip_t);
-//
-//                            pcm_l.into_iter()
-//                                .interleave(pcm_r.into_iter())
-//                                .flat_map(|x| {
-//                                    let mut b = vec![0u8; 2];
-//                                    NativeEndian::write_i16(&mut b, x);
-//
-//                                    b.into_iter()
-//                                })
-//                                .collect::<Vec<u8>>()
-//                        };
-
-                        let mut out = Command::new("lame")
+                    Right(ref vec) => {
+                        let mut transcoder = process::Command::new("ffmpeg")
                             .args(&[
-                                "--decode", "-t",
-                                "-", "-",
+                                "-format", "opus",
+                                "-i", "pipe:0",
+                                "-acodec", "pcm_s16le",
+                                "-f", "s16le",
+                                "-"
                             ])
-                            .stdin(Stdio::piped())
-                            .stdout(Stdio::piped())
-                            .stderr(Stdio::piped())
+                            .stdin(process::Stdio::piped())
+                            .stdout(process::Stdio::piped())
+                            .stderr(process::Stdio::piped())
                             .spawn()
-                            .unwrap();
+                            .expect("unable to call ffmpeg");
+
+                        let process::Child {
+                            stdin,
+                            stderr,
+                            stdout,
+                            ..
+                        } = transcoder;
+
+                        thread::spawn(move || {
+                            let stderr = BufReader::new(stderr.unwrap());
 
-                        io::copy(&mut Cursor::new(v), &mut out.stdin.as_mut().unwrap());
-                        let result = voice::pcm(true,  Cursor::new("abc"));
+                            for line in stderr.lines() {
+                                let line = line.unwrap();
 
-//                        out.stdout.as_mut().unwrap()
+                                trace!("{}", line);
+                            }
+                        });
+
+                        let v = vec.clone();
+                        thread::spawn(move || {
+                            if let Err(e) = io::copy(&mut Cursor::new(v), &mut stdin.unwrap()) {
+                                use std::io::ErrorKind;
+                                if e.kind() == ErrorKind::BrokenPipe {
+                                    debug!("ffmpeg closed unexpectedly");
+                                } else {
+                                    error!("copying audio to ffmpeg {}", e);
+                                }
+                            }
+                        });
 
-                        let status = out.wait_with_output().unwrap();
-                        println!("{}", status.status);
-                        println!("{}", String::from_utf8(status.stderr).unwrap());
+                        let result = voice::pcm(true, stdout.unwrap());
 
                         result
                     }