2019-01-01 13:13:17 +00:00
|
|
|
// Copyright (C) 2019 Sebastian Dröge <sebastian@centricular.com>
|
|
|
|
// Copyright (C) 2019 Jordan Petridis <jordan@centricular.com>
|
|
|
|
//
|
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/>.
|
2019-01-01 13:13:17 +00:00
|
|
|
//
|
2022-01-15 18:40:12 +00:00
|
|
|
// SPDX-License-Identifier: MPL-2.0
|
2019-01-01 13:13:17 +00:00
|
|
|
|
2021-06-03 18:20:54 +00:00
|
|
|
use gst::glib;
|
2019-01-01 13:13:17 +00:00
|
|
|
use gst::prelude::*;
|
2019-08-12 22:45:36 +00:00
|
|
|
use gst::structure;
|
2019-01-01 13:13:17 +00:00
|
|
|
use gst::subclass::prelude::*;
|
2020-12-20 18:43:45 +00:00
|
|
|
use gst::{gst_error, gst_log, gst_trace};
|
2019-01-01 13:13:17 +00:00
|
|
|
use gst_video::{self, ValidVideoTimeCode};
|
|
|
|
|
2020-11-22 17:21:45 +00:00
|
|
|
use once_cell::sync::Lazy;
|
|
|
|
|
2019-01-01 13:13:17 +00:00
|
|
|
use std::io::Write;
|
|
|
|
use std::sync::Mutex;
|
|
|
|
|
2022-01-08 00:26:50 +00:00
|
|
|
const DEFAULT_OUTPUT_PADDING: bool = true;
|
|
|
|
|
2020-11-22 17:21:45 +00:00
|
|
|
static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
|
|
|
|
gst::DebugCategory::new(
|
|
|
|
"sccenc",
|
|
|
|
gst::DebugColorFlags::empty(),
|
|
|
|
Some("Scc Encoder Element"),
|
|
|
|
)
|
|
|
|
});
|
2019-01-01 13:13:17 +00:00
|
|
|
|
2022-01-08 00:26:50 +00:00
|
|
|
#[derive(Clone, Debug)]
|
|
|
|
struct Settings {
|
|
|
|
output_padding: bool,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for Settings {
|
|
|
|
fn default() -> Self {
|
|
|
|
Self {
|
|
|
|
output_padding: DEFAULT_OUTPUT_PADDING,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-01 13:13:17 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
struct State {
|
|
|
|
need_headers: bool,
|
|
|
|
expected_timecode: Option<ValidVideoTimeCode>,
|
|
|
|
internal_buffer: Vec<gst::Buffer>,
|
|
|
|
framerate: Option<gst::Fraction>,
|
2022-01-08 00:26:50 +00:00
|
|
|
settings: Settings,
|
2019-01-01 13:13:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for State {
|
|
|
|
fn default() -> Self {
|
|
|
|
Self {
|
|
|
|
need_headers: true,
|
|
|
|
expected_timecode: None,
|
|
|
|
internal_buffer: Vec::with_capacity(64),
|
|
|
|
framerate: None,
|
2022-01-08 00:26:50 +00:00
|
|
|
settings: Settings::default(),
|
2019-01-01 13:13:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl State {
|
|
|
|
// Write the header to the buffer and set need_headers to false
|
|
|
|
fn generate_headers(&mut self, buffer: &mut Vec<u8>) {
|
|
|
|
assert!(buffer.is_empty());
|
|
|
|
self.need_headers = false;
|
|
|
|
buffer.extend_from_slice(b"Scenarist_SCC V1.0\r\n\r\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
fn encode_payload(outbuf: &mut Vec<u8>, slice: &[u8]) {
|
|
|
|
write!(outbuf, "{:02x}{:02x}", slice[0], slice[1]).unwrap();
|
|
|
|
}
|
|
|
|
|
|
|
|
fn generate_caption(
|
|
|
|
&mut self,
|
2020-11-15 13:50:12 +00:00
|
|
|
element: &super::SccEnc,
|
2019-01-01 13:13:17 +00:00
|
|
|
buffer: gst::Buffer,
|
|
|
|
) -> Result<Option<gst::Buffer>, gst::FlowError> {
|
|
|
|
// Arbitrary number that was chosen to keep in order
|
|
|
|
// to batch pushes of smaller buffers
|
|
|
|
const MAXIMUM_PACKETES_PER_LINE: usize = 16;
|
|
|
|
|
|
|
|
assert!(self.internal_buffer.len() < MAXIMUM_PACKETES_PER_LINE);
|
|
|
|
|
2021-04-12 12:49:54 +00:00
|
|
|
if buffer.size() != 2 {
|
2020-12-20 18:43:45 +00:00
|
|
|
gst::element_error!(
|
2019-01-01 13:13:17 +00:00
|
|
|
element,
|
|
|
|
gst::StreamError::Format,
|
2021-04-12 12:49:54 +00:00
|
|
|
["Wrongly sized CEA608 packet: {}", buffer.size()]
|
2019-01-01 13:13:17 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
return Err(gst::FlowError::Error);
|
|
|
|
};
|
|
|
|
|
2022-01-08 00:26:50 +00:00
|
|
|
if !self.settings.output_padding {
|
|
|
|
let map = buffer.map_readable().map_err(|_| {
|
|
|
|
gst::element_error!(
|
|
|
|
element,
|
|
|
|
gst::StreamError::Format,
|
|
|
|
["Failed to map buffer readable"]
|
|
|
|
);
|
|
|
|
|
|
|
|
gst::FlowError::Error
|
|
|
|
})?;
|
|
|
|
|
|
|
|
if map[0] == 0x80 && map[1] == 0x80 {
|
|
|
|
return Ok(None);
|
|
|
|
}
|
|
|
|
|
|
|
|
drop(map);
|
|
|
|
}
|
|
|
|
|
2019-01-01 13:13:17 +00:00
|
|
|
let mut timecode = buffer
|
2021-04-20 12:58:11 +00:00
|
|
|
.meta::<gst_video::VideoTimeCodeMeta>()
|
2019-01-01 13:13:17 +00:00
|
|
|
.ok_or_else(|| {
|
2020-12-20 18:43:45 +00:00
|
|
|
gst::element_error!(
|
2019-01-01 13:13:17 +00:00
|
|
|
element,
|
|
|
|
gst::StreamError::Format,
|
|
|
|
["Stream with timecodes on each buffer required"]
|
|
|
|
);
|
|
|
|
|
|
|
|
// If we neeed to skip a buffer, increment the frame if it exists
|
|
|
|
// to avoid getting out of sync
|
|
|
|
if let Some(ref mut timecode) = self.expected_timecode {
|
|
|
|
timecode.increment_frame();
|
|
|
|
}
|
|
|
|
|
|
|
|
gst::FlowError::Error
|
|
|
|
})?
|
2021-04-12 12:49:54 +00:00
|
|
|
.tc();
|
2019-01-01 13:13:17 +00:00
|
|
|
|
|
|
|
if self.expected_timecode.is_none() {
|
|
|
|
self.expected_timecode = Some(timecode.clone());
|
|
|
|
}
|
|
|
|
|
|
|
|
// if the timecode is different from the expected one,
|
|
|
|
// flush the previous line into the buffer, and push
|
|
|
|
// the new packet to the, now empty, internal buffer
|
|
|
|
if Some(&timecode) != self.expected_timecode.as_ref() {
|
2019-02-12 12:35:22 +00:00
|
|
|
let outbuf = self.write_line(element)?;
|
|
|
|
|
2019-01-01 13:13:17 +00:00
|
|
|
assert!(self.internal_buffer.is_empty());
|
|
|
|
self.internal_buffer.push(buffer);
|
|
|
|
|
|
|
|
timecode.increment_frame();
|
|
|
|
self.expected_timecode = Some(timecode);
|
2019-02-12 12:35:22 +00:00
|
|
|
|
|
|
|
return Ok(outbuf);
|
2019-01-01 13:13:17 +00:00
|
|
|
} else if let Some(ref mut timecode) = self.expected_timecode {
|
|
|
|
timecode.increment_frame();
|
|
|
|
}
|
|
|
|
|
|
|
|
self.internal_buffer.push(buffer);
|
|
|
|
|
|
|
|
if self.internal_buffer.len() == MAXIMUM_PACKETES_PER_LINE {
|
|
|
|
return self.write_line(element);
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(None)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Flush the internal buffers into a line
|
|
|
|
fn write_line(
|
|
|
|
&mut self,
|
2020-11-15 13:50:12 +00:00
|
|
|
element: &super::SccEnc,
|
2019-01-01 13:13:17 +00:00
|
|
|
) -> Result<Option<gst::Buffer>, gst::FlowError> {
|
|
|
|
let mut outbuf = Vec::new();
|
|
|
|
let mut line_start = true;
|
|
|
|
|
2019-02-12 12:35:22 +00:00
|
|
|
if self.internal_buffer.is_empty() {
|
|
|
|
return Ok(None);
|
|
|
|
}
|
2019-01-01 13:13:17 +00:00
|
|
|
|
|
|
|
if self.need_headers {
|
|
|
|
self.generate_headers(&mut outbuf);
|
|
|
|
}
|
|
|
|
|
|
|
|
let first_buf = self.internal_buffer.first().unwrap();
|
|
|
|
for buffer in self.internal_buffer.iter() {
|
2019-12-18 05:50:10 +00:00
|
|
|
let map = buffer.map_readable().map_err(|_| {
|
2020-12-20 18:43:45 +00:00
|
|
|
gst::element_error!(
|
2019-01-01 13:13:17 +00:00
|
|
|
element,
|
|
|
|
gst::StreamError::Format,
|
|
|
|
["Failed to map buffer readable"]
|
|
|
|
);
|
|
|
|
|
|
|
|
gst::FlowError::Error
|
|
|
|
})?;
|
|
|
|
|
|
|
|
// If its the first packet in the line, write the timecode first
|
|
|
|
// else, separate the packets with a space
|
|
|
|
if line_start {
|
|
|
|
let timecode = buffer
|
2021-04-20 12:58:11 +00:00
|
|
|
.meta::<gst_video::VideoTimeCodeMeta>()
|
2019-01-01 13:13:17 +00:00
|
|
|
// Checked already before the buffer has been pushed to the
|
|
|
|
// internal_buffer
|
|
|
|
.expect("Buffer without timecode")
|
2021-04-12 12:49:54 +00:00
|
|
|
.tc();
|
2019-01-01 13:13:17 +00:00
|
|
|
|
|
|
|
let _ = write!(outbuf, "{}\t", timecode);
|
|
|
|
line_start = false;
|
|
|
|
} else {
|
|
|
|
outbuf.push(b' ');
|
|
|
|
}
|
|
|
|
|
|
|
|
Self::encode_payload(&mut outbuf, &*map);
|
|
|
|
}
|
|
|
|
|
|
|
|
outbuf.extend_from_slice(b"\r\n\r\n".as_ref());
|
|
|
|
|
|
|
|
let buffer = {
|
|
|
|
let mut buffer = gst::Buffer::from_mut_slice(outbuf);
|
|
|
|
let buf_mut = buffer.get_mut().unwrap();
|
|
|
|
|
|
|
|
// Something is seriously wrong else
|
|
|
|
assert!(self.framerate.is_some());
|
|
|
|
let framerate = self.framerate.unwrap();
|
|
|
|
|
2021-06-04 17:06:24 +00:00
|
|
|
let dur = gst::ClockTime::SECOND.mul_div_floor(
|
2021-11-06 07:34:10 +00:00
|
|
|
self.internal_buffer.len() as u64 * framerate.denom() as u64,
|
|
|
|
framerate.numer() as u64,
|
2021-06-04 17:06:24 +00:00
|
|
|
);
|
2019-01-01 13:13:17 +00:00
|
|
|
buf_mut.set_duration(dur);
|
|
|
|
|
|
|
|
// Copy the metadata of the first buffer
|
|
|
|
first_buf
|
2020-01-23 06:21:32 +00:00
|
|
|
.copy_into(buf_mut, gst::BUFFER_COPY_METADATA, 0, None)
|
2019-01-01 13:13:17 +00:00
|
|
|
.expect("Failed to copy buffer metadata");
|
2021-04-12 12:49:54 +00:00
|
|
|
buf_mut.set_pts(first_buf.pts());
|
2019-01-01 13:13:17 +00:00
|
|
|
buffer
|
|
|
|
};
|
|
|
|
|
|
|
|
// Clear the internal buffer
|
|
|
|
self.internal_buffer.clear();
|
|
|
|
|
|
|
|
Ok(Some(buffer))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-15 13:50:12 +00:00
|
|
|
pub struct SccEnc {
|
2019-01-01 13:13:17 +00:00
|
|
|
srcpad: gst::Pad,
|
|
|
|
sinkpad: gst::Pad,
|
|
|
|
state: Mutex<State>,
|
2022-01-08 00:26:50 +00:00
|
|
|
settings: Mutex<Settings>,
|
2019-01-01 13:13:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl SccEnc {
|
|
|
|
fn sink_chain(
|
|
|
|
&self,
|
|
|
|
pad: &gst::Pad,
|
2020-11-15 13:50:12 +00:00
|
|
|
element: &super::SccEnc,
|
2019-01-01 13:13:17 +00:00
|
|
|
buffer: gst::Buffer,
|
|
|
|
) -> Result<gst::FlowSuccess, gst::FlowError> {
|
|
|
|
gst_log!(CAT, obj: pad, "Handling buffer {:?}", buffer);
|
|
|
|
|
|
|
|
let mut state = self.state.lock().unwrap();
|
|
|
|
let res = state.generate_caption(element, buffer)?;
|
|
|
|
|
|
|
|
if let Some(outbuf) = res {
|
|
|
|
gst_trace!(CAT, obj: pad, "Pushing buffer {:?} to the pad", &outbuf);
|
|
|
|
|
|
|
|
drop(state);
|
|
|
|
self.srcpad.push(outbuf)?;
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(gst::FlowSuccess::Ok)
|
|
|
|
}
|
|
|
|
|
2020-11-15 13:50:12 +00:00
|
|
|
fn sink_event(&self, pad: &gst::Pad, element: &super::SccEnc, event: gst::Event) -> bool {
|
2019-01-01 13:13:17 +00:00
|
|
|
use gst::EventView;
|
|
|
|
|
|
|
|
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
|
|
|
|
|
|
|
|
match event.view() {
|
|
|
|
EventView::Caps(ev) => {
|
2021-04-12 12:49:54 +00:00
|
|
|
let caps = ev.caps();
|
2021-04-20 12:58:11 +00:00
|
|
|
let s = caps.structure(0).unwrap();
|
2021-04-25 12:41:22 +00:00
|
|
|
let framerate = match s.get::<gst::Fraction>("framerate") {
|
2019-08-12 22:45:36 +00:00
|
|
|
Ok(framerate) => Some(framerate),
|
|
|
|
Err(structure::GetError::FieldNotFound { .. }) => {
|
|
|
|
gst_error!(CAT, obj: pad, "Caps without framerate");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
err => panic!("SccEnc::sink_event caps: {:?}", err),
|
2019-01-01 13:13:17 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
let mut state = self.state.lock().unwrap();
|
|
|
|
state.framerate = framerate;
|
|
|
|
|
|
|
|
// We send our own caps downstream
|
|
|
|
let caps = gst::Caps::builder("application/x-scc").build();
|
2020-06-24 22:33:57 +00:00
|
|
|
self.srcpad.push_event(gst::event::Caps::new(&caps))
|
2019-01-01 13:13:17 +00:00
|
|
|
}
|
|
|
|
EventView::Eos(_) => {
|
|
|
|
let mut state = self.state.lock().unwrap();
|
|
|
|
|
|
|
|
let outbuf = state.write_line(element);
|
|
|
|
|
|
|
|
if let Ok(Some(buffer)) = outbuf {
|
|
|
|
gst_trace!(CAT, obj: pad, "Pushing buffer {:?} to the pad", &buffer);
|
|
|
|
|
|
|
|
drop(state);
|
|
|
|
if self.srcpad.push(buffer).is_err() {
|
|
|
|
gst_error!(CAT, obj: pad, "Failed to push buffer to the pad");
|
|
|
|
return false;
|
|
|
|
}
|
2019-02-12 12:35:22 +00:00
|
|
|
} else if let Err(err) = outbuf {
|
|
|
|
gst_error!(CAT, obj: pad, "Failed to write a line after EOS: {:?}", err);
|
2019-01-01 13:13:17 +00:00
|
|
|
return false;
|
|
|
|
}
|
2019-05-23 20:55:54 +00:00
|
|
|
pad.event_default(Some(element), event)
|
2019-01-01 13:13:17 +00:00
|
|
|
}
|
2019-05-23 20:55:54 +00:00
|
|
|
_ => pad.event_default(Some(element), event),
|
2019-01-01 13:13:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-15 13:50:12 +00:00
|
|
|
fn src_event(&self, pad: &gst::Pad, element: &super::SccEnc, event: gst::Event) -> bool {
|
2019-01-01 13:13:17 +00:00
|
|
|
use gst::EventView;
|
|
|
|
|
|
|
|
gst_log!(CAT, obj: pad, "Handling event {:?}", event);
|
|
|
|
match event.view() {
|
|
|
|
EventView::Seek(_) => {
|
|
|
|
gst_log!(CAT, obj: pad, "Dropping seek event");
|
|
|
|
false
|
|
|
|
}
|
2019-05-23 20:55:54 +00:00
|
|
|
_ => pad.event_default(Some(element), event),
|
2019-01-01 13:13:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-15 13:50:12 +00:00
|
|
|
fn src_query(
|
|
|
|
&self,
|
|
|
|
pad: &gst::Pad,
|
|
|
|
element: &super::SccEnc,
|
|
|
|
query: &mut gst::QueryRef,
|
|
|
|
) -> bool {
|
2019-01-01 13:13:17 +00:00
|
|
|
use gst::QueryView;
|
|
|
|
|
|
|
|
gst_log!(CAT, obj: pad, "Handling query {:?}", query);
|
|
|
|
|
|
|
|
match query.view_mut() {
|
|
|
|
QueryView::Seeking(mut q) => {
|
|
|
|
// We don't support any seeking at all
|
2021-04-12 12:49:54 +00:00
|
|
|
let fmt = q.format();
|
2019-01-01 13:13:17 +00:00
|
|
|
q.set(
|
|
|
|
false,
|
|
|
|
gst::GenericFormattedValue::Other(fmt, -1),
|
|
|
|
gst::GenericFormattedValue::Other(fmt, -1),
|
|
|
|
);
|
|
|
|
true
|
|
|
|
}
|
2019-05-23 20:55:54 +00:00
|
|
|
_ => pad.query_default(Some(element), query),
|
2019-01-01 13:13:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-07 16:22:24 +00:00
|
|
|
#[glib::object_subclass]
|
2019-01-01 13:13:17 +00:00
|
|
|
impl ObjectSubclass for SccEnc {
|
|
|
|
const NAME: &'static str = "RsSccEnc";
|
2020-11-15 13:50:12 +00:00
|
|
|
type Type = super::SccEnc;
|
2019-01-01 13:13:17 +00:00
|
|
|
type ParentType = gst::Element;
|
|
|
|
|
2020-11-15 13:50:12 +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| {
|
|
|
|
SccEnc::catch_panic_pad_function(
|
|
|
|
parent,
|
|
|
|
|| Err(gst::FlowError::Error),
|
|
|
|
|enc, element| enc.sink_chain(pad, element, buffer),
|
|
|
|
)
|
|
|
|
})
|
|
|
|
.event_function(|pad, parent, event| {
|
|
|
|
SccEnc::catch_panic_pad_function(
|
|
|
|
parent,
|
|
|
|
|| false,
|
|
|
|
|enc, element| enc.sink_event(pad, element, event),
|
|
|
|
)
|
|
|
|
})
|
|
|
|
.build();
|
2019-01-01 13:13:17 +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"))
|
|
|
|
.event_function(|pad, parent, event| {
|
|
|
|
SccEnc::catch_panic_pad_function(
|
|
|
|
parent,
|
|
|
|
|| false,
|
|
|
|
|enc, element| enc.src_event(pad, element, event),
|
|
|
|
)
|
|
|
|
})
|
|
|
|
.query_function(|pad, parent, query| {
|
|
|
|
SccEnc::catch_panic_pad_function(
|
|
|
|
parent,
|
|
|
|
|| false,
|
|
|
|
|enc, element| enc.src_query(pad, element, query),
|
|
|
|
)
|
|
|
|
})
|
|
|
|
.build();
|
2019-01-01 13:13:17 +00:00
|
|
|
|
|
|
|
Self {
|
|
|
|
srcpad,
|
|
|
|
sinkpad,
|
|
|
|
state: Mutex::new(State::default()),
|
2022-01-08 00:26:50 +00:00
|
|
|
settings: Mutex::new(Settings::default()),
|
2019-01-01 13:13:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ObjectImpl for SccEnc {
|
2020-11-15 13:50:12 +00:00
|
|
|
fn constructed(&self, obj: &Self::Type) {
|
2019-01-01 13:13:17 +00:00
|
|
|
self.parent_constructed(obj);
|
|
|
|
|
2020-11-15 13:50:12 +00:00
|
|
|
obj.add_pad(&self.sinkpad).unwrap();
|
|
|
|
obj.add_pad(&self.srcpad).unwrap();
|
2019-01-01 13:13:17 +00:00
|
|
|
}
|
2022-01-08 00:26:50 +00:00
|
|
|
|
|
|
|
fn properties() -> &'static [glib::ParamSpec] {
|
|
|
|
static PROPERTIES: Lazy<Vec<glib::ParamSpec>> = Lazy::new(|| {
|
|
|
|
vec![glib::ParamSpecBoolean::new(
|
|
|
|
"output-padding",
|
|
|
|
"Output padding",
|
|
|
|
"Whether the encoder should output padding captions. \
|
|
|
|
The element will never add padding, but will encode padding \
|
|
|
|
buffers it receives if this property is set to true.",
|
|
|
|
DEFAULT_OUTPUT_PADDING,
|
|
|
|
glib::ParamFlags::READWRITE | gst::PARAM_FLAG_MUTABLE_READY,
|
|
|
|
)]
|
|
|
|
});
|
|
|
|
|
|
|
|
PROPERTIES.as_ref()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn set_property(
|
|
|
|
&self,
|
|
|
|
_obj: &Self::Type,
|
|
|
|
_id: usize,
|
|
|
|
value: &glib::Value,
|
|
|
|
pspec: &glib::ParamSpec,
|
|
|
|
) {
|
|
|
|
match pspec.name() {
|
|
|
|
"output-padding" => {
|
|
|
|
self.settings.lock().unwrap().output_padding =
|
|
|
|
value.get().expect("type checked upstream");
|
|
|
|
}
|
|
|
|
_ => unimplemented!(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn property(&self, _obj: &Self::Type, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
|
|
|
|
match pspec.name() {
|
|
|
|
"output-padding" => {
|
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
settings.output_padding.to_value()
|
|
|
|
}
|
|
|
|
_ => unimplemented!(),
|
|
|
|
}
|
|
|
|
}
|
2019-01-01 13:13:17 +00:00
|
|
|
}
|
|
|
|
|
2021-10-23 08:57:31 +00:00
|
|
|
impl GstObjectImpl for SccEnc {}
|
|
|
|
|
2019-01-01 13:13:17 +00:00
|
|
|
impl ElementImpl for SccEnc {
|
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(
|
|
|
|
"Scc Encoder",
|
|
|
|
"Encoder/ClosedCaption",
|
|
|
|
"Encodes SCC Closed Caption Files",
|
|
|
|
"Sebastian Dröge <sebastian@centricular.com>, Jordan Petridis <jordan@centricular.com>",
|
|
|
|
)
|
|
|
|
});
|
|
|
|
|
|
|
|
Some(&*ELEMENT_METADATA)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn pad_templates() -> &'static [gst::PadTemplate] {
|
|
|
|
static PAD_TEMPLATES: Lazy<Vec<gst::PadTemplate>> = Lazy::new(|| {
|
|
|
|
let framerates =
|
2021-11-06 07:34:10 +00:00
|
|
|
gst::List::new([gst::Fraction::new(30000, 1001), gst::Fraction::new(30, 1)]);
|
2021-01-21 18:21:29 +00:00
|
|
|
let caps = gst::Caps::builder("closedcaption/x-cea-608")
|
2021-11-06 07:34:10 +00:00
|
|
|
.field("format", "raw")
|
|
|
|
.field("framerate", framerates)
|
2021-01-21 18:21:29 +00:00
|
|
|
.build();
|
|
|
|
let sink_pad_template = gst::PadTemplate::new(
|
|
|
|
"sink",
|
|
|
|
gst::PadDirection::Sink,
|
|
|
|
gst::PadPresence::Always,
|
|
|
|
&caps,
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
let caps = gst::Caps::builder("application/x-scc").build();
|
|
|
|
let src_pad_template = gst::PadTemplate::new(
|
|
|
|
"src",
|
|
|
|
gst::PadDirection::Src,
|
|
|
|
gst::PadPresence::Always,
|
|
|
|
&caps,
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
vec![src_pad_template, sink_pad_template]
|
|
|
|
});
|
|
|
|
|
|
|
|
PAD_TEMPLATES.as_ref()
|
|
|
|
}
|
|
|
|
|
2019-01-01 13:13:17 +00:00
|
|
|
fn change_state(
|
|
|
|
&self,
|
2020-11-15 13:50:12 +00:00
|
|
|
element: &Self::Type,
|
2019-01-01 13:13:17 +00:00
|
|
|
transition: gst::StateChange,
|
|
|
|
) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
|
|
|
|
gst_trace!(CAT, obj: element, "Changing state {:?}", transition);
|
|
|
|
|
|
|
|
match transition {
|
2022-01-08 00:26:50 +00:00
|
|
|
gst::StateChange::ReadyToPaused => {
|
|
|
|
// Reset the whole state
|
|
|
|
let mut state = self.state.lock().unwrap();
|
|
|
|
*state = State::default();
|
|
|
|
state.settings = self.settings.lock().unwrap().clone();
|
|
|
|
}
|
|
|
|
gst::StateChange::PausedToReady => {
|
2019-01-01 13:13:17 +00:00
|
|
|
// Reset the whole state
|
|
|
|
let mut state = self.state.lock().unwrap();
|
|
|
|
*state = State::default();
|
|
|
|
}
|
|
|
|
_ => (),
|
|
|
|
}
|
|
|
|
|
|
|
|
self.parent_change_state(element, transition)
|
|
|
|
}
|
|
|
|
}
|