mirror of
https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs.git
synced 2024-06-09 09:49:22 +00:00
563 lines
16 KiB
Rust
563 lines
16 KiB
Rust
// Copyright (C) 2020 Mathieu Duponchelle <mathieu@centricular.com>
|
|
//
|
|
// This library is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU Library General Public
|
|
// License as published by the Free Software Foundation; either
|
|
// version 2 of the License, or (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Library General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Library General Public
|
|
// License along with this library; if not, write to the
|
|
// Free Software Foundation, Inc., 51 Franklin Street, Suite 500,
|
|
// Boston, MA 02110-1335, USA.
|
|
|
|
use gst::ClockTime;
|
|
use pretty_assertions::assert_eq;
|
|
|
|
fn init() {
|
|
use std::sync::Once;
|
|
static INIT: Once = Once::new();
|
|
|
|
INIT.call_once(|| {
|
|
gst::init().unwrap();
|
|
gstrsclosedcaption::plugin_register_static().unwrap();
|
|
});
|
|
}
|
|
|
|
fn new_timed_buffer<T: AsRef<[u8]> + Send + 'static>(
|
|
slice: T,
|
|
timestamp: ClockTime,
|
|
duration: ClockTime,
|
|
) -> gst::buffer::Buffer {
|
|
let mut buf = gst::Buffer::from_slice(slice);
|
|
let buf_ref = buf.get_mut().unwrap();
|
|
buf_ref.set_pts(timestamp);
|
|
buf_ref.set_duration(duration);
|
|
buf
|
|
}
|
|
|
|
#[test]
|
|
fn test_non_timed_buffer() {
|
|
init();
|
|
|
|
let mut h = gst_check::Harness::new_parse("tttocea608 mode=pop-on");
|
|
h.set_src_caps_str("text/x-raw");
|
|
|
|
let inbuf = gst::Buffer::from_slice(&"Hello");
|
|
|
|
assert_eq!(h.push(inbuf), Err(gst::FlowError::Error));
|
|
}
|
|
|
|
/* Check translation of a simple string */
|
|
#[test]
|
|
fn test_one_timed_buffer_and_eos() {
|
|
init();
|
|
|
|
let mut h = gst_check::Harness::new_parse("tttocea608 mode=pop-on");
|
|
h.set_src_caps_str("text/x-raw");
|
|
|
|
while h.events_in_queue() != 0 {
|
|
let _event = h.pull_event().unwrap();
|
|
}
|
|
|
|
let inbuf = new_timed_buffer(&"Hello", ClockTime::SECOND, ClockTime::SECOND);
|
|
|
|
assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
|
|
|
|
let expected: [(ClockTime, ClockTime, [u8; 2usize]); 7] = [
|
|
(
|
|
ClockTime::from_nseconds(1_000_000_000),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0x94, 0x20],
|
|
), /* resume_caption_loading */
|
|
(
|
|
ClockTime::from_nseconds(1_033_333_333),
|
|
ClockTime::from_nseconds(33_333_334),
|
|
[0x94, 0xae],
|
|
), /* erase_non_displayed_memory */
|
|
(
|
|
ClockTime::from_nseconds(1_066_666_667),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0x94, 0x70],
|
|
), /* preamble */
|
|
(
|
|
ClockTime::from_nseconds(1_100_000_000),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0xc8, 0xe5],
|
|
), /* H e */
|
|
(
|
|
ClockTime::from_nseconds(1_133_333_333),
|
|
ClockTime::from_nseconds(33_333_334),
|
|
[0xec, 0xec],
|
|
), /* l l */
|
|
(
|
|
ClockTime::from_nseconds(1_166_666_667),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0xef, 0x80],
|
|
), /* o, nil */
|
|
(
|
|
ClockTime::from_nseconds(1_200_000_000),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0x94, 0x2f],
|
|
), /* end_of_caption */
|
|
];
|
|
|
|
for (i, e) in expected.iter().enumerate() {
|
|
let outbuf = h.try_pull().unwrap();
|
|
|
|
assert_eq!(
|
|
e.0,
|
|
outbuf.pts().unwrap(),
|
|
"Unexpected PTS for {}th buffer",
|
|
i + 1
|
|
);
|
|
assert_eq!(
|
|
e.1,
|
|
outbuf.duration().unwrap(),
|
|
"Unexpected duration for {}th buffer",
|
|
i + 1
|
|
);
|
|
|
|
let data = outbuf.map_readable().unwrap();
|
|
assert_eq!(e.2, &*data);
|
|
}
|
|
|
|
assert_eq!(h.buffers_in_queue(), 23);
|
|
|
|
h.push_event(gst::event::Eos::new());
|
|
|
|
/* Check that we do receive an erase_display */
|
|
loop {
|
|
let outbuf = h.try_pull().unwrap();
|
|
let data = outbuf.map_readable().unwrap();
|
|
if outbuf.pts().unwrap() == ClockTime::from_nseconds(2_200_000_000) {
|
|
assert_eq!(&*data, &[0x94, 0x2c]);
|
|
break;
|
|
} else {
|
|
assert_eq!(&*data, &[0x80, 0x80]);
|
|
}
|
|
}
|
|
|
|
assert_eq!(h.events_in_queue(), 1);
|
|
|
|
let event = h.pull_event().unwrap();
|
|
assert_eq!(event.type_(), gst::EventType::Eos);
|
|
}
|
|
|
|
/* Here we test that the erase_display_memory control code
|
|
* gets inserted at the correct moment, when there's enough
|
|
* of an interval between two buffers
|
|
*/
|
|
#[test]
|
|
fn test_erase_display_memory_non_spliced() {
|
|
init();
|
|
|
|
let mut h = gst_check::Harness::new_parse("tttocea608 mode=pop-on");
|
|
h.set_src_caps_str("text/x-raw");
|
|
|
|
while h.events_in_queue() != 0 {
|
|
let _event = h.pull_event().unwrap();
|
|
}
|
|
|
|
let inbuf = new_timed_buffer(
|
|
&"Hello",
|
|
ClockTime::from_nseconds(1_000_000_000),
|
|
ClockTime::SECOND,
|
|
);
|
|
assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
|
|
|
|
let inbuf = new_timed_buffer(
|
|
&"World",
|
|
ClockTime::from_nseconds(3_000_000_000),
|
|
ClockTime::SECOND,
|
|
);
|
|
assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
|
|
|
|
let mut erase_display_buffers = 0;
|
|
|
|
while h.buffers_in_queue() > 0 {
|
|
let outbuf = h.pull().unwrap();
|
|
|
|
if outbuf.pts().unwrap() == ClockTime::from_nseconds(2_200_000_000) {
|
|
let data = outbuf.map_readable().unwrap();
|
|
assert_eq!(&*data, &[0x94, 0x2c]);
|
|
erase_display_buffers += 1;
|
|
}
|
|
}
|
|
|
|
assert_eq!(erase_display_buffers, 1);
|
|
}
|
|
|
|
/* Here we test that the erase_display_memory control code
|
|
* gets inserted while loading the following pop-on captions
|
|
* when there's not enough of an interval between them.
|
|
*
|
|
* Note that as tttocea608 introduces an offset between the
|
|
* intended PTS and the actual display time with pop-on captions
|
|
* (when end_of_caption is output) in order not to introduce
|
|
* a huge latency, the clear time is also offset so that the captions
|
|
* display as long as intended.
|
|
*/
|
|
#[test]
|
|
fn test_erase_display_memory_spliced() {
|
|
init();
|
|
|
|
let mut h = gst_check::Harness::new_parse("tttocea608 mode=pop-on");
|
|
h.set_src_caps_str("text/x-raw");
|
|
|
|
while h.events_in_queue() != 0 {
|
|
let _event = h.pull_event().unwrap();
|
|
}
|
|
|
|
let inbuf = new_timed_buffer(
|
|
&"Hello",
|
|
ClockTime::from_nseconds(1_000_000_000),
|
|
ClockTime::SECOND,
|
|
);
|
|
assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
|
|
|
|
let inbuf = new_timed_buffer(
|
|
&"World, Lorem Ipsum",
|
|
ClockTime::from_nseconds(2_000_000_000),
|
|
ClockTime::SECOND,
|
|
);
|
|
assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
|
|
|
|
let mut erase_display_buffers = 0;
|
|
let mut prev_pts: ClockTime = ClockTime::ZERO;
|
|
|
|
while h.buffers_in_queue() > 0 {
|
|
let outbuf = h.pull().unwrap();
|
|
|
|
/* Check that our timestamps are strictly ascending */
|
|
let pts = outbuf.pts().unwrap();
|
|
assert!(pts >= prev_pts);
|
|
|
|
if pts == ClockTime::from_nseconds(2_200_000_000) {
|
|
let data = outbuf.map_readable().unwrap();
|
|
assert_eq!(&*data, &[0x94, 0x2c]);
|
|
erase_display_buffers += 1;
|
|
}
|
|
|
|
prev_pts = pts;
|
|
}
|
|
|
|
assert_eq!(erase_display_buffers, 1);
|
|
}
|
|
|
|
/* Here we verify that the element outputs a continuous stream
|
|
* with padding buffers
|
|
*/
|
|
#[test]
|
|
fn test_output_gaps() {
|
|
init();
|
|
|
|
let mut h = gst_check::Harness::new_parse("tttocea608 mode=pop-on");
|
|
h.set_src_caps_str("text/x-raw");
|
|
|
|
while h.events_in_queue() != 0 {
|
|
let _event = h.pull_event().unwrap();
|
|
}
|
|
|
|
let inbuf = new_timed_buffer(
|
|
&"Hello",
|
|
ClockTime::from_nseconds(1_000_000_000),
|
|
ClockTime::SECOND,
|
|
);
|
|
assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
|
|
|
|
let inbuf = new_timed_buffer(
|
|
&"World",
|
|
ClockTime::from_nseconds(3_000_000_000),
|
|
ClockTime::SECOND,
|
|
);
|
|
assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
|
|
|
|
h.push_event(gst::event::Eos::new());
|
|
|
|
/* Padding */
|
|
loop {
|
|
let outbuf = h.pull().unwrap();
|
|
if outbuf.pts().unwrap() + outbuf.duration().unwrap() >= ClockTime::SECOND {
|
|
break;
|
|
}
|
|
|
|
let data = outbuf.map_readable().unwrap();
|
|
assert_eq!(&*data, &[0x80, 0x80]);
|
|
}
|
|
|
|
/* Hello */
|
|
loop {
|
|
let outbuf = h.pull().unwrap();
|
|
if outbuf.pts().unwrap() + outbuf.duration().unwrap()
|
|
>= ClockTime::from_nseconds(1_233_333_333)
|
|
{
|
|
break;
|
|
}
|
|
|
|
let data = outbuf.map_readable().unwrap();
|
|
assert_ne!(&*data, &[0x80, 0x80]);
|
|
}
|
|
|
|
/* Padding */
|
|
loop {
|
|
let outbuf = h.pull().unwrap();
|
|
if outbuf.pts().unwrap() + outbuf.duration().unwrap()
|
|
>= ClockTime::from_nseconds(3_000_000_000)
|
|
{
|
|
break;
|
|
}
|
|
|
|
let data = outbuf.map_readable().unwrap();
|
|
if outbuf.pts().unwrap() == ClockTime::from_nseconds(2_200_000_000) {
|
|
/* Erase display one second after Hello */
|
|
assert_eq!(&*data, &[0x94, 0x2C]);
|
|
} else {
|
|
assert_eq!(&*data, &[0x80, 0x80]);
|
|
}
|
|
}
|
|
|
|
/* World */
|
|
loop {
|
|
let outbuf = h.pull().unwrap();
|
|
if outbuf.pts().unwrap() + outbuf.duration().unwrap()
|
|
>= ClockTime::from_nseconds(3_233_333_333)
|
|
{
|
|
break;
|
|
}
|
|
|
|
let data = outbuf.map_readable().unwrap();
|
|
assert_ne!(&*data, &[0x80, 0x80]);
|
|
}
|
|
|
|
assert_eq!(h.events_in_queue(), 1);
|
|
|
|
let event = h.pull_event().unwrap();
|
|
assert_eq!(event.type_(), gst::EventType::Eos);
|
|
}
|
|
|
|
#[test]
|
|
fn test_one_timed_buffer_and_eos_roll_up2() {
|
|
init();
|
|
|
|
let mut h = gst_check::Harness::new_parse("tttocea608 mode=roll-up2");
|
|
h.set_src_caps_str("text/x-raw");
|
|
|
|
while h.events_in_queue() != 0 {
|
|
let _event = h.pull_event().unwrap();
|
|
}
|
|
|
|
let inbuf = new_timed_buffer(&"Hello", ClockTime::SECOND, ClockTime::SECOND);
|
|
assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
|
|
|
|
let inbuf = new_timed_buffer(&"World", 2 * ClockTime::SECOND, ClockTime::from_nseconds(1));
|
|
assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
|
|
|
|
let expected: [(ClockTime, ClockTime, [u8; 2usize]); 5] = [
|
|
(
|
|
ClockTime::from_nseconds(1_000_000_000),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0x94, 0x25],
|
|
), /* roll_up_2 */
|
|
(
|
|
ClockTime::from_nseconds(1_033_333_333),
|
|
ClockTime::from_nseconds(33_333_334),
|
|
[0x94, 0x70],
|
|
), /* preamble */
|
|
(
|
|
ClockTime::from_nseconds(1_066_666_667),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0xc8, 0xe5],
|
|
), /* H e */
|
|
(
|
|
ClockTime::from_nseconds(1_100_000_000),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0xec, 0xec],
|
|
), /* l l */
|
|
(
|
|
ClockTime::from_nseconds(1_133_333_333),
|
|
ClockTime::from_nseconds(33_333_334),
|
|
[0xef, 0x80],
|
|
), /* o nil */
|
|
];
|
|
|
|
for (i, e) in expected.iter().enumerate() {
|
|
let outbuf = h.try_pull().unwrap();
|
|
|
|
assert_eq!(
|
|
e.0,
|
|
outbuf.pts().unwrap(),
|
|
"Unexpected PTS for {}th buffer",
|
|
i + 1
|
|
);
|
|
assert_eq!(
|
|
e.1,
|
|
outbuf.duration().unwrap(),
|
|
"Unexpected duration for {}th buffer",
|
|
i + 1
|
|
);
|
|
|
|
let data = outbuf.map_readable().unwrap();
|
|
assert_eq!(e.2, &*data);
|
|
}
|
|
|
|
/* Padding */
|
|
loop {
|
|
let outbuf = h.pull().unwrap();
|
|
if outbuf.pts().unwrap() + outbuf.duration().unwrap() >= 2 * ClockTime::SECOND {
|
|
break;
|
|
}
|
|
|
|
let data = outbuf.map_readable().unwrap();
|
|
assert_eq!(&*data, &[0x80, 0x80]);
|
|
}
|
|
|
|
let expected: [(ClockTime, ClockTime, [u8; 2usize]); 3] = [
|
|
(
|
|
ClockTime::from_nseconds(2_000_000_000),
|
|
ClockTime::ZERO,
|
|
[0x20, 0x57],
|
|
), /* SPACE W */
|
|
(
|
|
ClockTime::from_nseconds(2_000_000_000),
|
|
ClockTime::ZERO,
|
|
[0xef, 0xf2],
|
|
), /* o r */
|
|
(
|
|
ClockTime::from_nseconds(2_000_000_000),
|
|
ClockTime::ZERO,
|
|
[0xec, 0x64],
|
|
), /* l d */
|
|
];
|
|
|
|
for (i, e) in expected.iter().enumerate() {
|
|
let outbuf = h.try_pull().unwrap();
|
|
|
|
assert_eq!(
|
|
e.0,
|
|
outbuf.pts().unwrap(),
|
|
"Unexpected PTS for {}th buffer",
|
|
i + 1
|
|
);
|
|
assert_eq!(
|
|
e.1,
|
|
outbuf.duration().unwrap(),
|
|
"Unexpected duration for {}th buffer",
|
|
i + 1
|
|
);
|
|
|
|
let data = outbuf.map_readable().unwrap();
|
|
assert_eq!(e.2, &*data);
|
|
}
|
|
|
|
assert_eq!(h.buffers_in_queue(), 0);
|
|
|
|
h.push_event(gst::event::Eos::new());
|
|
|
|
assert_eq!(h.events_in_queue(), 1);
|
|
|
|
let event = h.pull_event().unwrap();
|
|
assert_eq!(event.type_(), gst::EventType::Eos);
|
|
}
|
|
|
|
/* Here we test that tttocea608 introduces carriage returns in
|
|
* judicious places and avoids to break words without rhyme or
|
|
* reason.
|
|
*/
|
|
#[test]
|
|
fn test_word_wrap_roll_up() {
|
|
init();
|
|
|
|
let mut h = gst_check::Harness::new_parse("tttocea608 mode=roll-up2 origin-column=24");
|
|
h.set_src_caps_str("text/x-raw");
|
|
|
|
while h.events_in_queue() != 0 {
|
|
let _event = h.pull_event().unwrap();
|
|
}
|
|
|
|
let inbuf = new_timed_buffer(&"Hello World", ClockTime::SECOND, ClockTime::SECOND);
|
|
assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
|
|
|
|
let expected: [(ClockTime, ClockTime, [u8; 2usize]); 11] = [
|
|
(
|
|
ClockTime::from_nseconds(1_000_000_000),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0x94, 0x25],
|
|
), /* roll_up_2 */
|
|
(
|
|
ClockTime::from_nseconds(1_033_333_333),
|
|
ClockTime::from_nseconds(33_333_334),
|
|
[0x94, 0x7c],
|
|
), /* preamble */
|
|
(
|
|
ClockTime::from_nseconds(1_066_666_667),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0xc8, 0xe5],
|
|
), /* H e */
|
|
(
|
|
ClockTime::from_nseconds(1_100_000_000),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0xec, 0xec],
|
|
), /* l l */
|
|
(
|
|
ClockTime::from_nseconds(1_133_333_333),
|
|
ClockTime::from_nseconds(33_333_334),
|
|
[0xef, 0x20],
|
|
), /* o SPACE */
|
|
(
|
|
ClockTime::from_nseconds(1_166_666_667),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0x94, 0xad],
|
|
), /* carriage return */
|
|
(
|
|
ClockTime::from_nseconds(1_200_000_000),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0x94, 0x25],
|
|
), /* roll_up_2 */
|
|
(
|
|
ClockTime::from_nseconds(1_233_333_333),
|
|
ClockTime::from_nseconds(33_333_334),
|
|
[0x94, 0x7c],
|
|
), /* preamble */
|
|
(
|
|
ClockTime::from_nseconds(1_266_666_667),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0x57, 0xef],
|
|
), /* W o */
|
|
(
|
|
ClockTime::from_nseconds(1_300_000_000),
|
|
ClockTime::from_nseconds(33_333_333),
|
|
[0xf2, 0xec],
|
|
), /* r l */
|
|
(
|
|
ClockTime::from_nseconds(1_333_333_333),
|
|
ClockTime::from_nseconds(33_333_334),
|
|
[0x64, 0x80],
|
|
), /* d nil */
|
|
];
|
|
|
|
for (i, e) in expected.iter().enumerate() {
|
|
let outbuf = h.try_pull().unwrap();
|
|
|
|
assert_eq!(
|
|
e.0,
|
|
outbuf.pts().unwrap(),
|
|
"Unexpected PTS for {}th buffer",
|
|
i + 1
|
|
);
|
|
assert_eq!(
|
|
e.1,
|
|
outbuf.duration().unwrap(),
|
|
"Unexpected duration for {}th buffer",
|
|
i + 1
|
|
);
|
|
|
|
let data = outbuf.map_readable().unwrap();
|
|
assert_eq!(e.2, &*data);
|
|
}
|
|
}
|