2022-10-01 15:38:03 +00:00
|
|
|
mod server;
|
|
|
|
|
2022-10-01 11:32:43 +00:00
|
|
|
use anyhow::Result;
|
|
|
|
use gst::glib;
|
|
|
|
use gst::glib::once_cell::sync::Lazy;
|
2022-10-01 15:38:03 +00:00
|
|
|
use gst::prelude::*;
|
2023-03-26 20:26:46 +00:00
|
|
|
use rand::prelude::*;
|
2023-03-26 00:05:57 +00:00
|
|
|
use std::thread;
|
2023-03-26 16:34:10 +00:00
|
|
|
use std::thread::sleep;
|
2022-10-01 15:38:03 +00:00
|
|
|
use tokio::runtime::Builder;
|
2022-10-01 11:32:43 +00:00
|
|
|
|
|
|
|
static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
|
2022-10-01 15:38:03 +00:00
|
|
|
gst::DebugCategory::new("main", gst::DebugColorFlags::empty(), Some("Main function"))
|
2022-10-01 11:32:43 +00:00
|
|
|
});
|
|
|
|
|
2023-03-26 20:26:46 +00:00
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
|
|
struct DtmfEvent(i32);
|
|
|
|
|
|
|
|
impl TryFrom<&gst::StructureRef> for DtmfEvent {
|
|
|
|
type Error = anyhow::Error;
|
|
|
|
|
|
|
|
fn try_from(structure: &gst::StructureRef) -> anyhow::Result<Self> {
|
|
|
|
let name = structure.name().to_string();
|
|
|
|
if name != "dtmf-event" {
|
|
|
|
anyhow::bail!("Not a dtmf-event structure: {name}");
|
|
|
|
}
|
|
|
|
let number = structure.get::<i32>("number")?;
|
|
|
|
Ok(Self(number))
|
|
|
|
}
|
2023-03-26 17:49:26 +00:00
|
|
|
}
|
|
|
|
|
2023-03-26 20:26:46 +00:00
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
|
|
enum DtmfCommand {
|
|
|
|
Start(i32),
|
|
|
|
End(Option<i32>),
|
2023-03-26 16:34:10 +00:00
|
|
|
}
|
|
|
|
|
2023-03-26 20:26:46 +00:00
|
|
|
impl DtmfCommand {
|
2023-03-26 17:49:26 +00:00
|
|
|
fn start(number: i32) -> Self {
|
2023-03-26 20:26:46 +00:00
|
|
|
Self::Start(number)
|
2023-03-26 16:34:10 +00:00
|
|
|
}
|
|
|
|
|
2023-03-26 17:49:26 +00:00
|
|
|
fn end(self) -> Self {
|
|
|
|
match self {
|
2023-03-26 20:26:46 +00:00
|
|
|
Self::Start(number) => Self::End(Some(number)),
|
2023-03-26 17:49:26 +00:00
|
|
|
Self::End(_) => self,
|
|
|
|
}
|
2023-03-26 16:34:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-26 20:26:46 +00:00
|
|
|
impl TryFrom<&gst::StructureRef> for DtmfCommand {
|
2023-03-26 16:34:10 +00:00
|
|
|
type Error = anyhow::Error;
|
|
|
|
|
|
|
|
fn try_from(structure: &gst::StructureRef) -> anyhow::Result<Self> {
|
|
|
|
let name = structure.name().to_string();
|
|
|
|
if !name.starts_with("dtmf-event") {
|
|
|
|
anyhow::bail!("Not a dtmf-event structure: {name}");
|
|
|
|
}
|
2023-03-26 20:26:46 +00:00
|
|
|
let number = structure.get_optional::<i32>("number")?;
|
|
|
|
if structure.get::<bool>("start")? {
|
|
|
|
Ok(Self::Start(number.ok_or_else(|| {
|
|
|
|
anyhow::anyhow!("No number specified for start DTMF command")
|
|
|
|
})?))
|
2023-03-26 17:49:26 +00:00
|
|
|
} else {
|
|
|
|
Ok(Self::End(number))
|
|
|
|
}
|
2023-03-26 16:34:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-26 20:26:46 +00:00
|
|
|
impl TryFrom<DtmfCommand> for gst::Structure {
|
|
|
|
type Error = anyhow::Error;
|
|
|
|
|
|
|
|
fn try_from(event: DtmfCommand) -> anyhow::Result<Self> {
|
|
|
|
let structure = match event {
|
|
|
|
DtmfCommand::Start(number) => gst::Structure::builder("dtmf-event")
|
|
|
|
.field("type", 1)
|
|
|
|
.field("start", true)
|
|
|
|
.field("number", number)
|
|
|
|
.field("volume", 36)
|
|
|
|
.build(),
|
|
|
|
DtmfCommand::End(number) => {
|
|
|
|
let Some(number) = number else {
|
|
|
|
anyhow::bail!("Cannot send end DTMF command without a specified number");
|
|
|
|
};
|
2023-03-26 17:49:26 +00:00
|
|
|
gst::Structure::builder("dtmf-event")
|
|
|
|
.field("type", 1)
|
|
|
|
.field("start", false)
|
|
|
|
.field("number", number)
|
|
|
|
.build()
|
|
|
|
}
|
2023-03-26 20:26:46 +00:00
|
|
|
};
|
|
|
|
Ok(structure)
|
2023-03-26 16:34:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-01 11:32:43 +00:00
|
|
|
fn main() -> Result<()> {
|
|
|
|
gst::init()?;
|
|
|
|
|
2022-10-01 15:38:03 +00:00
|
|
|
let pipeline = gst::parse_launch(
|
|
|
|
r#"
|
2022-10-01 11:32:43 +00:00
|
|
|
|
2023-03-26 16:34:10 +00:00
|
|
|
dtmfsrc name=src ! mix.
|
2023-03-26 20:26:46 +00:00
|
|
|
audiotestsrc freq=0 ! audiomixer name=mix ! dtmfdetect ! audioconvert ! autoaudiosink name=audiosink
|
2022-10-01 11:32:43 +00:00
|
|
|
|
2022-10-01 15:38:03 +00:00
|
|
|
"#,
|
|
|
|
)?
|
|
|
|
.downcast::<gst::Pipeline>()
|
|
|
|
.unwrap();
|
2022-10-01 11:32:43 +00:00
|
|
|
|
|
|
|
let context = glib::MainContext::default();
|
|
|
|
let main_loop = glib::MainLoop::new(Some(&context), false);
|
|
|
|
|
|
|
|
let bus = pipeline.bus().unwrap();
|
|
|
|
bus.add_watch({
|
|
|
|
let main_loop = main_loop.clone();
|
|
|
|
move |_, msg| {
|
|
|
|
use gst::MessageView;
|
|
|
|
let main_loop = &main_loop;
|
|
|
|
match msg.view() {
|
|
|
|
MessageView::Eos(..) => main_loop.quit(),
|
|
|
|
MessageView::Error(err) => {
|
2023-03-26 20:26:46 +00:00
|
|
|
gst::error!(CAT, obj: err.src().unwrap(),
|
2022-10-01 11:32:43 +00:00
|
|
|
"Error from {:?}: {} ({:?})",
|
|
|
|
err.src().map(|s| s.path_string()),
|
|
|
|
err.error(),
|
|
|
|
err.debug()
|
|
|
|
);
|
|
|
|
main_loop.quit();
|
2023-03-26 20:26:46 +00:00
|
|
|
}
|
2023-03-26 16:34:10 +00:00
|
|
|
MessageView::Element(element) => {
|
|
|
|
match element.structure().unwrap().name().as_str() {
|
|
|
|
"dtmf-event" => {
|
2023-03-26 20:26:46 +00:00
|
|
|
let dtmf_event = DtmfEvent::try_from(element.structure().unwrap())
|
|
|
|
.expect("Failed to parse DTMF event");
|
|
|
|
gst::info!(CAT, "Detected DTMF event: {:?}", dtmf_event);
|
2023-03-26 16:34:10 +00:00
|
|
|
}
|
|
|
|
"dtmf-event-processed" => {
|
2023-03-26 20:26:46 +00:00
|
|
|
let dtmf_cmd = match DtmfCommand::try_from(element.structure().unwrap())
|
|
|
|
{
|
|
|
|
Ok(ev) => ev,
|
|
|
|
Err(err) => {
|
|
|
|
gst::error!(
|
|
|
|
CAT,
|
|
|
|
"Failed to parse DTMF event {:?} with error: {:?}",
|
|
|
|
element.structure().unwrap(),
|
|
|
|
err
|
|
|
|
);
|
|
|
|
return glib::Continue(true);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
match dtmf_cmd {
|
|
|
|
DtmfCommand::Start(number) => {
|
|
|
|
gst::info!(CAT, "Processed DTMF event {}", number);
|
2023-03-26 17:49:26 +00:00
|
|
|
}
|
2023-03-26 20:26:46 +00:00
|
|
|
DtmfCommand::End(_) => {
|
|
|
|
gst::info!(CAT, "Processed ending DTMF event");
|
2023-03-26 17:49:26 +00:00
|
|
|
}
|
2023-03-26 16:34:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => {
|
2023-03-26 20:26:46 +00:00
|
|
|
gst::error!(
|
|
|
|
CAT,
|
|
|
|
"Received unknown event: {:?}",
|
|
|
|
element.structure().unwrap().name()
|
|
|
|
);
|
2023-03-26 16:34:10 +00:00
|
|
|
}
|
|
|
|
}
|
2022-10-01 11:32:43 +00:00
|
|
|
}
|
|
|
|
_ => (),
|
|
|
|
};
|
|
|
|
glib::Continue(true)
|
|
|
|
}
|
|
|
|
})
|
2022-10-01 15:38:03 +00:00
|
|
|
.expect("Failed to add bus watch");
|
|
|
|
|
2023-03-26 16:34:10 +00:00
|
|
|
thread::spawn({
|
|
|
|
let pipeline_weak = pipeline.downgrade();
|
|
|
|
move || {
|
|
|
|
let Some(pipeline) = pipeline_weak.upgrade() else {
|
|
|
|
gst::error!(CAT, "Pipeline gone...");
|
|
|
|
return;
|
|
|
|
};
|
|
|
|
|
|
|
|
let source = pipeline.by_name("src").unwrap();
|
|
|
|
|
2023-03-26 20:26:46 +00:00
|
|
|
// wait pipeline to be running
|
|
|
|
let bus = pipeline.bus().unwrap();
|
|
|
|
while let Some(msg) = bus.timed_pop(None) {
|
|
|
|
use gst::MessageView;
|
|
|
|
if let MessageView::StateChanged(state_changed) = msg.view() {
|
|
|
|
if state_changed.src().unwrap() == &source
|
|
|
|
&& state_changed.current() == gst::State::Playing
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
gst::info!(CAT, "Pipeline is running");
|
|
|
|
|
2023-03-26 16:34:10 +00:00
|
|
|
let mut rng = rand::thread_rng();
|
|
|
|
loop {
|
2023-03-26 20:26:46 +00:00
|
|
|
let dtmf_cmd = DtmfCommand::start(rng.gen_range(0..15));
|
2023-03-26 16:34:10 +00:00
|
|
|
|
2023-03-26 20:26:46 +00:00
|
|
|
source.send_event(gst::event::CustomUpstream::new(
|
|
|
|
dtmf_cmd.try_into().unwrap(),
|
|
|
|
));
|
|
|
|
gst::info!(CAT, "Sent DTMF event {:?}", dtmf_cmd);
|
2023-03-26 16:34:10 +00:00
|
|
|
|
|
|
|
sleep(std::time::Duration::from_millis(10));
|
|
|
|
|
2023-03-26 20:26:46 +00:00
|
|
|
source.send_event(gst::event::CustomUpstream::new(
|
|
|
|
dtmf_cmd.end().try_into().unwrap(),
|
|
|
|
));
|
2023-03-26 16:34:10 +00:00
|
|
|
|
|
|
|
sleep(std::time::Duration::from_millis(1000));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2022-10-01 15:38:03 +00:00
|
|
|
thread::spawn({
|
|
|
|
let pipeline_weak = pipeline.downgrade();
|
|
|
|
move || {
|
|
|
|
let runtime = Builder::new_multi_thread()
|
|
|
|
.worker_threads(2)
|
|
|
|
.thread_name("http-server")
|
|
|
|
.enable_all()
|
|
|
|
.build()
|
|
|
|
.unwrap();
|
|
|
|
runtime.block_on(server::run(8080, pipeline_weak))
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2023-03-26 20:26:46 +00:00
|
|
|
pipeline.set_state(gst::State::Playing)?;
|
|
|
|
|
2022-10-01 15:38:03 +00:00
|
|
|
ctrlc::set_handler({
|
2023-03-26 00:05:57 +00:00
|
|
|
let main_loop = main_loop.clone();
|
2022-10-01 15:38:03 +00:00
|
|
|
move || {
|
2023-03-26 00:05:57 +00:00
|
|
|
main_loop.quit();
|
2022-10-01 15:38:03 +00:00
|
|
|
}
|
|
|
|
})?;
|
2022-10-01 11:32:43 +00:00
|
|
|
|
|
|
|
main_loop.run();
|
|
|
|
|
|
|
|
pipeline.set_state(gst::State::Null)?;
|
|
|
|
bus.remove_watch().unwrap();
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|