2020-04-10 17:52:28 +00:00
|
|
|
// Copyright (C) 2020 Mathieu Duponchelle <mathieu@centricular.com>
|
2023-02-24 20:40:54 +00:00
|
|
|
// Copyright (C) 2023 François Laignel <francois@centricular.com>
|
2020-04-10 17:52:28 +00:00
|
|
|
//
|
2022-01-15 18:40:12 +00:00
|
|
|
// This Source Code Form is subject to the terms of the Mozilla Public License, v2.0.
|
|
|
|
// If a copy of the MPL was not distributed with this file, You can obtain one at
|
|
|
|
// <https://mozilla.org/MPL/2.0/>.
|
2020-04-10 17:52:28 +00:00
|
|
|
//
|
2022-01-15 18:40:12 +00:00
|
|
|
// SPDX-License-Identifier: MPL-2.0
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2021-06-03 18:20:54 +00:00
|
|
|
use gst::glib;
|
2020-04-09 22:51:03 +00:00
|
|
|
use gst::prelude::*;
|
|
|
|
use gst::subclass::prelude::*;
|
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
use aws_sdk_transcribestreaming as aws_transcribe;
|
|
|
|
use aws_sdk_transcribestreaming::model;
|
2020-04-09 22:51:03 +00:00
|
|
|
|
|
|
|
use futures::channel::mpsc;
|
|
|
|
use futures::prelude::*;
|
2023-02-24 20:40:54 +00:00
|
|
|
use tokio::{runtime, task};
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2021-06-22 18:53:49 +00:00
|
|
|
use std::cmp::Ordering;
|
2020-04-09 22:51:03 +00:00
|
|
|
use std::collections::VecDeque;
|
2020-04-10 17:52:28 +00:00
|
|
|
use std::sync::Mutex;
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2020-04-10 17:52:28 +00:00
|
|
|
use once_cell::sync::Lazy;
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2022-08-03 22:42:50 +00:00
|
|
|
use super::{AwsTranscriberResultStability, AwsTranscriberVocabularyFilterMethod};
|
2021-06-19 01:27:42 +00:00
|
|
|
|
2020-04-10 17:52:28 +00:00
|
|
|
static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
|
|
|
|
gst::DebugCategory::new(
|
|
|
|
"awstranscribe",
|
|
|
|
gst::DebugColorFlags::empty(),
|
|
|
|
Some("AWS Transcribe element"),
|
|
|
|
)
|
|
|
|
});
|
|
|
|
|
|
|
|
static RUNTIME: Lazy<runtime::Runtime> = Lazy::new(|| {
|
2021-01-09 10:14:31 +00:00
|
|
|
runtime::Builder::new_multi_thread()
|
2020-04-09 22:51:03 +00:00
|
|
|
.enable_all()
|
2021-01-09 10:14:31 +00:00
|
|
|
.worker_threads(1)
|
2020-04-09 22:51:03 +00:00
|
|
|
.build()
|
2020-04-10 17:52:28 +00:00
|
|
|
.unwrap()
|
|
|
|
});
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
const DEFAULT_TRANSCRIBER_REGION: &str = "us-east-1";
|
2021-05-26 13:22:01 +00:00
|
|
|
const DEFAULT_LATENCY: gst::ClockTime = gst::ClockTime::from_seconds(8);
|
2022-10-17 17:48:43 +00:00
|
|
|
const DEFAULT_LATENESS: gst::ClockTime = gst::ClockTime::ZERO;
|
2023-02-24 20:40:54 +00:00
|
|
|
const DEFAULT_LANGUAGE_CODE: &str = "en-US";
|
2021-06-19 01:27:42 +00:00
|
|
|
const DEFAULT_STABILITY: AwsTranscriberResultStability = AwsTranscriberResultStability::Low;
|
2022-08-03 22:42:50 +00:00
|
|
|
const DEFAULT_VOCABULARY_FILTER_METHOD: AwsTranscriberVocabularyFilterMethod =
|
|
|
|
AwsTranscriberVocabularyFilterMethod::Mask;
|
2021-05-26 13:22:01 +00:00
|
|
|
const GRANULARITY: gst::ClockTime = gst::ClockTime::from_mseconds(100);
|
2020-04-09 22:51:03 +00:00
|
|
|
|
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
struct Settings {
|
2021-05-26 13:22:01 +00:00
|
|
|
latency: gst::ClockTime,
|
2021-07-27 00:36:59 +00:00
|
|
|
lateness: gst::ClockTime,
|
2023-02-24 20:40:54 +00:00
|
|
|
language_code: String,
|
2021-02-19 20:54:08 +00:00
|
|
|
vocabulary: Option<String>,
|
2021-06-16 22:53:04 +00:00
|
|
|
session_id: Option<String>,
|
2021-06-19 01:27:42 +00:00
|
|
|
results_stability: AwsTranscriberResultStability,
|
2021-09-27 13:49:12 +00:00
|
|
|
access_key: Option<String>,
|
|
|
|
secret_access_key: Option<String>,
|
2022-06-16 07:16:28 +00:00
|
|
|
session_token: Option<String>,
|
2022-08-03 22:42:50 +00:00
|
|
|
vocabulary_filter: Option<String>,
|
|
|
|
vocabulary_filter_method: AwsTranscriberVocabularyFilterMethod,
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
impl Default for Settings {
|
2020-04-09 22:51:03 +00:00
|
|
|
fn default() -> Self {
|
|
|
|
Self {
|
2021-05-26 13:22:01 +00:00
|
|
|
latency: DEFAULT_LATENCY,
|
2021-07-27 00:36:59 +00:00
|
|
|
lateness: DEFAULT_LATENESS,
|
2023-02-24 20:40:54 +00:00
|
|
|
language_code: DEFAULT_LANGUAGE_CODE.to_string(),
|
2021-02-19 20:54:08 +00:00
|
|
|
vocabulary: None,
|
2021-06-16 22:53:04 +00:00
|
|
|
session_id: None,
|
2021-06-19 01:27:42 +00:00
|
|
|
results_stability: DEFAULT_STABILITY,
|
2021-09-27 13:49:12 +00:00
|
|
|
access_key: None,
|
|
|
|
secret_access_key: None,
|
2022-06-16 07:16:28 +00:00
|
|
|
session_token: None,
|
2022-08-03 22:42:50 +00:00
|
|
|
vocabulary_filter: None,
|
|
|
|
vocabulary_filter_method: DEFAULT_VOCABULARY_FILTER_METHOD,
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
struct TranscriptionSettings {
|
|
|
|
lang_code: model::LanguageCode,
|
|
|
|
sample_rate: i32,
|
|
|
|
vocabulary: Option<String>,
|
|
|
|
vocabulary_filter: Option<String>,
|
|
|
|
vocabulary_filter_method: model::VocabularyFilterMethod,
|
|
|
|
session_id: Option<String>,
|
|
|
|
results_stability: model::PartialResultsStability,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl TranscriptionSettings {
|
|
|
|
fn from(settings: &Settings, sample_rate: i32) -> Self {
|
|
|
|
TranscriptionSettings {
|
|
|
|
lang_code: settings.language_code.as_str().into(),
|
|
|
|
sample_rate,
|
|
|
|
vocabulary: settings.vocabulary.clone(),
|
|
|
|
vocabulary_filter: settings.vocabulary_filter.clone(),
|
|
|
|
vocabulary_filter_method: settings.vocabulary_filter_method.into(),
|
|
|
|
session_id: settings.session_id.clone(),
|
|
|
|
results_stability: settings.results_stability.into(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-09 22:51:03 +00:00
|
|
|
struct State {
|
2023-02-24 20:40:54 +00:00
|
|
|
client: Option<aws_transcribe::Client>,
|
|
|
|
buffer_tx: Option<mpsc::Sender<gst::Buffer>>,
|
2023-02-28 15:28:13 +00:00
|
|
|
transcript_notif_tx: Option<mpsc::Sender<()>>,
|
2023-02-24 20:40:54 +00:00
|
|
|
ws_loop_handle: Option<task::JoinHandle<Result<(), gst::ErrorMessage>>>,
|
2020-04-09 22:51:03 +00:00
|
|
|
in_segment: gst::FormattedSegment<gst::ClockTime>,
|
|
|
|
out_segment: gst::FormattedSegment<gst::ClockTime>,
|
|
|
|
seqnum: gst::Seqnum,
|
|
|
|
buffers: VecDeque<gst::Buffer>,
|
|
|
|
send_eos: bool,
|
|
|
|
discont: bool,
|
2021-06-19 01:27:42 +00:00
|
|
|
partial_index: usize,
|
2021-06-22 18:53:49 +00:00
|
|
|
send_events: bool,
|
|
|
|
start_time: Option<gst::ClockTime>,
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
impl Default for State {
|
2020-04-09 22:51:03 +00:00
|
|
|
fn default() -> Self {
|
|
|
|
Self {
|
2023-02-24 20:40:54 +00:00
|
|
|
client: None,
|
|
|
|
buffer_tx: None,
|
2023-02-28 15:28:13 +00:00
|
|
|
transcript_notif_tx: None,
|
2023-02-24 20:40:54 +00:00
|
|
|
ws_loop_handle: None,
|
2020-04-09 22:51:03 +00:00
|
|
|
in_segment: gst::FormattedSegment::new(),
|
|
|
|
out_segment: gst::FormattedSegment::new(),
|
|
|
|
seqnum: gst::Seqnum::next(),
|
|
|
|
buffers: VecDeque::new(),
|
|
|
|
send_eos: false,
|
|
|
|
discont: true,
|
2021-06-19 01:27:42 +00:00
|
|
|
partial_index: 0,
|
2021-06-22 18:53:49 +00:00
|
|
|
send_events: true,
|
|
|
|
start_time: None,
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-14 17:24:01 +00:00
|
|
|
pub struct Transcriber {
|
2020-04-09 22:51:03 +00:00
|
|
|
srcpad: gst::Pad,
|
|
|
|
sinkpad: gst::Pad,
|
|
|
|
settings: Mutex<Settings>,
|
|
|
|
state: Mutex<State>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Transcriber {
|
2022-10-09 13:06:59 +00:00
|
|
|
fn dequeue(&self) -> bool {
|
2020-04-09 22:51:03 +00:00
|
|
|
/* First, check our pending buffers */
|
2020-04-10 17:52:28 +00:00
|
|
|
let mut items = vec![];
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
let Some(now) = self.obj().current_running_time() else { return true };
|
2021-06-22 18:53:49 +00:00
|
|
|
|
|
|
|
let latency = self.settings.lock().unwrap().latency;
|
|
|
|
|
|
|
|
let mut state = self.state.lock().unwrap();
|
|
|
|
|
|
|
|
if state.start_time.is_none() {
|
|
|
|
state.start_time = Some(now);
|
|
|
|
state.out_segment.set_position(now);
|
|
|
|
}
|
2021-06-19 01:27:42 +00:00
|
|
|
|
2021-06-22 18:53:49 +00:00
|
|
|
let start_time = state.start_time.unwrap();
|
|
|
|
let mut last_position = state.out_segment.position().unwrap();
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2021-06-22 18:53:49 +00:00
|
|
|
let send_eos = state.send_eos && state.buffers.is_empty();
|
|
|
|
|
|
|
|
while let Some(buf) = state.buffers.front() {
|
|
|
|
let pts = buf.pts().unwrap();
|
2022-02-21 17:43:46 +00:00
|
|
|
gst::trace!(
|
2021-06-22 18:53:49 +00:00
|
|
|
CAT,
|
2022-10-09 13:06:59 +00:00
|
|
|
imp: self,
|
2023-02-24 20:40:54 +00:00
|
|
|
"Checking now {now} if item is ready for dequeuing, PTS {pts}, threshold {} vs {}",
|
2021-06-22 18:53:49 +00:00
|
|
|
pts + latency.saturating_sub(3 * GRANULARITY),
|
|
|
|
now - start_time
|
|
|
|
);
|
|
|
|
|
|
|
|
if pts + latency.saturating_sub(3 * GRANULARITY) < now - start_time {
|
|
|
|
/* Safe unwrap, we know we have an item */
|
|
|
|
let mut buf = state.buffers.pop_front().unwrap();
|
2020-05-28 21:55:00 +00:00
|
|
|
|
2021-05-26 13:22:01 +00:00
|
|
|
{
|
2021-06-22 18:53:49 +00:00
|
|
|
let buf_mut = buf.get_mut().unwrap();
|
|
|
|
|
|
|
|
buf_mut.set_pts(start_time + pts);
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2021-06-22 18:53:49 +00:00
|
|
|
|
|
|
|
items.push(buf);
|
|
|
|
} else {
|
|
|
|
break;
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2021-06-22 18:53:49 +00:00
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2021-06-22 18:53:49 +00:00
|
|
|
let seqnum = state.seqnum;
|
|
|
|
|
|
|
|
drop(state);
|
2020-04-09 22:51:03 +00:00
|
|
|
|
|
|
|
/* We're EOS, we can pause and exit early */
|
|
|
|
if send_eos {
|
2020-04-10 17:52:28 +00:00
|
|
|
let _ = self.srcpad.pause_task();
|
|
|
|
|
2020-04-09 22:51:03 +00:00
|
|
|
return self
|
|
|
|
.srcpad
|
2020-06-24 22:33:57 +00:00
|
|
|
.push_event(gst::event::Eos::builder().seqnum(seqnum).build());
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for mut buf in items.drain(..) {
|
2021-06-22 18:53:49 +00:00
|
|
|
let mut pts = buf.pts().unwrap();
|
|
|
|
let mut duration = buf.duration().unwrap();
|
|
|
|
|
|
|
|
match pts.cmp(&last_position) {
|
|
|
|
Ordering::Greater => {
|
|
|
|
let gap_event = gst::event::Gap::builder(last_position)
|
|
|
|
.duration(pts - last_position)
|
|
|
|
.seqnum(seqnum)
|
|
|
|
.build();
|
2023-02-24 20:40:54 +00:00
|
|
|
gst::log!(CAT, "Pushing gap: {last_position} -> {pts}");
|
2021-06-22 18:53:49 +00:00
|
|
|
if !self.srcpad.push_event(gap_event) {
|
|
|
|
return false;
|
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2021-06-22 18:53:49 +00:00
|
|
|
Ordering::Less => {
|
|
|
|
let delta = last_position - pts;
|
|
|
|
|
2022-02-21 17:43:46 +00:00
|
|
|
gst::warning!(
|
2021-06-22 18:53:49 +00:00
|
|
|
CAT,
|
2022-10-09 13:06:59 +00:00
|
|
|
imp: self,
|
2023-02-24 20:40:54 +00:00
|
|
|
"Updating item PTS ({pts} < {last_position}), consider increasing latency",
|
2021-06-22 18:53:49 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
pts = last_position;
|
|
|
|
duration = duration.saturating_sub(delta);
|
|
|
|
|
|
|
|
{
|
|
|
|
let buf_mut = buf.get_mut().unwrap();
|
|
|
|
|
|
|
|
buf_mut.set_pts(pts);
|
|
|
|
buf_mut.set_duration(duration);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => (),
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2021-06-22 18:53:49 +00:00
|
|
|
|
|
|
|
last_position = pts + duration;
|
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
gst::debug!(CAT, "Pushing buffer: {pts} -> {}", pts + duration);
|
2021-06-22 18:53:49 +00:00
|
|
|
|
2020-04-10 17:52:28 +00:00
|
|
|
if self.srcpad.push(buf).is_err() {
|
2020-04-09 22:51:03 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* next, push a gap if we're lagging behind the target position */
|
2022-02-21 17:43:46 +00:00
|
|
|
gst::trace!(
|
2021-06-22 18:53:49 +00:00
|
|
|
CAT,
|
2022-10-09 13:06:59 +00:00
|
|
|
imp: self,
|
2023-02-24 20:40:54 +00:00
|
|
|
"Checking now: {now} if we need to push a gap, last_position: {last_position}, threshold: {}",
|
2021-06-22 18:53:49 +00:00
|
|
|
last_position + latency.saturating_sub(GRANULARITY)
|
|
|
|
);
|
|
|
|
|
|
|
|
if now > last_position + latency.saturating_sub(GRANULARITY) {
|
|
|
|
let duration = now - last_position - latency.saturating_sub(GRANULARITY);
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2021-06-22 18:53:49 +00:00
|
|
|
let gap_event = gst::event::Gap::builder(last_position)
|
2021-05-26 13:22:01 +00:00
|
|
|
.duration(duration)
|
2020-04-09 22:51:03 +00:00
|
|
|
.seqnum(seqnum)
|
|
|
|
.build();
|
2021-06-22 18:53:49 +00:00
|
|
|
|
2022-02-21 17:43:46 +00:00
|
|
|
gst::log!(
|
2021-06-22 18:53:49 +00:00
|
|
|
CAT,
|
2023-02-24 20:40:54 +00:00
|
|
|
"Pushing gap: {last_position} -> {}",
|
2021-06-22 18:53:49 +00:00
|
|
|
last_position + duration
|
|
|
|
);
|
|
|
|
|
|
|
|
last_position += duration;
|
|
|
|
|
2020-04-09 22:51:03 +00:00
|
|
|
if !self.srcpad.push_event(gap_event) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
self.state
|
|
|
|
.lock()
|
|
|
|
.unwrap()
|
|
|
|
.out_segment
|
|
|
|
.set_position(last_position);
|
|
|
|
|
|
|
|
true
|
|
|
|
}
|
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
/// Enqueues a buffer for each of the provided stable items.
|
|
|
|
///
|
|
|
|
/// Returns `true` if at least one buffer was enqueued.
|
2023-02-28 16:38:20 +00:00
|
|
|
fn enqueue(
|
|
|
|
&self,
|
|
|
|
mut items: Vec<model::Item>,
|
|
|
|
partial: bool,
|
|
|
|
lateness: gst::ClockTime,
|
|
|
|
) -> bool {
|
2023-02-28 15:28:13 +00:00
|
|
|
let mut state = self.state.lock().unwrap();
|
2021-07-27 00:36:59 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
if items.len() <= state.partial_index {
|
2022-02-21 17:43:46 +00:00
|
|
|
gst::error!(
|
2021-11-24 12:57:15 +00:00
|
|
|
CAT,
|
2022-10-09 13:06:59 +00:00
|
|
|
imp: self,
|
2021-11-24 12:57:15 +00:00
|
|
|
"sanity check failed, alternative length {} < partial_index {}",
|
2023-02-24 20:40:54 +00:00
|
|
|
items.len(),
|
2021-11-24 12:57:15 +00:00
|
|
|
state.partial_index
|
|
|
|
);
|
|
|
|
|
|
|
|
if !partial {
|
|
|
|
state.partial_index = 0;
|
|
|
|
}
|
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
return false;
|
2021-11-24 12:57:15 +00:00
|
|
|
}
|
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
let mut enqueued = false;
|
2021-05-26 13:22:01 +00:00
|
|
|
|
2023-02-28 16:38:20 +00:00
|
|
|
for item in items.drain(state.partial_index..) {
|
2023-02-24 20:40:54 +00:00
|
|
|
if !item.stable().unwrap_or(false) {
|
2021-06-19 01:27:42 +00:00
|
|
|
break;
|
|
|
|
}
|
2020-05-28 21:55:00 +00:00
|
|
|
|
2023-02-28 16:38:20 +00:00
|
|
|
let Some(content) = item.content else { continue };
|
2020-05-28 21:55:00 +00:00
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
let start_time = ((item.start_time * 1_000_000_000.0) as u64).nseconds() + lateness;
|
|
|
|
let end_time = ((item.end_time * 1_000_000_000.0) as u64).nseconds() + lateness;
|
2021-06-19 01:27:42 +00:00
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
/* Should be sent now */
|
|
|
|
gst::debug!(
|
|
|
|
CAT,
|
|
|
|
imp: self,
|
|
|
|
"Item is ready for queuing: {content}, PTS {start_time}",
|
|
|
|
);
|
2020-05-28 21:55:00 +00:00
|
|
|
|
2023-02-28 16:38:20 +00:00
|
|
|
let mut buf = gst::Buffer::from_mut_slice(content.into_bytes());
|
2023-02-28 15:28:13 +00:00
|
|
|
{
|
|
|
|
let buf = buf.get_mut().unwrap();
|
2021-06-19 01:27:42 +00:00
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
if state.discont {
|
|
|
|
buf.set_flags(gst::BufferFlags::DISCONT);
|
|
|
|
state.discont = false;
|
|
|
|
}
|
2021-06-19 01:27:42 +00:00
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
buf.set_pts(start_time);
|
|
|
|
buf.set_duration(end_time - start_time);
|
2023-02-24 20:40:54 +00:00
|
|
|
}
|
2023-02-28 15:28:13 +00:00
|
|
|
|
|
|
|
state.partial_index += 1;
|
|
|
|
|
|
|
|
state.buffers.push_back(buf);
|
|
|
|
enqueued = true;
|
2021-06-19 01:27:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if !partial {
|
|
|
|
state.partial_index = 0;
|
2020-05-28 21:55:00 +00:00
|
|
|
}
|
2023-02-28 15:28:13 +00:00
|
|
|
|
|
|
|
enqueued
|
2020-05-28 21:55:00 +00:00
|
|
|
}
|
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
fn pad_loop_fn(&self, transcript_notif_rx: &mut mpsc::Receiver<()>) {
|
2021-06-22 18:53:49 +00:00
|
|
|
let mut events = {
|
|
|
|
let mut events = vec![];
|
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
let state = self.state.lock().unwrap();
|
2021-06-22 18:53:49 +00:00
|
|
|
if state.send_events {
|
|
|
|
events.push(
|
|
|
|
gst::event::StreamStart::builder("transcription")
|
|
|
|
.seqnum(state.seqnum)
|
|
|
|
.build(),
|
|
|
|
);
|
|
|
|
|
|
|
|
let caps = gst::Caps::builder("text/x-raw")
|
2021-11-06 07:34:10 +00:00
|
|
|
.field("format", "utf8")
|
2021-06-22 18:53:49 +00:00
|
|
|
.build();
|
|
|
|
events.push(
|
|
|
|
gst::event::Caps::builder(&caps)
|
|
|
|
.seqnum(state.seqnum)
|
|
|
|
.build(),
|
|
|
|
);
|
|
|
|
|
|
|
|
events.push(
|
|
|
|
gst::event::Segment::builder(&state.out_segment)
|
|
|
|
.seqnum(state.seqnum)
|
|
|
|
.build(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
events
|
|
|
|
};
|
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
if !events.is_empty() {
|
|
|
|
for event in events.drain(..) {
|
|
|
|
gst::info!(CAT, imp: self, "Sending {event:?}");
|
|
|
|
self.srcpad.push_event(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
self.state.lock().unwrap().send_events = false;
|
2021-06-22 18:53:49 +00:00
|
|
|
}
|
|
|
|
|
2020-04-09 22:51:03 +00:00
|
|
|
let future = async move {
|
2023-02-28 15:28:13 +00:00
|
|
|
let timeout = tokio::time::sleep(GRANULARITY.into()).fuse();
|
|
|
|
futures::pin_mut!(timeout);
|
|
|
|
|
|
|
|
futures::select! {
|
|
|
|
notif = transcript_notif_rx.next() => {
|
|
|
|
if notif.is_none() {
|
|
|
|
// Transcriber loop terminated
|
|
|
|
self.state.lock().unwrap().send_eos = true;
|
|
|
|
return;
|
|
|
|
};
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2023-02-28 15:28:13 +00:00
|
|
|
_ = timeout => (),
|
|
|
|
};
|
2020-04-10 17:52:28 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
if !self.dequeue() {
|
|
|
|
gst::info!(CAT, imp: self, "Failed to dequeue buffer, pausing");
|
|
|
|
let _ = self.srcpad.pause_task();
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2021-01-09 10:14:31 +00:00
|
|
|
let _enter = RUNTIME.enter();
|
|
|
|
futures::executor::block_on(future)
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn start_task(&self) -> Result<(), gst::LoggableError> {
|
2023-02-24 20:40:54 +00:00
|
|
|
let mut state = self.state.lock().unwrap();
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
let (transcript_notif_tx, mut transcript_notif_rx) = mpsc::channel(1);
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
let imp = self.ref_counted();
|
2023-02-28 15:28:13 +00:00
|
|
|
let res = self
|
|
|
|
.srcpad
|
|
|
|
.start_task(move || imp.pad_loop_fn(&mut transcript_notif_rx));
|
2023-02-24 20:40:54 +00:00
|
|
|
|
2020-04-09 22:51:03 +00:00
|
|
|
if res.is_err() {
|
2023-02-28 15:28:13 +00:00
|
|
|
state.transcript_notif_tx = None;
|
2023-02-24 20:40:54 +00:00
|
|
|
return Err(gst::loggable_error!(CAT, "Failed to start pad task"));
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2023-02-24 20:40:54 +00:00
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
state.transcript_notif_tx = Some(transcript_notif_tx);
|
2023-02-24 20:40:54 +00:00
|
|
|
|
2020-04-09 22:51:03 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
fn stop_task(&self) {
|
|
|
|
let mut state = self.state.lock().unwrap();
|
|
|
|
|
|
|
|
let _ = self.srcpad.stop_task();
|
|
|
|
|
|
|
|
if let Some(ws_loop_handle) = state.ws_loop_handle.take() {
|
|
|
|
ws_loop_handle.abort();
|
|
|
|
}
|
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
state.transcript_notif_tx = None;
|
2023-02-24 20:40:54 +00:00
|
|
|
state.buffer_tx = None;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn stop_ws_loop(&self) {
|
|
|
|
let mut state = self.state.lock().unwrap();
|
|
|
|
|
|
|
|
if let Some(ws_loop_handle) = state.ws_loop_handle.take() {
|
|
|
|
ws_loop_handle.abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
state.buffer_tx = None;
|
|
|
|
}
|
|
|
|
|
2020-04-09 22:51:03 +00:00
|
|
|
fn src_activatemode(
|
|
|
|
&self,
|
|
|
|
_pad: &gst::Pad,
|
2020-04-10 17:52:28 +00:00
|
|
|
_mode: gst::PadMode,
|
2020-04-09 22:51:03 +00:00
|
|
|
active: bool,
|
|
|
|
) -> Result<(), gst::LoggableError> {
|
|
|
|
if active {
|
2022-10-09 13:06:59 +00:00
|
|
|
self.start_task()?;
|
2020-04-09 22:51:03 +00:00
|
|
|
} else {
|
2023-02-24 20:40:54 +00:00
|
|
|
self.stop_task();
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn src_query(&self, pad: &gst::Pad, query: &mut gst::QueryRef) -> bool {
|
2023-02-24 20:40:54 +00:00
|
|
|
gst::log!(CAT, obj: pad, "Handling query {query:?}");
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
use gst::QueryViewMut::*;
|
2020-04-09 22:51:03 +00:00
|
|
|
match query.view_mut() {
|
2023-02-24 20:40:54 +00:00
|
|
|
Latency(q) => {
|
2020-06-24 22:33:57 +00:00
|
|
|
let mut peer_query = gst::query::Latency::new();
|
2020-04-09 22:51:03 +00:00
|
|
|
|
|
|
|
let ret = self.sinkpad.peer_query(&mut peer_query);
|
|
|
|
|
|
|
|
if ret {
|
2021-04-12 12:49:54 +00:00
|
|
|
let (_, min, _) = peer_query.result();
|
2021-05-26 13:22:01 +00:00
|
|
|
let our_latency = self.settings.lock().unwrap().latency;
|
|
|
|
q.set(true, our_latency + min, gst::ClockTime::NONE);
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
ret
|
|
|
|
}
|
2023-02-24 20:40:54 +00:00
|
|
|
Position(q) => {
|
2021-04-12 12:49:54 +00:00
|
|
|
if q.format() == gst::Format::Time {
|
2020-04-09 22:51:03 +00:00
|
|
|
let state = self.state.lock().unwrap();
|
|
|
|
q.set(
|
|
|
|
state
|
2020-04-10 17:52:28 +00:00
|
|
|
.out_segment
|
2021-04-12 12:49:54 +00:00
|
|
|
.to_stream_time(state.out_segment.position()),
|
2020-04-09 22:51:03 +00:00
|
|
|
);
|
|
|
|
true
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
2022-10-23 20:03:22 +00:00
|
|
|
_ => gst::Pad::query_default(pad, Some(&*self.obj()), query),
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn sink_event(&self, pad: &gst::Pad, event: gst::Event) -> bool {
|
2023-02-24 20:40:54 +00:00
|
|
|
gst::log!(CAT, obj: pad, "Handling event {event:?}");
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
use gst::EventView::*;
|
2020-04-09 22:51:03 +00:00
|
|
|
match event.view() {
|
2023-02-24 20:40:54 +00:00
|
|
|
Eos(_) => {
|
|
|
|
self.stop_ws_loop();
|
2021-06-22 18:53:49 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
true
|
|
|
|
}
|
|
|
|
FlushStart(_) => {
|
|
|
|
gst::info!(CAT, imp: self, "Received flush start, disconnecting");
|
|
|
|
let ret = gst::Pad::event_default(pad, Some(&*self.obj()), event);
|
|
|
|
self.stop_task();
|
2020-04-10 17:52:28 +00:00
|
|
|
|
2021-02-09 16:57:34 +00:00
|
|
|
ret
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2023-02-24 20:40:54 +00:00
|
|
|
FlushStop(_) => {
|
2022-10-09 13:06:59 +00:00
|
|
|
gst::info!(CAT, imp: self, "Received flush stop, restarting task");
|
2020-04-10 17:52:28 +00:00
|
|
|
|
2022-10-23 20:03:22 +00:00
|
|
|
if gst::Pad::event_default(pad, Some(&*self.obj()), event) {
|
2022-10-09 13:06:59 +00:00
|
|
|
match self.start_task() {
|
2020-04-10 17:52:28 +00:00
|
|
|
Err(err) => {
|
2023-02-24 20:40:54 +00:00
|
|
|
gst::error!(CAT, imp: self, "Failed to start srcpad task: {err}");
|
2020-04-10 17:52:28 +00:00
|
|
|
false
|
|
|
|
}
|
|
|
|
Ok(_) => true,
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2023-02-24 20:40:54 +00:00
|
|
|
Segment(e) => {
|
2021-04-12 12:49:54 +00:00
|
|
|
let segment = match e.segment().clone().downcast::<gst::ClockTime>() {
|
2020-04-09 22:51:03 +00:00
|
|
|
Err(segment) => {
|
2023-02-24 20:40:54 +00:00
|
|
|
gst::element_imp_error!(
|
2022-10-09 13:06:59 +00:00
|
|
|
self,
|
2020-04-09 22:51:03 +00:00
|
|
|
gst::StreamError::Format,
|
2023-02-24 20:40:54 +00:00
|
|
|
["Only Time segments supported, got {:?}", segment.format()]
|
2020-04-09 22:51:03 +00:00
|
|
|
);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
Ok(segment) => segment,
|
|
|
|
};
|
|
|
|
|
2021-06-22 18:53:49 +00:00
|
|
|
let mut state = self.state.lock().unwrap();
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2021-06-22 18:53:49 +00:00
|
|
|
state.in_segment = segment;
|
|
|
|
state.seqnum = e.seqnum();
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2021-06-22 18:53:49 +00:00
|
|
|
true
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2023-02-24 20:40:54 +00:00
|
|
|
Tag(_) => true,
|
|
|
|
Caps(c) => {
|
|
|
|
gst::info!(CAT, "Received caps {c:?}");
|
2021-06-22 18:53:49 +00:00
|
|
|
true
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2023-02-24 20:40:54 +00:00
|
|
|
StreamStart(_) => true,
|
2022-10-23 20:03:22 +00:00
|
|
|
_ => gst::Pad::event_default(pad, Some(&*self.obj()), event),
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
fn sink_chain(
|
2020-04-09 22:51:03 +00:00
|
|
|
&self,
|
2023-02-24 20:40:54 +00:00
|
|
|
pad: &gst::Pad,
|
|
|
|
buffer: gst::Buffer,
|
2020-04-09 22:51:03 +00:00
|
|
|
) -> Result<gst::FlowSuccess, gst::FlowError> {
|
2023-02-24 20:40:54 +00:00
|
|
|
gst::log!(CAT, obj: pad, "Handling {buffer:?}");
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
self.ensure_connection().map_err(|err| {
|
2023-02-24 20:40:54 +00:00
|
|
|
gst::element_imp_error!(self, gst::StreamError::Failed, ["Streaming failed: {err}"]);
|
2020-04-09 22:51:03 +00:00
|
|
|
gst::FlowError::Error
|
|
|
|
})?;
|
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
let Some(mut buffer_tx) = self.state.lock().unwrap().buffer_tx.take() else {
|
|
|
|
gst::log!(CAT, obj: pad, "Flushing");
|
|
|
|
return Err(gst::FlowError::Flushing);
|
2021-01-09 10:14:31 +00:00
|
|
|
};
|
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
futures::executor::block_on(buffer_tx.send(buffer)).map_err(|err| {
|
|
|
|
gst::element_imp_error!(self, gst::StreamError::Failed, ["Streaming failed: {err}"]);
|
|
|
|
gst::FlowError::Error
|
|
|
|
})?;
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
self.state.lock().unwrap().buffer_tx = Some(buffer_tx);
|
|
|
|
|
|
|
|
Ok(gst::FlowSuccess::Ok)
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn ensure_connection(&self) -> Result<(), gst::ErrorMessage> {
|
2023-02-24 20:40:54 +00:00
|
|
|
enum ClientStage {
|
|
|
|
Ready(aws_transcribe::Client),
|
|
|
|
NotReady {
|
|
|
|
access_key: Option<String>,
|
|
|
|
secret_access_key: Option<String>,
|
|
|
|
session_token: Option<String>,
|
|
|
|
},
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
let (client_stage, transcription_settings, lateness, transcript_notif_tx);
|
|
|
|
{
|
2023-02-24 20:40:54 +00:00
|
|
|
let mut state = self.state.lock().unwrap();
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
if let Some(ref ws_loop_handle) = state.ws_loop_handle {
|
|
|
|
if ws_loop_handle.is_finished() {
|
|
|
|
state.ws_loop_handle = None;
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
const ERR: &str = "ws loop terminated unexpectedly";
|
|
|
|
gst::error!(CAT, imp: self, "{ERR}");
|
|
|
|
return Err(gst::error_msg!(gst::LibraryError::Failed, ["{ERR}"]));
|
|
|
|
}
|
2021-07-27 00:36:59 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
return Ok(());
|
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
transcript_notif_tx = state
|
|
|
|
.transcript_notif_tx
|
2023-02-24 20:40:54 +00:00
|
|
|
.take()
|
|
|
|
.expect("attempting to spawn the ws loop, but the srcpad task hasn't been started");
|
2022-08-04 06:11:41 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
let settings = self.settings.lock().unwrap();
|
2022-08-04 06:11:41 +00:00
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
lateness = settings.lateness;
|
|
|
|
if settings.latency + lateness <= 2 * GRANULARITY {
|
2023-02-24 20:40:54 +00:00
|
|
|
const ERR: &str = "latency + lateness must be greater than 200 milliseconds";
|
|
|
|
gst::error!(CAT, imp: self, "{ERR}");
|
|
|
|
return Err(gst::error_msg!(gst::LibraryError::Settings, ["{ERR}"]));
|
2022-08-04 06:11:41 +00:00
|
|
|
}
|
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
let in_caps = self.sinkpad.current_caps().unwrap();
|
|
|
|
let s = in_caps.structure(0).unwrap();
|
|
|
|
let sample_rate = s.get::<i32>("rate").unwrap();
|
2022-05-17 15:25:08 +00:00
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
transcription_settings = TranscriptionSettings::from(&settings, sample_rate);
|
2022-05-17 15:25:08 +00:00
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
client_stage = if let Some(client) = state.client.take() {
|
2023-02-24 20:40:54 +00:00
|
|
|
ClientStage::Ready(client)
|
|
|
|
} else {
|
|
|
|
ClientStage::NotReady {
|
|
|
|
access_key: settings.access_key.to_owned(),
|
|
|
|
secret_access_key: settings.secret_access_key.to_owned(),
|
|
|
|
session_token: settings.session_token.to_owned(),
|
|
|
|
}
|
|
|
|
};
|
|
|
|
};
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
let client = match client_stage {
|
|
|
|
ClientStage::Ready(client) => client,
|
|
|
|
ClientStage::NotReady {
|
|
|
|
access_key,
|
|
|
|
secret_access_key,
|
|
|
|
session_token,
|
|
|
|
} => {
|
|
|
|
gst::info!(CAT, imp: self, "Connecting...");
|
|
|
|
let _enter_guard = RUNTIME.enter();
|
|
|
|
|
|
|
|
let config_loader = match (access_key, secret_access_key) {
|
|
|
|
(Some(key), Some(secret_key)) => {
|
|
|
|
gst::debug!(CAT, imp: self, "Using settings credentials");
|
|
|
|
aws_config::ConfigLoader::default().credentials_provider(
|
|
|
|
aws_transcribe::Credentials::new(
|
|
|
|
key,
|
|
|
|
secret_key,
|
|
|
|
session_token,
|
|
|
|
None,
|
|
|
|
"translate",
|
|
|
|
),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
gst::debug!(CAT, imp: self, "Attempting to get credentials from env...");
|
|
|
|
aws_config::from_env()
|
|
|
|
}
|
|
|
|
};
|
2021-02-19 20:54:08 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
let config_loader = config_loader.region(
|
|
|
|
aws_config::meta::region::RegionProviderChain::default_provider()
|
|
|
|
.or_else(DEFAULT_TRANSCRIBER_REGION),
|
|
|
|
);
|
|
|
|
let config = futures::executor::block_on(config_loader.load());
|
|
|
|
gst::debug!(CAT, imp: self, "Using region {}", config.region().unwrap());
|
2021-02-19 20:54:08 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
aws_transcribe::Client::new(&config)
|
|
|
|
}
|
|
|
|
};
|
2022-08-03 22:42:50 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
let mut state = self.state.lock().unwrap();
|
2022-08-03 22:42:50 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
let (buffer_tx, buffer_rx) = mpsc::channel(1);
|
|
|
|
let ws_loop_handle = RUNTIME.spawn(self.build_ws_loop_fut(
|
|
|
|
client,
|
|
|
|
transcription_settings,
|
2023-02-28 15:28:13 +00:00
|
|
|
lateness,
|
2023-02-24 20:40:54 +00:00
|
|
|
buffer_rx,
|
2023-02-28 15:28:13 +00:00
|
|
|
transcript_notif_tx,
|
2023-02-24 20:40:54 +00:00
|
|
|
));
|
2021-06-16 22:53:04 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
state.ws_loop_handle = Some(ws_loop_handle);
|
|
|
|
state.buffer_tx = Some(buffer_tx);
|
2022-05-17 15:25:08 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
2021-06-19 01:27:42 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
fn build_ws_loop_fut(
|
|
|
|
&self,
|
|
|
|
client: aws_transcribe::Client,
|
|
|
|
settings: TranscriptionSettings,
|
2023-02-28 15:28:13 +00:00
|
|
|
lateness: gst::ClockTime,
|
2023-02-24 20:40:54 +00:00
|
|
|
buffer_rx: mpsc::Receiver<gst::Buffer>,
|
2023-02-28 15:28:13 +00:00
|
|
|
transcript_notif_tx: mpsc::Sender<()>,
|
2023-02-24 20:40:54 +00:00
|
|
|
) -> impl Future<Output = Result<(), gst::ErrorMessage>> {
|
|
|
|
let imp_weak = self.downgrade();
|
|
|
|
async move {
|
|
|
|
use gst::glib::subclass::ObjectImplWeakRef;
|
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
// Guard that restores client & transcript_notif_tx when the ws loop is done
|
2023-02-24 20:40:54 +00:00
|
|
|
struct Guard {
|
|
|
|
imp_weak: ObjectImplWeakRef<Transcriber>,
|
|
|
|
client: Option<aws_transcribe::Client>,
|
2023-02-28 15:28:13 +00:00
|
|
|
transcript_notif_tx: Option<mpsc::Sender<()>>,
|
2023-02-24 20:40:54 +00:00
|
|
|
}
|
2021-06-22 18:53:49 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
impl Guard {
|
|
|
|
fn client(&self) -> &aws_transcribe::Client {
|
|
|
|
self.client.as_ref().unwrap()
|
|
|
|
}
|
2022-05-17 15:25:08 +00:00
|
|
|
|
2023-02-28 15:28:13 +00:00
|
|
|
fn transcript_notif_tx(&mut self) -> &mut mpsc::Sender<()> {
|
|
|
|
self.transcript_notif_tx.as_mut().unwrap()
|
2023-02-24 20:40:54 +00:00
|
|
|
}
|
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
impl Drop for Guard {
|
|
|
|
fn drop(&mut self) {
|
|
|
|
if let Some(imp) = self.imp_weak.upgrade() {
|
|
|
|
let mut state = imp.state.lock().unwrap();
|
|
|
|
state.client = self.client.take();
|
2023-02-28 15:28:13 +00:00
|
|
|
state.transcript_notif_tx = self.transcript_notif_tx.take();
|
2023-02-24 20:40:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
let mut guard = Guard {
|
|
|
|
imp_weak: imp_weak.clone(),
|
|
|
|
client: Some(client),
|
2023-02-28 15:28:13 +00:00
|
|
|
transcript_notif_tx: Some(transcript_notif_tx),
|
2023-02-24 20:40:54 +00:00
|
|
|
};
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
// Stream the incoming buffers chunked
|
|
|
|
let chunk_stream = buffer_rx.flat_map(move |buffer: gst::Buffer| {
|
|
|
|
async_stream::stream! {
|
|
|
|
let data = buffer.map_readable().unwrap();
|
|
|
|
use aws_transcribe::{model::{AudioEvent, AudioStream}, types::Blob};
|
|
|
|
for chunk in data.chunks(8192) {
|
|
|
|
yield Ok(AudioStream::AudioEvent(AudioEvent::builder().audio_chunk(Blob::new(chunk)).build()));
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2023-02-24 20:40:54 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
let mut transcribe_builder = guard
|
|
|
|
.client()
|
|
|
|
.start_stream_transcription()
|
|
|
|
.language_code(settings.lang_code)
|
|
|
|
.media_sample_rate_hertz(settings.sample_rate)
|
|
|
|
.media_encoding(model::MediaEncoding::Pcm)
|
|
|
|
.enable_partial_results_stabilization(true)
|
|
|
|
.partial_results_stability(settings.results_stability)
|
|
|
|
.set_vocabulary_name(settings.vocabulary)
|
|
|
|
.set_session_id(settings.session_id);
|
|
|
|
|
|
|
|
if let Some(vocabulary_filter) = settings.vocabulary_filter {
|
|
|
|
transcribe_builder = transcribe_builder
|
|
|
|
.vocabulary_filter_name(vocabulary_filter)
|
|
|
|
.vocabulary_filter_method(settings.vocabulary_filter_method);
|
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
let mut output = transcribe_builder
|
|
|
|
.audio_stream(chunk_stream.into())
|
|
|
|
.send()
|
|
|
|
.await
|
|
|
|
.map_err(|err| {
|
|
|
|
let err = format!("Transcribe ws init error: {err}");
|
|
|
|
if let Some(imp) = imp_weak.upgrade() {
|
|
|
|
gst::error!(CAT, imp: imp, "{err}");
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2023-02-24 20:40:54 +00:00
|
|
|
gst::error_msg!(gst::LibraryError::Init, ["{err}"])
|
|
|
|
})?;
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
while let Some(event) = output
|
|
|
|
.transcript_result_stream
|
|
|
|
.recv()
|
|
|
|
.await
|
|
|
|
.map_err(|err| {
|
|
|
|
let err = format!("Transcribe ws stream error: {err}");
|
|
|
|
if let Some(imp) = imp_weak.upgrade() {
|
|
|
|
gst::error!(CAT, imp: imp, "{err}");
|
|
|
|
}
|
|
|
|
gst::error_msg!(gst::LibraryError::Failed, ["{err}"])
|
|
|
|
})?
|
|
|
|
{
|
|
|
|
if let model::TranscriptResultStream::TranscriptEvent(transcript_evt) = event {
|
2023-02-28 15:28:13 +00:00
|
|
|
let mut enqueued = false;
|
|
|
|
|
|
|
|
if let Some(result) = transcript_evt
|
|
|
|
.transcript
|
2023-02-28 16:38:20 +00:00
|
|
|
.and_then(|transcript| transcript.results)
|
|
|
|
.and_then(|mut results| results.drain(..).next())
|
2023-02-28 15:28:13 +00:00
|
|
|
{
|
|
|
|
let Some(imp) = imp_weak.upgrade() else { break };
|
|
|
|
|
|
|
|
gst::trace!(CAT, imp: imp, "Received: {result:?}");
|
|
|
|
|
|
|
|
if let Some(alternative) = result
|
|
|
|
.alternatives
|
2023-02-28 16:38:20 +00:00
|
|
|
.and_then(|mut alternatives| alternatives.drain(..).next())
|
2023-02-28 15:28:13 +00:00
|
|
|
{
|
2023-02-28 16:38:20 +00:00
|
|
|
if let Some(items) = alternative.items {
|
2023-02-28 15:28:13 +00:00
|
|
|
enqueued = imp.enqueue(items, result.is_partial, lateness);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if enqueued && guard.transcript_notif_tx().send(()).await.is_err() {
|
2023-02-24 20:40:54 +00:00
|
|
|
if let Some(imp) = imp_weak.upgrade() {
|
2023-02-28 15:28:13 +00:00
|
|
|
gst::debug!(CAT, imp: imp, "Terminated transcript_notif_tx channel");
|
2023-02-24 20:40:54 +00:00
|
|
|
}
|
2020-04-10 17:52:28 +00:00
|
|
|
break;
|
|
|
|
}
|
2023-02-24 20:40:54 +00:00
|
|
|
} else if let Some(imp) = imp_weak.upgrade() {
|
|
|
|
gst::warning!(
|
|
|
|
CAT,
|
|
|
|
imp: imp,
|
|
|
|
"Transcribe ws returned unknown event: consider upgrading the SDK"
|
|
|
|
)
|
|
|
|
} else {
|
|
|
|
// imp has left the building
|
|
|
|
break;
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
if let Some(imp) = imp_weak.upgrade() {
|
|
|
|
gst::debug!(CAT, imp: imp, "Exiting ws loop");
|
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2023-02-24 20:40:54 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn disconnect(&self) {
|
2020-04-09 22:51:03 +00:00
|
|
|
let mut state = self.state.lock().unwrap();
|
2022-10-09 13:06:59 +00:00
|
|
|
gst::info!(CAT, imp: self, "Unpreparing");
|
2023-02-24 20:40:54 +00:00
|
|
|
self.stop_task();
|
2023-02-28 15:28:13 +00:00
|
|
|
// Also resets discont to true
|
2020-04-09 22:51:03 +00:00
|
|
|
*state = State::default();
|
2023-02-24 20:40:54 +00:00
|
|
|
gst::info!(CAT, imp: self, "Unprepared");
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-07 16:22:24 +00:00
|
|
|
#[glib::object_subclass]
|
2020-04-09 22:51:03 +00:00
|
|
|
impl ObjectSubclass for Transcriber {
|
2022-10-23 15:42:58 +00:00
|
|
|
const NAME: &'static str = "GstAwsTranscriber";
|
2020-11-14 17:24:01 +00:00
|
|
|
type Type = super::Transcriber;
|
2020-04-09 22:51:03 +00:00
|
|
|
type ParentType = gst::Element;
|
|
|
|
|
2020-11-14 17:24:01 +00:00
|
|
|
fn with_class(klass: &Self::Class) -> Self {
|
2021-04-20 12:58:11 +00:00
|
|
|
let templ = klass.pad_template("sink").unwrap();
|
2020-06-22 08:03:52 +00:00
|
|
|
let sinkpad = gst::Pad::builder_with_template(&templ, Some("sink"))
|
|
|
|
.chain_function(|pad, parent, buffer| {
|
|
|
|
Transcriber::catch_panic_pad_function(
|
|
|
|
parent,
|
|
|
|
|| Err(gst::FlowError::Error),
|
2022-10-09 13:06:59 +00:00
|
|
|
|transcriber| transcriber.sink_chain(pad, buffer),
|
2020-06-22 08:03:52 +00:00
|
|
|
)
|
|
|
|
})
|
|
|
|
.event_function(|pad, parent, event| {
|
|
|
|
Transcriber::catch_panic_pad_function(
|
|
|
|
parent,
|
|
|
|
|| false,
|
2022-10-09 13:06:59 +00:00
|
|
|
|transcriber| transcriber.sink_event(pad, event),
|
2020-06-22 08:03:52 +00:00
|
|
|
)
|
|
|
|
})
|
|
|
|
.build();
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2021-04-20 12:58:11 +00:00
|
|
|
let templ = klass.pad_template("src").unwrap();
|
2020-06-22 08:03:52 +00:00
|
|
|
let srcpad = gst::Pad::builder_with_template(&templ, Some("src"))
|
|
|
|
.activatemode_function(|pad, parent, mode, active| {
|
|
|
|
Transcriber::catch_panic_pad_function(
|
|
|
|
parent,
|
2023-02-24 20:40:54 +00:00
|
|
|
|| {
|
|
|
|
Err(gst::loggable_error!(
|
|
|
|
CAT,
|
|
|
|
"Panic activating src pad with mode"
|
|
|
|
))
|
|
|
|
},
|
2022-10-09 13:06:59 +00:00
|
|
|
|transcriber| transcriber.src_activatemode(pad, mode, active),
|
2020-06-22 08:03:52 +00:00
|
|
|
)
|
|
|
|
})
|
|
|
|
.query_function(|pad, parent, query| {
|
|
|
|
Transcriber::catch_panic_pad_function(
|
|
|
|
parent,
|
|
|
|
|| false,
|
2022-10-09 13:06:59 +00:00
|
|
|
|transcriber| transcriber.src_query(pad, query),
|
2020-06-22 08:03:52 +00:00
|
|
|
)
|
|
|
|
})
|
|
|
|
.flags(gst::PadFlags::FIXED_CAPS)
|
|
|
|
.build();
|
2020-04-09 22:51:03 +00:00
|
|
|
|
|
|
|
let settings = Mutex::new(Settings::default());
|
|
|
|
|
|
|
|
Self {
|
|
|
|
srcpad,
|
|
|
|
sinkpad,
|
|
|
|
settings,
|
|
|
|
state: Mutex::new(State::default()),
|
|
|
|
}
|
|
|
|
}
|
2021-01-21 18:21:29 +00:00
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2021-01-21 18:21:29 +00:00
|
|
|
impl ObjectImpl for Transcriber {
|
|
|
|
fn properties() -> &'static [glib::ParamSpec] {
|
|
|
|
static PROPERTIES: Lazy<Vec<glib::ParamSpec>> = Lazy::new(|| {
|
|
|
|
vec![
|
2022-08-18 12:04:15 +00:00
|
|
|
glib::ParamSpecString::builder("language-code")
|
|
|
|
.nick("Language Code")
|
|
|
|
.blurb("The Language of the Stream, see \
|
2021-01-21 18:21:29 +00:00
|
|
|
<https://docs.aws.amazon.com/transcribe/latest/dg/how-streaming-transcription.html> \
|
2022-08-18 12:04:15 +00:00
|
|
|
for an up to date list of allowed languages")
|
2023-02-24 20:40:54 +00:00
|
|
|
.default_value(Some(DEFAULT_LANGUAGE_CODE))
|
2022-08-18 12:04:15 +00:00
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecUInt::builder("latency")
|
|
|
|
.nick("Latency")
|
|
|
|
.blurb("Amount of milliseconds to allow AWS transcribe")
|
|
|
|
.default_value(DEFAULT_LATENCY.mseconds() as u32)
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecUInt::builder("lateness")
|
|
|
|
.nick("Lateness")
|
|
|
|
.blurb("Amount of milliseconds to introduce as lateness")
|
|
|
|
.default_value(DEFAULT_LATENESS.mseconds() as u32)
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecString::builder("vocabulary-name")
|
|
|
|
.nick("Vocabulary Name")
|
|
|
|
.blurb("The name of a custom vocabulary, see \
|
2021-02-19 20:54:08 +00:00
|
|
|
<https://docs.aws.amazon.com/transcribe/latest/dg/how-vocabulary.html> \
|
2022-08-18 12:04:15 +00:00
|
|
|
for more information")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecString::builder("session-id")
|
|
|
|
.nick("Session ID")
|
|
|
|
.blurb("The ID of the transcription session, must be length 36")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
2023-01-21 16:13:48 +00:00
|
|
|
glib::ParamSpecEnum::builder_with_default("results-stability", DEFAULT_STABILITY)
|
2022-08-18 12:04:15 +00:00
|
|
|
.nick("Results stability")
|
|
|
|
.blurb("Defines how fast results should stabilize")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecString::builder("access-key")
|
|
|
|
.nick("Access Key")
|
|
|
|
.blurb("AWS Access Key")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecString::builder("secret-access-key")
|
|
|
|
.nick("Secret Access Key")
|
|
|
|
.blurb("AWS Secret Access Key")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecString::builder("session-token")
|
|
|
|
.nick("Session Token")
|
|
|
|
.blurb("AWS temporary Session Token from STS")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecString::builder("vocabulary-filter-name")
|
|
|
|
.nick("Vocabulary Filter Name")
|
|
|
|
.blurb("The name of a custom filter vocabulary, see \
|
2022-08-03 22:42:50 +00:00
|
|
|
<https://docs.aws.amazon.com/transcribe/latest/help-panel/vocab-filter.html> \
|
2022-08-18 12:04:15 +00:00
|
|
|
for more information")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
2023-01-21 16:13:48 +00:00
|
|
|
glib::ParamSpecEnum::builder_with_default("vocabulary-filter-method", DEFAULT_VOCABULARY_FILTER_METHOD)
|
2022-08-18 12:04:15 +00:00
|
|
|
.nick("Vocabulary Filter Method")
|
|
|
|
.blurb("Defines how filtered words will be edited, has no effect when vocabulary-filter-name isn't set")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
2021-01-21 18:21:29 +00:00
|
|
|
]
|
|
|
|
});
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2021-01-21 18:21:29 +00:00
|
|
|
PROPERTIES.as_ref()
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn constructed(&self) {
|
|
|
|
self.parent_constructed();
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2022-10-23 20:03:22 +00:00
|
|
|
let obj = self.obj();
|
2020-11-14 17:24:01 +00:00
|
|
|
obj.add_pad(&self.sinkpad).unwrap();
|
|
|
|
obj.add_pad(&self.srcpad).unwrap();
|
|
|
|
obj.set_element_flags(gst::ElementFlags::PROVIDE_CLOCK | gst::ElementFlags::REQUIRE_CLOCK);
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
|
2021-04-12 12:49:54 +00:00
|
|
|
match pspec.name() {
|
2022-09-08 20:07:49 +00:00
|
|
|
"language-code" => {
|
2020-04-09 22:51:03 +00:00
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
settings.language_code = value.get().expect("type checked upstream");
|
|
|
|
}
|
2021-01-21 18:21:29 +00:00
|
|
|
"latency" => {
|
2020-04-09 22:51:03 +00:00
|
|
|
let mut settings = self.settings.lock().unwrap();
|
2021-05-26 13:22:01 +00:00
|
|
|
settings.latency = gst::ClockTime::from_mseconds(
|
|
|
|
value.get::<u32>().expect("type checked upstream").into(),
|
|
|
|
);
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2021-07-27 00:36:59 +00:00
|
|
|
"lateness" => {
|
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
settings.lateness = gst::ClockTime::from_mseconds(
|
|
|
|
value.get::<u32>().expect("type checked upstream").into(),
|
|
|
|
);
|
|
|
|
}
|
2021-02-19 20:54:08 +00:00
|
|
|
"vocabulary-name" => {
|
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
settings.vocabulary = value.get().expect("type checked upstream");
|
|
|
|
}
|
2021-06-16 22:53:04 +00:00
|
|
|
"session-id" => {
|
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
settings.session_id = value.get().expect("type checked upstream");
|
|
|
|
}
|
2021-06-19 01:27:42 +00:00
|
|
|
"results-stability" => {
|
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
settings.results_stability = value
|
|
|
|
.get::<AwsTranscriberResultStability>()
|
|
|
|
.expect("type checked upstream");
|
|
|
|
}
|
2021-09-27 13:49:12 +00:00
|
|
|
"access-key" => {
|
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
settings.access_key = value.get().expect("type checked upstream");
|
|
|
|
}
|
|
|
|
"secret-access-key" => {
|
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
settings.secret_access_key = value.get().expect("type checked upstream");
|
|
|
|
}
|
2022-06-16 07:16:28 +00:00
|
|
|
"session-token" => {
|
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
settings.session_token = value.get().expect("type checked upstream");
|
|
|
|
}
|
2022-08-03 22:42:50 +00:00
|
|
|
"vocabulary-filter-name" => {
|
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
settings.vocabulary_filter = value.get().expect("type checked upstream");
|
|
|
|
}
|
|
|
|
"vocabulary-filter-method" => {
|
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
settings.vocabulary_filter_method = value
|
|
|
|
.get::<AwsTranscriberVocabularyFilterMethod>()
|
|
|
|
.expect("type checked upstream");
|
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
_ => unimplemented!(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
|
2021-04-12 12:49:54 +00:00
|
|
|
match pspec.name() {
|
2021-01-21 18:21:29 +00:00
|
|
|
"language-code" => {
|
2020-04-09 22:51:03 +00:00
|
|
|
let settings = self.settings.lock().unwrap();
|
2020-11-19 15:55:57 +00:00
|
|
|
settings.language_code.to_value()
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2021-01-21 18:21:29 +00:00
|
|
|
"latency" => {
|
2020-04-09 22:51:03 +00:00
|
|
|
let settings = self.settings.lock().unwrap();
|
2021-05-26 13:22:01 +00:00
|
|
|
(settings.latency.mseconds() as u32).to_value()
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
2021-07-27 00:36:59 +00:00
|
|
|
"lateness" => {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
(settings.lateness.mseconds() as u32).to_value()
|
|
|
|
}
|
2021-02-19 20:54:08 +00:00
|
|
|
"vocabulary-name" => {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
settings.vocabulary.to_value()
|
|
|
|
}
|
2021-06-16 22:53:04 +00:00
|
|
|
"session-id" => {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
settings.session_id.to_value()
|
|
|
|
}
|
2021-06-19 01:27:42 +00:00
|
|
|
"results-stability" => {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
settings.results_stability.to_value()
|
|
|
|
}
|
2021-09-27 13:49:12 +00:00
|
|
|
"access-key" => {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
settings.access_key.to_value()
|
|
|
|
}
|
|
|
|
"secret-access-key" => {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
settings.secret_access_key.to_value()
|
|
|
|
}
|
2022-06-16 07:16:28 +00:00
|
|
|
"session-token" => {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
settings.session_token.to_value()
|
|
|
|
}
|
2022-08-03 22:42:50 +00:00
|
|
|
"vocabulary-filter-name" => {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
settings.vocabulary_filter.to_value()
|
|
|
|
}
|
|
|
|
"vocabulary-filter-method" => {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
settings.vocabulary_filter_method.to_value()
|
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
_ => unimplemented!(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-23 08:57:31 +00:00
|
|
|
impl GstObjectImpl for Transcriber {}
|
|
|
|
|
2020-04-09 22:51:03 +00:00
|
|
|
impl ElementImpl for Transcriber {
|
2021-01-21 18:21:29 +00:00
|
|
|
fn metadata() -> Option<&'static gst::subclass::ElementMetadata> {
|
|
|
|
static ELEMENT_METADATA: Lazy<gst::subclass::ElementMetadata> = Lazy::new(|| {
|
|
|
|
gst::subclass::ElementMetadata::new(
|
|
|
|
"Transcriber",
|
|
|
|
"Audio/Text/Filter",
|
|
|
|
"Speech to Text filter, using AWS transcribe",
|
2023-02-24 20:40:54 +00:00
|
|
|
"Jordan Petridis <jordan@centricular.com>, Mathieu Duponchelle <mathieu@centricular.com>, François Laignel <francois@centricular.com>",
|
2021-01-21 18:21:29 +00:00
|
|
|
)
|
|
|
|
});
|
|
|
|
|
|
|
|
Some(&*ELEMENT_METADATA)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn pad_templates() -> &'static [gst::PadTemplate] {
|
|
|
|
static PAD_TEMPLATES: Lazy<Vec<gst::PadTemplate>> = Lazy::new(|| {
|
|
|
|
let src_caps = gst::Caps::builder("text/x-raw")
|
2021-11-06 07:34:10 +00:00
|
|
|
.field("format", "utf8")
|
2021-01-21 18:21:29 +00:00
|
|
|
.build();
|
|
|
|
let src_pad_template = gst::PadTemplate::new(
|
|
|
|
"src",
|
|
|
|
gst::PadDirection::Src,
|
|
|
|
gst::PadPresence::Always,
|
|
|
|
&src_caps,
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
|
2022-10-13 18:02:04 +00:00
|
|
|
let sink_caps = gst_audio::AudioCapsBuilder::new()
|
|
|
|
.format(gst_audio::AudioFormat::S16le)
|
|
|
|
.rate_range(8000..=48000)
|
|
|
|
.channels(1)
|
2021-01-21 18:21:29 +00:00
|
|
|
.build();
|
|
|
|
let sink_pad_template = gst::PadTemplate::new(
|
|
|
|
"sink",
|
|
|
|
gst::PadDirection::Sink,
|
|
|
|
gst::PadPresence::Always,
|
|
|
|
&sink_caps,
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
vec![src_pad_template, sink_pad_template]
|
|
|
|
});
|
|
|
|
|
|
|
|
PAD_TEMPLATES.as_ref()
|
|
|
|
}
|
|
|
|
|
2020-04-09 22:51:03 +00:00
|
|
|
fn change_state(
|
|
|
|
&self,
|
|
|
|
transition: gst::StateChange,
|
|
|
|
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
|
2023-02-24 20:40:54 +00:00
|
|
|
gst::info!(CAT, imp: self, "Changing state {transition:?}");
|
2020-04-09 22:51:03 +00:00
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
let mut success = self.parent_change_state(transition)?;
|
2021-06-22 18:53:49 +00:00
|
|
|
|
2020-04-09 22:51:03 +00:00
|
|
|
match transition {
|
|
|
|
gst::StateChange::PausedToReady => {
|
2022-10-09 13:06:59 +00:00
|
|
|
self.disconnect();
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|
|
|
|
gst::StateChange::ReadyToPaused => {
|
|
|
|
success = gst::StateChangeSuccess::NoPreroll;
|
|
|
|
}
|
|
|
|
gst::StateChange::PlayingToPaused => {
|
|
|
|
success = gst::StateChangeSuccess::NoPreroll;
|
|
|
|
}
|
|
|
|
_ => (),
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(success)
|
|
|
|
}
|
2020-06-02 17:31:58 +00:00
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn provide_clock(&self) -> Option<gst::Clock> {
|
2020-06-02 17:31:58 +00:00
|
|
|
Some(gst::SystemClock::obtain())
|
|
|
|
}
|
2020-04-09 22:51:03 +00:00
|
|
|
}
|