From 774110ec0a67e0e65037bcd186fde9aa91b7eb60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Sat, 29 Dec 2018 00:00:28 +0200 Subject: [PATCH] closedcaption: Add closed caption plugin with an MCC parser and encoder --- Cargo.toml | 1 + gst-plugin-closedcaption/Cargo.toml | 26 + gst-plugin-closedcaption/src/lib.rs | 58 ++ gst-plugin-closedcaption/src/line_reader.rs | 333 ++++++++ gst-plugin-closedcaption/src/mcc_enc.rs | 641 ++++++++++++++ .../src/mcc_enc_headers.rs | 95 +++ gst-plugin-closedcaption/src/mcc_parse.rs | 614 ++++++++++++++ gst-plugin-closedcaption/src/mcc_parser.rs | 793 ++++++++++++++++++ .../tests/captions-test_708.mcc | 622 ++++++++++++++ gst-plugin-closedcaption/tests/mcc_enc.rs | 143 ++++ gst-plugin-closedcaption/tests/mcc_parse.rs | 136 +++ 11 files changed, 3462 insertions(+) create mode 100644 gst-plugin-closedcaption/Cargo.toml create mode 100644 gst-plugin-closedcaption/src/lib.rs create mode 100644 gst-plugin-closedcaption/src/line_reader.rs create mode 100644 gst-plugin-closedcaption/src/mcc_enc.rs create mode 100644 gst-plugin-closedcaption/src/mcc_enc_headers.rs create mode 100644 gst-plugin-closedcaption/src/mcc_parse.rs create mode 100644 gst-plugin-closedcaption/src/mcc_parser.rs create mode 100644 gst-plugin-closedcaption/tests/captions-test_708.mcc create mode 100644 gst-plugin-closedcaption/tests/mcc_enc.rs create mode 100644 gst-plugin-closedcaption/tests/mcc_parse.rs diff --git a/Cargo.toml b/Cargo.toml index 07d37d8d..83fa2797 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,6 +8,7 @@ members = [ "gst-plugin-togglerecord", "gst-plugin-threadshare", "gst-plugin-tutorial", + "gst-plugin-closedcaption", ] [profile.release] diff --git a/gst-plugin-closedcaption/Cargo.toml b/gst-plugin-closedcaption/Cargo.toml new file mode 100644 index 00000000..2c111e05 --- /dev/null +++ b/gst-plugin-closedcaption/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "gst-plugin-closedcaption" +version = "0.4.0" +authors = ["Sebastian Dröge ", "Jordan Petridis "] +license = "LGPL-2.1+" +edition = "2018" + +[dependencies] +glib = { git = "https://github.com/gtk-rs/glib", features = ["subclassing"] } +gstreamer = { git = "https://gitlab.freedesktop.org/gstreamer/gstreamer-rs", features = ["subclassing", "v1_10"] } +gstreamer-base = { git = "https://gitlab.freedesktop.org/gstreamer/gstreamer-rs", features = ["subclassing", "v1_10"] } +gstreamer-video = { git = "https://gitlab.freedesktop.org/gstreamer/gstreamer-rs", features = ["v1_10"] } +combine = "3.6" +either = "1" +uuid = { version = "0.7", features = ["v4"] } +chrono = "0.4" + +[dev-dependencies] +pretty_assertions = "0.5.1" +gstreamer-check = { git = "https://gitlab.freedesktop.org/gstreamer/gstreamer-rs" } +rand = "0.6" + +[lib] +name = "gstrsclosedcaption" +crate-type = ["cdylib", "rlib"] +path = "src/lib.rs" diff --git a/gst-plugin-closedcaption/src/lib.rs b/gst-plugin-closedcaption/src/lib.rs new file mode 100644 index 00000000..c533ea0e --- /dev/null +++ b/gst-plugin-closedcaption/src/lib.rs @@ -0,0 +1,58 @@ +// Copyright (C) 2018 Sebastian Dröge +// +// 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. + +#![crate_type = "cdylib"] + +#[macro_use] +extern crate glib; +#[macro_use] +extern crate gstreamer as gst; +extern crate gstreamer_base as gst_base; +extern crate gstreamer_video as gst_video; + +extern crate combine; +extern crate either; + +extern crate chrono; +extern crate uuid; + +#[cfg(test)] +#[macro_use] +extern crate pretty_assertions; + +mod line_reader; +mod mcc_enc; +mod mcc_parse; +mod mcc_parser; + +fn plugin_init(plugin: &gst::Plugin) -> Result<(), glib::BoolError> { + mcc_parse::register(plugin)?; + mcc_enc::register(plugin)?; + Ok(()) +} + +gst_plugin_define!( + "rsclosedcaption", + "Rust Closed Caption Plugin", + plugin_init, + "0.1.0", + "LGPL", + "rsclosedcaption", + "rsclosedcaption", + "https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs", + "2018-12-17" +); diff --git a/gst-plugin-closedcaption/src/line_reader.rs b/gst-plugin-closedcaption/src/line_reader.rs new file mode 100644 index 00000000..7ab48833 --- /dev/null +++ b/gst-plugin-closedcaption/src/line_reader.rs @@ -0,0 +1,333 @@ +// Copyright (C) 2018 Sebastian Dröge +// +// 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 std::collections::VecDeque; + +#[derive(Debug)] +pub struct LineReader> { + queue: VecDeque, + // Read position into the queue in bytes + read_pos: usize, + // Offset into queue where we have to look for a newline + // All previous items don't contain a newline + search_pos: usize, + buf: Vec, +} + +impl> LineReader { + pub fn new() -> LineReader { + Self { + queue: VecDeque::new(), + read_pos: 0, + search_pos: 0, + buf: Vec::new(), + } + } + + pub fn push(&mut self, b: T) { + self.queue.push_back(b); + } + + /// Drops everything from the internal queue that was previously returned, i.e. + /// if previously a line was returned we drop this whole line so that we can + /// proceed with the next line + fn drop_previous_line(&mut self) { + // Drop everything we read the last time now + while self.read_pos > 0 + && self.read_pos >= self.queue.front().map(|f| f.as_ref().len()).unwrap_or(0) + { + self.read_pos -= self.queue.front().map(|f| f.as_ref().len()).unwrap_or(0); + self.queue.pop_front(); + if self.search_pos > 0 { + self.search_pos -= 1; + } + } + + self.buf.clear(); + } + + #[allow(unused)] + pub fn get_line_or_drain(&mut self) -> Option<&[u8]> { + self.get_line_with_drain(true) + } + + #[allow(unused)] + pub fn get_line(&mut self) -> Option<&[u8]> { + self.get_line_with_drain(false) + } + + /// Searches the first '\n' in the currently queued buffers and returns the index in buffers + /// inside the queue and the index in bytes from the beginning of the queue, or None. + /// + /// Also updates the search_pos so that we don't look again in the previous buffers on the next + /// call + fn find_newline(&mut self) -> Option<(usize, usize)> { + let mut offset = 0; + for (idx, buf) in self.queue.iter().enumerate() { + let buf = buf.as_ref(); + + // Fast skip-ahead + if idx < self.search_pos { + offset += buf.len(); + continue; + } + + let pos = buf + .iter() + .enumerate() + .skip(if idx == 0 { self.read_pos } else { 0 }) + .find(|(_, b)| **b == b'\n') + .map(|(idx, _)| idx); + + if let Some(pos) = pos { + // On the next call we have to search in this buffer again + // as it might contain a second newline + self.search_pos = idx; + return Some((idx, offset + pos + 1)); + } + + // This buffer did not contain a newline so we don't have to look + // in it again next time + self.search_pos = idx + 1; + offset += buf.len(); + } + + None + } + + /// Copies length bytes from all buffers from the beginning until last_idx into our internal + /// buffer, and skips the first offset bytes from the first buffer. + fn copy_into_internal_buffer(&mut self, last_idx: usize, offset: usize, len: usize) { + // Reserve space for the whole line beforehand + if self.buf.capacity() < len { + self.buf.reserve(len - self.buf.capacity()); + } + + // Then iterate over all buffers inside the queue until the one that contains + // the newline character + for (idx, buf) in self.queue.iter().enumerate().take(last_idx + 1) { + let buf = buf.as_ref(); + + // Calculate how much data we still have to copy + let rem = len - self.buf.len(); + assert!(rem > 0); + + // For the first index we need to take into account the offset. The first + // bytes might have to be skipped and as such we have fewer bytes available + // than the whole length of the buffer + let buf_len = if idx == 0 { + assert!(offset < buf.len()); + buf.len() - offset + } else { + buf.len() + }; + + // Calculate how much we can copy from this buffer. At most the size of the buffer + // itself, but never more than the amount we still have to copy overall + let copy_len = if rem > buf_len { buf_len } else { rem }; + assert!(copy_len > 0); + + if idx == 0 { + self.buf + .extend_from_slice(&buf[offset..(offset + copy_len)]); + } else { + self.buf.extend_from_slice(&buf[..copy_len]); + } + } + + assert_eq!(self.buf.len(), len); + } + + pub fn get_line_with_drain(&mut self, drain: bool) -> Option<&[u8]> { + // Drop all data from the previous line + self.drop_previous_line(); + + // read_pos must always be inside the first buffer of our queue here + // or otherwise we went into an inconsistent state: the first buffer(s) + // would've had to be dropped above then as they are not relevant anymore + assert!( + self.read_pos == 0 + || self.read_pos < self.queue.front().map(|f| f.as_ref().len()).unwrap_or(0) + ); + + // Find the next newline character from our previous position + if let Some((idx, pos)) = self.find_newline() { + // We now need to copy everything from the old read_pos to the new + // pos, and on the next call we have to start from the new pos + let old_read_pos = self.read_pos; + self.read_pos = pos; + + assert!(self.read_pos > old_read_pos); + assert!(idx < self.queue.len()); + + // If the newline is found in the first buffer in our queue, we can directly return + // the slice from it without doing any copying. + // + // On average this should be the most common case. + if idx == 0 { + let buf = self.queue.front().unwrap().as_ref(); + return Some(&buf[old_read_pos..self.read_pos]); + } else { + // Copy into our internal buffer as the current line spans multiple buffers + let len = self.read_pos - old_read_pos; + self.copy_into_internal_buffer(idx, old_read_pos, len); + + return Some(&self.buf[0..len]); + } + } + + // No newline found above and we're not draining, so let's wait until + // more data is available that might contain a newline character + if !drain { + return None; + } + + if self.queue.is_empty() { + return None; + } + + // When draining and we only have a single buffer in the queue we can + // directly return a slice into it + if self.queue.len() == 1 { + let res = &self.queue.front().unwrap().as_ref()[self.read_pos..]; + self.read_pos += res.len(); + self.search_pos = 1; + return Some(res); + } + + // Otherwise we have to copy everything that is remaining into our + // internal buffer and then return a slice from that + let len = self.queue.iter().map(|v| v.as_ref().len()).sum(); + if self.buf.capacity() < len { + self.buf.reserve(len - self.buf.capacity()); + } + + for (idx, ref v) in self.queue.iter().enumerate() { + if idx == 0 { + self.buf.extend_from_slice(&v.as_ref()[self.read_pos..]); + } else { + self.buf.extend_from_slice(v.as_ref()); + } + } + + self.read_pos += self.buf.len(); + self.search_pos = self.queue.len(); + + Some(self.buf.as_ref()) + } + + pub fn clear(&mut self) { + self.queue.clear(); + self.read_pos = 0; + self.search_pos = 0; + self.buf.clear(); + } +} + +#[cfg(test)] +mod tests { + use super::LineReader; + + #[test] + fn test_single_buffer() { + let mut r = LineReader::new(); + r.push(Vec::from(b"abcd\nefgh\nijkl\n".as_ref())); + + assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); + assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); + assert_eq!(r.get_line(), Some(b"ijkl\n".as_ref())); + assert_eq!(r.get_line(), None); + } + + #[test] + fn test_empty_line() { + let mut r = LineReader::new(); + r.push(Vec::from(b"abcd\nefgh\n\nijkl\n".as_ref())); + + assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); + assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); + assert_eq!(r.get_line(), Some(b"\n".as_ref())); + assert_eq!(r.get_line(), Some(b"ijkl\n".as_ref())); + assert_eq!(r.get_line(), None); + } + + #[test] + fn test_multi_buffer_split() { + let mut r = LineReader::new(); + r.push(Vec::from(b"abcd\nef".as_ref())); + r.push(Vec::from(b"gh\nijkl\n".as_ref())); + + assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); + assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); + assert_eq!(r.get_line(), Some(b"ijkl\n".as_ref())); + assert_eq!(r.get_line(), None); + } + + #[test] + fn test_multi_buffer_split_2() { + let mut r = LineReader::new(); + r.push(Vec::from(b"abcd\ne".as_ref())); + r.push(Vec::from(b"f".as_ref())); + r.push(Vec::from(b"g".as_ref())); + r.push(Vec::from(b"h\nijkl\n".as_ref())); + + assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); + assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); + assert_eq!(r.get_line(), Some(b"ijkl\n".as_ref())); + assert_eq!(r.get_line(), None); + } + + #[test] + fn test_single_buffer_drain() { + let mut r = LineReader::new(); + r.push(Vec::from(b"abcd\nefgh\nijkl".as_ref())); + + assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); + assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); + assert_eq!(r.get_line(), None); + assert_eq!(r.get_line_or_drain(), Some(b"ijkl".as_ref())); + assert_eq!(r.get_line_or_drain(), None); + } + + #[test] + fn test_single_buffer_drain_multi_line() { + let mut r = LineReader::new(); + r.push(Vec::from(b"abcd\nefgh\n".as_ref())); + r.push(Vec::from(b"ijkl".as_ref())); + + assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); + assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); + assert_eq!(r.get_line(), None); + assert_eq!(r.get_line_or_drain(), Some(b"ijkl".as_ref())); + assert_eq!(r.get_line_or_drain(), None); + } + + #[test] + fn test_single_buffer_drain_multi_line_2() { + let mut r = LineReader::new(); + r.push(Vec::from(b"abcd\nefgh\ni".as_ref())); + r.push(Vec::from(b"j".as_ref())); + r.push(Vec::from(b"k".as_ref())); + r.push(Vec::from(b"l".as_ref())); + + assert_eq!(r.get_line(), Some(b"abcd\n".as_ref())); + assert_eq!(r.get_line(), Some(b"efgh\n".as_ref())); + assert_eq!(r.get_line(), None); + assert_eq!(r.get_line_or_drain(), Some(b"ijkl".as_ref())); + assert_eq!(r.get_line_or_drain(), None); + } +} diff --git a/gst-plugin-closedcaption/src/mcc_enc.rs b/gst-plugin-closedcaption/src/mcc_enc.rs new file mode 100644 index 00000000..c778bb4a --- /dev/null +++ b/gst-plugin-closedcaption/src/mcc_enc.rs @@ -0,0 +1,641 @@ +// Copyright (C) 2018 Sebastian Dröge +// +// 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 glib; +use glib::prelude::*; +use glib::subclass; +use glib::subclass::prelude::*; +use gst; +use gst::prelude::*; +use gst::subclass::prelude::*; +use gst_video; + +use chrono::prelude::*; +use uuid::Uuid; + +use std::io::Write; +use std::sync::Mutex; + +#[path = "mcc_enc_headers.rs"] +mod mcc_enc_headers; +use self::mcc_enc_headers::*; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Format { + Cea708Cdp, + Cea608, +} + +#[derive(Debug)] +struct State { + format: Option, + need_headers: bool, + start_position: gst::ClockTime, + last_position: gst::ClockTime, +} + +impl Default for State { + fn default() -> Self { + Self { + format: None, + need_headers: true, + start_position: gst::CLOCK_TIME_NONE, + last_position: gst::CLOCK_TIME_NONE, + } + } +} + +#[derive(Debug, Clone)] +struct Settings { + uuid: Option, + creation_date: Option, +} + +impl Default for Settings { + fn default() -> Self { + Self { + uuid: None, + creation_date: None, + } + } +} + +static PROPERTIES: [subclass::Property; 2] = [ + subclass::Property("uuid", |name| { + glib::ParamSpec::string( + name, + "UUID", + "UUID for the output file", + None, + glib::ParamFlags::READWRITE, + ) + }), + subclass::Property("creation-date", |name| { + glib::ParamSpec::boxed( + name, + "Creation Date", + "Creation date for the output file", + glib::DateTime::static_type(), + glib::ParamFlags::READWRITE, + ) + }), +]; + +struct MccEnc { + cat: gst::DebugCategory, + srcpad: gst::Pad, + sinkpad: gst::Pad, + state: Mutex, + settings: Mutex, +} + +impl MccEnc { + fn set_pad_functions(sinkpad: &gst::Pad, srcpad: &gst::Pad) { + sinkpad.set_chain_function(|pad, parent, buffer| { + MccEnc::catch_panic_pad_function( + parent, + || Err(gst::FlowError::Error), + |enc, element| enc.sink_chain(pad, element, buffer), + ) + }); + sinkpad.set_event_function(|pad, parent, event| { + MccEnc::catch_panic_pad_function( + parent, + || false, + |enc, element| enc.sink_event(pad, element, event), + ) + }); + + srcpad.set_event_function(|pad, parent, event| { + MccEnc::catch_panic_pad_function( + parent, + || false, + |enc, element| enc.src_event(pad, element, event), + ) + }); + srcpad.set_query_function(|pad, parent, query| { + MccEnc::catch_panic_pad_function( + parent, + || false, + |enc, element| enc.src_query(pad, element, query), + ) + }); + } + + fn generate_headers(&self, _state: &State, buffer: &mut Vec) -> Result<(), gst::FlowError> { + let settings = self.settings.lock().unwrap(); + + let caps = self + .sinkpad + .get_current_caps() + .ok_or(gst::FlowError::NotNegotiated)?; + let framerate = caps + .get_structure(0) + .unwrap() + .get::("framerate") + .ok_or(gst::FlowError::NotNegotiated)?; + + if framerate == gst::Fraction::new(60000, 1001) { + buffer.extend_from_slice(PREAMBLE_V2); + } else { + buffer.extend_from_slice(PREAMBLE_V1); + } + + if let Some(ref uuid) = settings.uuid { + let _ = write!(buffer, "UUID={}\r\n", uuid); + } else { + let _ = write!(buffer, "UUID={:X}\r\n", Uuid::new_v4().to_hyphenated()); + } + + let _ = write!( + buffer, + "Creation Program=GStreamer MCC Encoder {}\r\n", + env!("CARGO_PKG_VERSION") + ); + + if let Some(ref creation_date) = settings.creation_date { + let creation_date = Utc + .ymd( + creation_date.get_year() as i32, + creation_date.get_month() as u32, + creation_date.get_day_of_month() as u32, + ) + .and_hms( + creation_date.get_hour() as u32, + creation_date.get_minute() as u32, + creation_date.get_seconds() as u32, + ) + .with_timezone(&FixedOffset::east( + (creation_date.get_utc_offset() / 1_000_000) as i32, + )); + + let _ = write!( + buffer, + "Creation Date={}\r\n", + creation_date.format("%A, %B %d, %Y") + ); + let _ = write!( + buffer, + "Creation Time={}\r\n", + creation_date.format("%H:%M:%S") + ); + } else { + let creation_date = Local::now(); + let _ = write!( + buffer, + "Creation Date={}\r\n", + creation_date.format("%A, %B %d, %Y") + ); + let _ = write!( + buffer, + "Creation Time={}\r\n", + creation_date.format("%H:%M:%S") + ); + } + + if *framerate.denom() == 1 { + let _ = write!(buffer, "Time Code Rate={}\r\n", *framerate.numer()); + } else { + assert_eq!(*framerate.denom(), 1001); + let _ = write!(buffer, "Time Code Rate={}DF\r\n", *framerate.numer() / 1000); + } + let _ = write!(buffer, "\r\n"); + + Ok(()) + } + + fn encode_payload(outbuf: &mut Vec, mut slice: &[u8]) { + while !slice.is_empty() { + if slice.starts_with( + [ + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, + 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, + 0x00, + ] + .as_ref(), + ) { + outbuf.push(b'O'); + slice = &slice[27..]; + } else if slice.starts_with( + [ + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, + 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + ] + .as_ref(), + ) { + outbuf.push(b'N'); + slice = &slice[24..]; + } else if slice.starts_with( + [ + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, + 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + ] + .as_ref(), + ) { + outbuf.push(b'M'); + slice = &slice[21..]; + } else if slice.starts_with( + [ + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, + 0x00, 0x00, 0xFA, 0x00, 0x00, + ] + .as_ref(), + ) { + outbuf.push(b'L'); + slice = &slice[18..]; + } else if slice.starts_with( + [ + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, + 0x00, 0x00, + ] + .as_ref(), + ) { + outbuf.push(b'K'); + slice = &slice[15..]; + } else if slice.starts_with( + [ + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + ] + .as_ref(), + ) { + outbuf.push(b'J'); + slice = &slice[12..]; + } else if slice + .starts_with([0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00].as_ref()) + { + outbuf.push(b'I'); + slice = &slice[9..]; + } else if slice.starts_with([0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00].as_ref()) { + outbuf.push(b'H'); + slice = &slice[6..]; + } else if slice.starts_with([0xFA, 0x00, 0x00].as_ref()) { + outbuf.push(b'G'); + slice = &slice[3..]; + } else if slice.starts_with([0xFB, 0x80, 0x80].as_ref()) { + outbuf.push(b'P'); + slice = &slice[3..]; + } else if slice.starts_with([0xFC, 0x80, 0x80].as_ref()) { + outbuf.push(b'Q'); + slice = &slice[3..]; + } else if slice.starts_with([0xFD, 0x80, 0x80].as_ref()) { + outbuf.push(b'R'); + slice = &slice[3..]; + } else if slice.starts_with([0x96, 0x69].as_ref()) { + outbuf.push(b'S'); + slice = &slice[2..]; + } else if slice.starts_with([0x61, 0x01].as_ref()) { + outbuf.push(b'T'); + slice = &slice[2..]; + } else if slice.starts_with([0xE1, 0x00, 0x00, 0x00].as_ref()) { + outbuf.push(b'U'); + slice = &slice[4..]; + } else if slice[0] == 0x00 { + outbuf.push(b'Z'); + slice = &slice[1..]; + } else { + let _ = write!(outbuf, "{:02X}", slice[0]); + slice = &slice[1..]; + } + } + } + + fn generate_caption( + &self, + element: &gst::Element, + state: &State, + buffer: &gst::Buffer, + outbuf: &mut Vec, + ) -> Result<(), gst::FlowError> { + let meta = buffer + .get_meta::() + .ok_or_else(|| { + gst_element_error!( + element, + gst::StreamError::Format, + ["Stream with timecodes on each buffer required"] + ); + + gst::FlowError::Error + })?; + + let _ = write!(outbuf, "{}\t", meta.get_tc()); + + let map = buffer.map_readable().ok_or_else(|| { + gst_element_error!( + element, + gst::StreamError::Format, + ["Failed to map buffer readable"] + ); + + gst::FlowError::Error + })?; + + let len = map.len(); + if len >= 256 { + gst_element_error!( + element, + gst::StreamError::Format, + ["Too big buffer: {}", map.len()] + ); + + return Err(gst::FlowError::Error); + } + let len = len as u8; + + match state.format { + Some(Format::Cea608) => { + let _ = write!(outbuf, "6102{:02X}", len); + } + Some(Format::Cea708Cdp) => { + let _ = write!(outbuf, "T{:02X}", len); + } + _ => return Err(gst::FlowError::NotNegotiated), + }; + + let checksum = map.iter().fold(0u8, |sum, b| sum.wrapping_add(*b)); + Self::encode_payload(outbuf, &*map); + + if checksum == 0 { + outbuf.push(b'Z'); + } else { + let _ = write!(outbuf, "{:02X}", checksum); + } + + outbuf.extend_from_slice(b"\r\n".as_ref()); + + Ok(()) + } + + fn sink_chain( + &self, + pad: &gst::Pad, + element: &gst::Element, + buffer: gst::Buffer, + ) -> Result { + gst_log!(self.cat, obj: pad, "Handling buffer {:?}", buffer); + + let mut state = self.state.lock().unwrap(); + + let mut outbuf = Vec::new(); + if state.need_headers { + state.need_headers = false; + self.generate_headers(&*state, &mut outbuf)?; + } + + self.generate_caption(element, &*state, &buffer, &mut outbuf)?; + drop(state); + + self.srcpad.push(gst::Buffer::from_mut_slice(outbuf)) + } + + fn sink_event(&self, pad: &gst::Pad, element: &gst::Element, event: gst::Event) -> bool { + use gst::EventView; + + gst_log!(self.cat, obj: pad, "Handling event {:?}", event); + + match event.view() { + EventView::Caps(ev) => { + let caps = ev.get_caps(); + let s = caps.get_structure(0).unwrap(); + let framerate = if let Some(framerate) = s.get::("framerate") { + framerate + } else { + gst_error!(self.cat, obj: pad, "Caps without framerate"); + return false; + }; + + let mut state = self.state.lock().unwrap(); + if s.get_name() == "closedcaption/x-cea-608" { + state.format = Some(Format::Cea608); + } else { + state.format = Some(Format::Cea708Cdp); + } + drop(state); + + // We send our own caps downstream + let caps = gst::Caps::builder("application/x-mcc") + .field( + "version", + if framerate == gst::Fraction::new(60000, 1001) { + &2i32 + } else { + &1i32 + }, + ) + .build(); + self.srcpad.push_event(gst::Event::new_caps(&caps).build()) + } + _ => pad.event_default(element, event), + } + } + + fn src_event(&self, pad: &gst::Pad, element: &gst::Element, event: gst::Event) -> bool { + use gst::EventView; + + gst_log!(self.cat, obj: pad, "Handling event {:?}", event); + match event.view() { + EventView::Seek(_) => { + gst_log!(self.cat, obj: pad, "Dropping seek event"); + false + } + _ => pad.event_default(element, event), + } + } + + fn src_query(&self, pad: &gst::Pad, element: &gst::Element, query: &mut gst::QueryRef) -> bool { + use gst::QueryView; + + gst_log!(self.cat, obj: pad, "Handling query {:?}", query); + + match query.view_mut() { + QueryView::Seeking(mut q) => { + // We don't support any seeking at all + let fmt = q.get_format(); + q.set( + false, + gst::GenericFormattedValue::Other(fmt, -1), + gst::GenericFormattedValue::Other(fmt, -1), + ); + true + } + QueryView::Position(ref mut q) => { + // For Time answer ourselfs, otherwise forward + if q.get_format() == gst::Format::Time { + let state = self.state.lock().unwrap(); + q.set(state.last_position); + true + } else { + self.sinkpad.peer_query(query) + } + } + _ => pad.query_default(element, query), + } + } +} + +impl ObjectSubclass for MccEnc { + const NAME: &'static str = "RsMccEnc"; + type ParentType = gst::Element; + type Instance = gst::subclass::ElementInstanceStruct; + type Class = subclass::simple::ClassStruct; + + glib_object_subclass!(); + + fn new_with_class(klass: &subclass::simple::ClassStruct) -> Self { + let templ = klass.get_pad_template("sink").unwrap(); + let sinkpad = gst::Pad::new_from_template(&templ, "sink"); + let templ = klass.get_pad_template("src").unwrap(); + let srcpad = gst::Pad::new_from_template(&templ, "src"); + + MccEnc::set_pad_functions(&sinkpad, &srcpad); + + Self { + cat: gst::DebugCategory::new( + "mccenc", + gst::DebugColorFlags::empty(), + "Mcc Encoder Element", + ), + srcpad, + sinkpad, + state: Mutex::new(State::default()), + settings: Mutex::new(Settings::default()), + } + } + + fn class_init(klass: &mut subclass::simple::ClassStruct) { + klass.set_metadata( + "Mcc Encoder", + "Encoder/ClosedCaption", + "Encodes MCC Closed Caption Files", + "Sebastian Dröge ", + ); + + let mut caps = gst::Caps::new_empty(); + { + let caps = caps.get_mut().unwrap(); + + let framerates = gst::List::new(&[ + &gst::Fraction::new(24, 1), + &gst::Fraction::new(25, 1), + &gst::Fraction::new(30000, 1001), + &gst::Fraction::new(30, 1), + &gst::Fraction::new(50, 1), + &gst::Fraction::new(60000, 1001), + &gst::Fraction::new(60, 1), + ]); + + let s = gst::Structure::builder("closedcaption/x-cea-708") + .field("format", &"cdp") + .field("framerate", &framerates) + .build(); + caps.append_structure(s); + + let s = gst::Structure::builder("closedcaption/x-cea-608") + .field("format", &"s334-1a") + .field("framerate", &framerates) + .build(); + caps.append_structure(s); + } + let sink_pad_template = gst::PadTemplate::new( + "sink", + gst::PadDirection::Sink, + gst::PadPresence::Always, + &caps, + ); + klass.add_pad_template(sink_pad_template); + + let caps = gst::Caps::builder("application/x-mcc").build(); + let src_pad_template = gst::PadTemplate::new( + "src", + gst::PadDirection::Src, + gst::PadPresence::Always, + &caps, + ); + klass.add_pad_template(src_pad_template); + + klass.install_properties(&PROPERTIES); + } +} + +impl ObjectImpl for MccEnc { + glib_object_impl!(); + + fn set_property(&self, _obj: &glib::Object, id: usize, value: &glib::Value) { + let prop = &PROPERTIES[id]; + + match *prop { + subclass::Property("uuid", ..) => { + let mut settings = self.settings.lock().unwrap(); + settings.uuid = value.get(); + } + subclass::Property("creation-date", ..) => { + let mut settings = self.settings.lock().unwrap(); + settings.creation_date = value.get(); + } + _ => unimplemented!(), + } + } + + fn get_property(&self, _obj: &glib::Object, id: usize) -> Result { + let prop = &PROPERTIES[id]; + + match *prop { + subclass::Property("uuid", ..) => { + let settings = self.settings.lock().unwrap(); + Ok(settings.uuid.to_value()) + } + subclass::Property("creation-date", ..) => { + let settings = self.settings.lock().unwrap(); + Ok(settings.creation_date.to_value()) + } + _ => unimplemented!(), + } + } + + fn constructed(&self, obj: &glib::Object) { + self.parent_constructed(obj); + + let element = obj.downcast_ref::().unwrap(); + element.add_pad(&self.sinkpad).unwrap(); + element.add_pad(&self.srcpad).unwrap(); + } +} + +impl ElementImpl for MccEnc { + fn change_state( + &self, + element: &gst::Element, + transition: gst::StateChange, + ) -> Result { + gst_trace!(self.cat, obj: element, "Changing state {:?}", transition); + + match transition { + gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { + // Reset the whole state + let mut state = self.state.lock().unwrap(); + *state = State::default(); + } + _ => (), + } + + self.parent_change_state(element, transition) + } +} + +pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> { + gst::Element::register(plugin, "mccenc", 0, MccEnc::get_type()) +} diff --git a/gst-plugin-closedcaption/src/mcc_enc_headers.rs b/gst-plugin-closedcaption/src/mcc_enc_headers.rs new file mode 100644 index 00000000..6995c99c --- /dev/null +++ b/gst-plugin-closedcaption/src/mcc_enc_headers.rs @@ -0,0 +1,95 @@ +// Copyright (C) 2018 Sebastian Dröge +// +// 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. + +pub const PREAMBLE_V1: &[u8] = b"File Format=MacCaption_MCC V1.0\r\n\ +\r\n\ +///////////////////////////////////////////////////////////////////////////////////\r\n\ +// Computer Prompting and Captioning Company\r\n\ +// Ancillary Data Packet Transfer File\r\n\ +//\r\n\ +// Permission to generate this format is granted provided that\r\n\ +// 1. This ANC Transfer file format is used on an as-is basis and no warranty is given, and\r\n\ +// 2. This entire descriptive information text is included in a generated .mcc file.\r\n\ +//\r\n\ +// General file format:\r\n\ +// HH:MM:SS:FF(tab)[Hexadecimal ANC data in groups of 2 characters]\r\n\ +// Hexadecimal data starts with the Ancillary Data Packet DID (Data ID defined in S291M)\r\n\ +// and concludes with the Check Sum following the User Data Words.\r\n\ +// Each time code line must contain at most one complete ancillary data packet.\r\n\ +// To transfer additional ANC Data successive lines may contain identical time code.\r\n\ +// Time Code Rate=[24, 25, 30, 30DF, 50, 60]\r\n\ +//\r\n\ +// ANC data bytes may be represented by one ASCII character according to the following schema:\r\n\ +// G FAh 00h 00h\r\n\ +// H 2 x (FAh 00h 00h)\r\n\ +// I 3 x (FAh 00h 00h)\r\n\ +// J 4 x (FAh 00h 00h)\r\n\ +// K 5 x (FAh 00h 00h)\r\n\ +// L 6 x (FAh 00h 00h)\r\n\ +// M 7 x (FAh 00h 00h)\r\n\ +// N 8 x (FAh 00h 00h)\r\n\ +// O 9 x (FAh 00h 00h)\r\n\ +// P FBh 80h 80h\r\n\ +// Q FCh 80h 80h\r\n\ +// R FDh 80h 80h\r\n\ +// S 96h 69h\r\n\ +// T 61h 01h\r\n\ +// U E1h 00h 00h 00h\r\n\ +// Z 00h\r\n\ +//\r\n\ +///////////////////////////////////////////////////////////////////////////////////\r\n\ +\r\n"; + +pub const PREAMBLE_V2: &[u8] = b"File Format=MacCaption_MCC V2.0\r\n\ +\r\n\ +///////////////////////////////////////////////////////////////////////////////////\r\n\ +// Computer Prompting and Captioning Company\r\n\ +// Ancillary Data Packet Transfer File\r\n\ +//\r\n\ +// Permission to generate this format is granted provided that\r\n\ +// 1. This ANC Transfer file format is used on an as-is basis and no warranty is given, and\r\n\ +// 2. This entire descriptive information text is included in a generated .mcc file.\r\n\ +//\r\n\ +// General file format:\r\n\ +// HH:MM:SS:FF(tab)[Hexadecimal ANC data in groups of 2 characters]\r\n\ +// Hexadecimal data starts with the Ancillary Data Packet DID (Data ID defined in S291M)\r\n\ +// and concludes with the Check Sum following the User Data Words.\r\n\ +// Each time code line must contain at most one complete ancillary data packet.\r\n\ +// To transfer additional ANC Data successive lines may contain identical time code.\r\n\ +// Time Code Rate=[24, 25, 30, 30DF, 50, 60, 60DF]\r\n\ +// Time Code Rate=[24, 25, 30, 30DF, 50, 60]\r\n\ +//\r\n\ +// ANC data bytes may be represented by one ASCII character according to the following schema:\r\n\ +// G FAh 00h 00h\r\n\ +// H 2 x (FAh 00h 00h)\r\n\ +// I 3 x (FAh 00h 00h)\r\n\ +// J 4 x (FAh 00h 00h)\r\n\ +// K 5 x (FAh 00h 00h)\r\n\ +// L 6 x (FAh 00h 00h)\r\n\ +// M 7 x (FAh 00h 00h)\r\n\ +// N 8 x (FAh 00h 00h)\r\n\ +// O 9 x (FAh 00h 00h)\r\n\ +// P FBh 80h 80h\r\n\ +// Q FCh 80h 80h\r\n\ +// R FDh 80h 80h\r\n\ +// S 96h 69h\r\n\ +// T 61h 01h\r\n\ +// U E1h 00h 00h 00h\r\n\ +// Z 00h\r\n\ +//\r\n\ +///////////////////////////////////////////////////////////////////////////////////\r\n\ +\r\n"; diff --git a/gst-plugin-closedcaption/src/mcc_parse.rs b/gst-plugin-closedcaption/src/mcc_parse.rs new file mode 100644 index 00000000..c9808eb2 --- /dev/null +++ b/gst-plugin-closedcaption/src/mcc_parse.rs @@ -0,0 +1,614 @@ +// Copyright (C) 2018 Sebastian Dröge +// +// 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 glib; +use glib::prelude::*; +use glib::subclass; +use glib::subclass::prelude::*; +use gst; +use gst::prelude::*; +use gst::subclass::prelude::*; +use gst_video; + +use std::sync::Mutex; + +use crate::line_reader::LineReader; +use crate::mcc_parser::{MccLine, MccParser}; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Format { + Cea708Cdp, + Cea608, +} + +#[derive(Debug)] +struct State { + reader: LineReader>, + parser: MccParser, + format: Option, + need_segment: bool, + pending_events: Vec, + start_position: gst::ClockTime, + last_position: gst::ClockTime, + last_timecode: Option, + timecode_rate: Option<(u8, bool)>, +} + +impl Default for State { + fn default() -> Self { + Self { + reader: LineReader::new(), + parser: MccParser::new(), + format: None, + need_segment: true, + pending_events: Vec::new(), + start_position: gst::CLOCK_TIME_NONE, + last_position: gst::CLOCK_TIME_NONE, + last_timecode: None, + timecode_rate: None, + } + } +} + +impl State { + fn get_line( + &mut self, + drain: bool, + ) -> Result< + Option, + ( + &[u8], + combine::easy::Errors, + ), + > { + let line = match self.reader.get_line_with_drain(drain) { + None => { + return Ok(None); + } + Some(line) => line, + }; + + self.parser + .parse_line(line) + .map(Option::Some) + .map_err(|err| (line, err)) + } +} + +struct MccParse { + cat: gst::DebugCategory, + srcpad: gst::Pad, + sinkpad: gst::Pad, + state: Mutex, +} + +#[derive(Debug)] +struct OffsetVec { + vec: Vec, + offset: usize, + len: usize, +} + +impl AsRef<[u8]> for OffsetVec { + fn as_ref(&self) -> &[u8] { + &self.vec[self.offset..(self.offset + self.len)] + } +} + +impl AsMut<[u8]> for OffsetVec { + fn as_mut(&mut self) -> &mut [u8] { + &mut self.vec[self.offset..(self.offset + self.len)] + } +} + +impl MccParse { + fn set_pad_functions(sinkpad: &gst::Pad, srcpad: &gst::Pad) { + sinkpad.set_chain_function(|pad, parent, buffer| { + MccParse::catch_panic_pad_function( + parent, + || Err(gst::FlowError::Error), + |parse, element| parse.sink_chain(pad, element, buffer), + ) + }); + sinkpad.set_event_function(|pad, parent, event| { + MccParse::catch_panic_pad_function( + parent, + || false, + |parse, element| parse.sink_event(pad, element, event), + ) + }); + + srcpad.set_event_function(|pad, parent, event| { + MccParse::catch_panic_pad_function( + parent, + || false, + |parse, element| parse.src_event(pad, element, event), + ) + }); + srcpad.set_query_function(|pad, parent, query| { + MccParse::catch_panic_pad_function( + parent, + || false, + |parse, element| parse.src_query(pad, element, query), + ) + }); + } + + fn handle_buffer( + &self, + element: &gst::Element, + buffer: Option, + ) -> Result { + let mut state = self.state.lock().unwrap(); + + let drain; + if let Some(buffer) = buffer { + let buffer = buffer.into_mapped_buffer_readable().map_err(|_| { + gst_element_error!( + element, + gst::ResourceError::Read, + ["Failed to map buffer readable"] + ); + + gst::FlowError::Error + })?; + + state.reader.push(buffer); + drain = false; + } else { + drain = true; + } + + loop { + let line = state.get_line(drain); + match line { + Ok(Some(MccLine::Caption(tc, data))) => { + gst_trace!( + self.cat, + obj: element, + "Got caption buffer with timecode {:?} and size {}", + tc, + data.len() + ); + + if data.len() < 3 { + gst_debug!( + self.cat, + obj: element, + "Too small caption packet: {}", + data.len(), + ); + continue; + } + + let format = match (data[0], data[1]) { + (0x61, 0x01) => Format::Cea708Cdp, + (0x61, 0x02) => Format::Cea608, + (did, sdid) => { + gst_debug!( + self.cat, + obj: element, + "Unknown DID {:x} SDID {:x}", + did, + sdid + ); + continue; + } + }; + + let len = data[2]; + if data.len() < 3 + len as usize { + gst_debug!( + self.cat, + obj: element, + "Too small caption packet: {} < {}", + data.len(), + 3 + len, + ); + continue; + } + + let (framerate, drop_frame) = match state.timecode_rate { + Some((rate, false)) => (gst::Fraction::new(rate as i32, 1), false), + Some((rate, true)) => (gst::Fraction::new(rate as i32 * 1000, 1001), true), + None => { + gst_element_error!( + element, + gst::StreamError::Decode, + ["Got caption before time code rate"] + ); + + break Err(gst::FlowError::Error); + } + }; + + let mut events = Vec::new(); + + if state.format != Some(format) { + state.format = Some(format); + + let caps = match format { + Format::Cea708Cdp => gst::Caps::builder("closedcaption/x-cea-708") + .field("format", &"cdp") + .field("framerate", &framerate) + .build(), + Format::Cea608 => gst::Caps::builder("closedcaption/x-cea-608") + .field("format", &"s334-1a") + .field("framerate", &framerate) + .build(), + }; + + events.push(gst::Event::new_caps(&caps).build()); + } + + if state.need_segment { + let segment = gst::FormattedSegment::::new(); + events.push(gst::Event::new_segment(&segment).build()); + state.need_segment = false; + } + + events.extend(state.pending_events.drain(..)); + + let timecode = gst_video::VideoTimeCode::new( + framerate, + None, + if drop_frame { + gst_video::VideoTimeCodeFlags::DROP_FRAME + } else { + gst_video::VideoTimeCodeFlags::empty() + }, + tc.hours, + tc.minutes, + tc.seconds, + tc.frames, + 0, + ); + + let timecode = match timecode.try_into() { + Ok(timecode) => timecode, + Err(timecode) => { + let last_timecode = + state.last_timecode.as_ref().map(Clone::clone).ok_or_else( + || { + gst_element_error!( + element, + gst::StreamError::Decode, + ["Invalid first timecode {:?}", timecode] + ); + + gst::FlowError::Error + }, + )?; + + gst_warning!( + self.cat, + obj: element, + "Invalid timecode {:?}, using previous {:?}", + timecode, + last_timecode + ); + + last_timecode + } + }; + + let mut buffer = gst::Buffer::from_mut_slice(OffsetVec { + vec: data, + offset: 3, + len: len as usize, + }); + + { + let buffer = buffer.get_mut().unwrap(); + gst_video::VideoTimeCodeMeta::add(buffer, &timecode); + + // Calculate a timestamp from the timecode and make sure to + // not produce timestamps jumping backwards + let nsecs = gst::ClockTime::from(timecode.nsec_since_daily_jam()); + if state.start_position.is_none() { + state.start_position = nsecs; + } + + let nsecs = if nsecs < state.start_position { + gst_fixme!( + self.cat, + obj: element, + "New position {} < start position {}", + nsecs, + state.start_position + ); + state.start_position + } else { + nsecs - state.start_position + }; + + if nsecs >= state.last_position { + state.last_position = nsecs; + } else { + gst_fixme!( + self.cat, + obj: element, + "New position {} < last position {}", + nsecs, + state.last_position + ); + } + + buffer.set_pts(state.last_position); + buffer.set_duration( + gst::SECOND + .mul_div_ceil(*framerate.denom() as u64, *framerate.numer() as u64) + .unwrap_or(gst::CLOCK_TIME_NONE), + ); + } + + // Drop our state mutex while we push out buffers or events + drop(state); + + for event in events { + gst_debug!(self.cat, obj: element, "Pushing event {:?}", event); + self.srcpad.push_event(event); + } + + self.srcpad.push(buffer).map_err(|err| { + gst_error!(self.cat, obj: element, "Pushing buffer returned {:?}", err); + err + })?; + + state = self.state.lock().unwrap(); + } + Ok(Some(MccLine::TimeCodeRate(rate, df))) => { + gst_debug!( + self.cat, + obj: element, + "Got timecode rate {} (drop frame {})", + rate, + df + ); + state.timecode_rate = Some((rate, df)); + } + Ok(Some(line)) => { + gst_debug!(self.cat, obj: element, "Got line '{:?}'", line); + } + Err((line, err)) => { + gst_element_error!( + element, + gst::StreamError::Decode, + ["Couldn't parse line '{:?}': {:?}", line, err] + ); + + break Err(gst::FlowError::Error); + } + Ok(None) => break Ok(gst::FlowSuccess::Ok), + } + } + } + + fn sink_chain( + &self, + pad: &gst::Pad, + element: &gst::Element, + buffer: gst::Buffer, + ) -> Result { + gst_log!(self.cat, obj: pad, "Handling buffer {:?}", buffer); + + self.handle_buffer(element, Some(buffer)) + } + + fn sink_event(&self, pad: &gst::Pad, element: &gst::Element, event: gst::Event) -> bool { + use gst::EventView; + + gst_log!(self.cat, obj: pad, "Handling event {:?}", event); + + match event.view() { + EventView::Caps(_) => { + // We send a proper caps event from the chain function later + gst_log!(self.cat, obj: pad, "Dropping caps event"); + true + } + EventView::Segment(_) => { + // We send a gst::Format::Time segment event later when needed + gst_log!(self.cat, obj: pad, "Dropping segment event"); + true + } + EventView::FlushStop(_) => { + let mut state = self.state.lock().unwrap(); + state.reader.clear(); + state.parser.reset(); + state.need_segment = true; + state.pending_events.clear(); + + pad.event_default(element, event) + } + EventView::Eos(_) => { + gst_log!(self.cat, obj: pad, "Draining"); + if let Err(err) = self.handle_buffer(element, None) { + gst_error!(self.cat, obj: pad, "Failed to drain parser: {:?}", err); + } + pad.event_default(element, event) + } + _ => { + if event.is_sticky() + && !self.srcpad.has_current_caps() + && event.get_type() > gst::EventType::Caps + { + gst_log!( + self.cat, + obj: pad, + "Deferring sticky event until we have caps" + ); + let mut state = self.state.lock().unwrap(); + state.pending_events.push(event); + true + } else { + pad.event_default(element, event) + } + } + } + } + + fn src_event(&self, pad: &gst::Pad, element: &gst::Element, event: gst::Event) -> bool { + use gst::EventView; + + gst_log!(self.cat, obj: pad, "Handling event {:?}", event); + match event.view() { + EventView::Seek(_) => { + gst_log!(self.cat, obj: pad, "Dropping seek event"); + false + } + _ => pad.event_default(element, event), + } + } + + fn src_query(&self, pad: &gst::Pad, element: &gst::Element, query: &mut gst::QueryRef) -> bool { + use gst::QueryView; + + gst_log!(self.cat, obj: pad, "Handling query {:?}", query); + + match query.view_mut() { + QueryView::Seeking(mut q) => { + // We don't support any seeking at all + let fmt = q.get_format(); + q.set( + false, + gst::GenericFormattedValue::Other(fmt, -1), + gst::GenericFormattedValue::Other(fmt, -1), + ); + true + } + QueryView::Position(ref mut q) => { + // For Time answer ourselfs, otherwise forward + if q.get_format() == gst::Format::Time { + let state = self.state.lock().unwrap(); + q.set(state.last_position); + true + } else { + self.sinkpad.peer_query(query) + } + } + _ => pad.query_default(element, query), + } + } +} + +impl ObjectSubclass for MccParse { + const NAME: &'static str = "RsMccParse"; + type ParentType = gst::Element; + type Instance = gst::subclass::ElementInstanceStruct; + type Class = subclass::simple::ClassStruct; + + glib_object_subclass!(); + + fn new_with_class(klass: &subclass::simple::ClassStruct) -> Self { + let templ = klass.get_pad_template("sink").unwrap(); + let sinkpad = gst::Pad::new_from_template(&templ, "sink"); + let templ = klass.get_pad_template("src").unwrap(); + let srcpad = gst::Pad::new_from_template(&templ, "src"); + + MccParse::set_pad_functions(&sinkpad, &srcpad); + + Self { + cat: gst::DebugCategory::new( + "mccparse", + gst::DebugColorFlags::empty(), + "Mcc Parser Element", + ), + srcpad, + sinkpad, + state: Mutex::new(State::default()), + } + } + + fn class_init(klass: &mut subclass::simple::ClassStruct) { + klass.set_metadata( + "Mcc Parse", + "Parser/ClosedCaption", + "Parses MCC Closed Caption Files", + "Sebastian Dröge ", + ); + + let mut caps = gst::Caps::new_empty(); + { + let caps = caps.get_mut().unwrap(); + + let s = gst::Structure::builder("closedcaption/x-cea-708") + .field("format", &"cdp") + .build(); + caps.append_structure(s); + + let s = gst::Structure::builder("closedcaption/x-cea-608") + .field("format", &"s334-1a") + .build(); + caps.append_structure(s); + } + let src_pad_template = gst::PadTemplate::new( + "src", + gst::PadDirection::Src, + gst::PadPresence::Always, + &caps, + ); + klass.add_pad_template(src_pad_template); + + let caps = gst::Caps::builder("application/x-mcc") + .field("version", &gst::List::new(&[&1i32, &2i32])) + .build(); + let sink_pad_template = gst::PadTemplate::new( + "sink", + gst::PadDirection::Sink, + gst::PadPresence::Always, + &caps, + ); + klass.add_pad_template(sink_pad_template); + } +} + +impl ObjectImpl for MccParse { + glib_object_impl!(); + + fn constructed(&self, obj: &glib::Object) { + self.parent_constructed(obj); + + let element = obj.downcast_ref::().unwrap(); + element.add_pad(&self.sinkpad).unwrap(); + element.add_pad(&self.srcpad).unwrap(); + } +} + +impl ElementImpl for MccParse { + fn change_state( + &self, + element: &gst::Element, + transition: gst::StateChange, + ) -> Result { + gst_trace!(self.cat, obj: element, "Changing state {:?}", transition); + + match transition { + gst::StateChange::ReadyToPaused | gst::StateChange::PausedToReady => { + // Reset the whole state + let mut state = self.state.lock().unwrap(); + *state = State::default(); + } + _ => (), + } + + self.parent_change_state(element, transition) + } +} + +pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> { + gst::Element::register(plugin, "mccparse", 0, MccParse::get_type()) +} diff --git a/gst-plugin-closedcaption/src/mcc_parser.rs b/gst-plugin-closedcaption/src/mcc_parser.rs new file mode 100644 index 00000000..fe9aca6a --- /dev/null +++ b/gst-plugin-closedcaption/src/mcc_parser.rs @@ -0,0 +1,793 @@ +// Copyright (C) 2018 Sebastian Dröge +// +// 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 either::Either; + +use combine; +use combine::parser::byte::hex_digit; +use combine::parser::range::{range, take_while1}; +use combine::parser::repeat::skip_many; +use combine::{any, choice, eof, from_str, many1, one_of, optional, token, unexpected_any, value}; +use combine::{ParseError, Parser, RangeStream}; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct TimeCode { + pub hours: u32, + pub minutes: u32, + pub seconds: u32, + pub frames: u32, + pub drop_frame: bool, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum MccLine<'a> { + Header, + Comment, + Empty, + UUID(&'a [u8]), + Metadata(&'a [u8], &'a [u8]), + TimeCodeRate(u8, bool), + Caption(TimeCode, Vec), +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum State { + Init, + Header, + Comments, + Metadata, + Captions, +} + +#[derive(Debug)] +pub struct MccParser { + state: State, +} + +/// Parser for parsing a run of ASCII, decimal digits and converting them into a `u32` +fn digits<'a, I: 'a>() -> impl Parser +where + I: RangeStream, + I::Error: ParseError, +{ + from_str(take_while1(|c: u8| c >= b'0' && c <= b'9').message("while parsing digits")) +} + +/// Copy from std::ops::RangeBounds as it's not stabilized yet. +/// +/// Checks if `item` is in the range `range`. +fn contains, U>(range: &R, item: &U) -> bool +where + U: ?Sized + PartialOrd, +{ + (match range.start_bound() { + std::ops::Bound::Included(ref start) => *start <= item, + std::ops::Bound::Excluded(ref start) => *start < item, + std::ops::Bound::Unbounded => true, + }) && (match range.end_bound() { + std::ops::Bound::Included(ref end) => item <= *end, + std::ops::Bound::Excluded(ref end) => item < *end, + std::ops::Bound::Unbounded => true, + }) +} + +/// Parser for a run of decimal digits, that converts them into a `u32` and checks if the result is +/// in the allowed range. +fn digits_range<'a, I: 'a, R: std::ops::RangeBounds>( + range: R, +) -> impl Parser +where + I: RangeStream, + I::Error: ParseError, +{ + digits().then(move |v| { + if contains(&range, &v) { + value(v).left() + } else { + unexpected_any("digits out of range").right() + } + }) +} + +/// Parser for a timecode in the form `hh:mm:ss:fs` +fn timecode<'a, I: 'a>() -> impl Parser +where + I: RangeStream, + I::Error: ParseError, +{ + ( + digits(), + token(b':'), + digits_range(0..60), + token(b':'), + digits_range(0..60), + one_of([b':', b'.', b';', b','].iter().cloned()), + digits(), + ) + .map(|(hours, _, minutes, _, seconds, sep, frames)| TimeCode { + hours, + minutes, + seconds, + frames, + drop_frame: sep == b';' || sep == b',', + }) + .message("while parsing timecode") +} + +/// Parser that checks for EOF and optionally `\n` or `\r\n` before EOF +fn end_of_line<'a, I: 'a>() -> impl Parser + 'a +where + I: RangeStream, + I::Error: ParseError, +{ + ( + optional(choice((range(b"\n".as_ref()), range(b"\r\n".as_ref())))), + eof(), + ) + .map(|_| ()) + .message("while parsing end of line") +} + +/// Parser for the MCC header +fn header<'a, I: 'a>() -> impl Parser> +where + I: RangeStream, + I::Error: ParseError, +{ + ( + range(b"File Format=MacCaption_MCC V".as_ref()), + choice!(range(b"1.0".as_ref()), range(b"2.0".as_ref())), + end_of_line(), + ) + .map(|_| MccLine::Header) + .message("while parsing header") +} + +/// Parser that accepts only an empty line +fn empty_line<'a, I: 'a>() -> impl Parser> +where + I: RangeStream, + I::Error: ParseError, +{ + end_of_line() + .map(|_| MccLine::Empty) + .message("while parsing empty line") +} + +/// Parser for an MCC comment, i.e. a line starting with `//`. We don't return the actual comment +/// text as it's irrelevant for us. +fn comment<'a, I: 'a>() -> impl Parser> +where + I: RangeStream, + I::Error: ParseError, +{ + (token(b'/'), token(b'/'), skip_many(any())) + .map(|_| MccLine::Comment) + .message("while parsing comment") +} + +/// Parser for the MCC UUID line. +fn uuid<'a, I: 'a>() -> impl Parser> +where + I: RangeStream, + I::Error: ParseError, +{ + ( + range(b"UUID=".as_ref()), + take_while1(|b| b != b'\n' && b != b'\r'), + end_of_line(), + ) + .map(|(_, uuid, _)| MccLine::UUID(uuid)) + .message("while parsing UUID") +} + +/// Parser for the MCC Time Code Rate line. +fn time_code_rate<'a, I: 'a>() -> impl Parser> +where + I: RangeStream, + I::Error: ParseError, +{ + ( + range(b"Time Code Rate=".as_ref()), + digits_range(1..256) + .and(optional(range(b"DF".as_ref()))) + .map(|(v, df)| MccLine::TimeCodeRate(v as u8, df.is_some())), + end_of_line(), + ) + .map(|(_, v, _)| v) + .message("while parsing time code rate") +} + +/// Parser for generic MCC metadata lines in the form `key=value`. +fn metadata<'a, I: 'a>() -> impl Parser> +where + I: RangeStream, + I::Error: ParseError, +{ + ( + take_while1(|b| b != b'='), + token(b'='), + take_while1(|b| b != b'\n' && b != b'\r'), + end_of_line(), + ) + .map(|(name, _, value, _)| MccLine::Metadata(name, value)) + .message("while parsing metadata") +} + +/// A single MCC payload item. This is ASCII hex encoded bytes plus some single-character +/// short-cuts for common byte sequences. +/// +/// It returns an `Either` of the single hex encoded byte or the short-cut byte sequence as a +/// static byte slice. +fn mcc_payload_item<'a, I: 'a>() -> impl Parser> +where + I: RangeStream, + I::Error: ParseError, +{ + choice!( + token(b'G').map(|_| Either::Right([0xfau8, 0x00, 0x00].as_ref())), + token(b'H').map(|_| Either::Right([0xfau8, 0x00, 0x00, 0xfa, 0x00, 0x00].as_ref())), + token(b'I').map(|_| Either::Right( + [0xfau8, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00].as_ref() + )), + token(b'J').map(|_| Either::Right( + [0xfau8, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00].as_ref() + )), + token(b'K').map(|_| Either::Right( + [ + 0xfau8, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, + 0x00, 0x00 + ] + .as_ref() + )), + token(b'L').map(|_| Either::Right( + [ + 0xfau8, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, + 0x00, 0x00, 0xfa, 0x00, 0x00 + ] + .as_ref() + )), + token(b'M').map(|_| Either::Right( + [ + 0xfau8, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, + 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00 + ] + .as_ref() + )), + token(b'N').map(|_| Either::Right( + [ + 0xfau8, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, + 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00 + ] + .as_ref() + )), + token(b'O').map(|_| Either::Right( + [ + 0xfau8, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, + 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00 + ] + .as_ref() + )), + token(b'P').map(|_| Either::Right([0xfbu8, 0x80, 0x80].as_ref())), + token(b'Q').map(|_| Either::Right([0xfcu8, 0x80, 0x80].as_ref())), + token(b'R').map(|_| Either::Right([0xfdu8, 0x80, 0x80].as_ref())), + token(b'S').map(|_| Either::Right([0x96u8, 0x69].as_ref())), + token(b'T').map(|_| Either::Right([0x61u8, 0x01].as_ref())), + token(b'U').map(|_| Either::Right([0xe1u8, 0x00, 0x00].as_ref())), + token(b'Z').map(|_| Either::Left(0x00u8)), + (hex_digit(), hex_digit()).map(|(u, l)| { + let hex_to_u8 = |v: u8| match v { + v if v >= b'0' && v <= b'9' => v - b'0', + v if v >= b'A' && v <= b'F' => 10 + v - b'A', + v if v >= b'a' && v <= b'f' => 10 + v - b'a', + _ => unreachable!(), + }; + let val = (hex_to_u8(u) << 4) | hex_to_u8(l); + Either::Left(val) + }) + ) + .message("while parsing MCC payload") +} + +/// A wrapper around `Vec` that implements `Extend` in a special way. It can be +/// extended from an iterator of `Either` while the default `Extend` implementation for +/// `Vec` only allows to extend over vector items. +struct VecExtend(Vec); + +impl Default for VecExtend { + fn default() -> Self { + VecExtend(Vec::with_capacity(256)) + } +} + +impl<'a> Extend> for VecExtend { + fn extend(&mut self, iter: T) + where + T: IntoIterator>, + { + for item in iter { + match item { + Either::Left(v) => self.0.push(v), + Either::Right(v) => self.0.extend_from_slice(v), + } + } + } +} + +/// Parser for the whole MCC payload with conversion to the underlying byte values. +fn mcc_payload<'a, I: 'a>() -> impl Parser> +where + I: RangeStream, + I::Error: ParseError, +{ + many1(mcc_payload_item()) + .map(|v: VecExtend| v.0) + .message("while parsing MCC payloads") +} + +/// Parser for a MCC caption line in the form `timecode\tpayload`. +fn caption<'a, I: 'a>() -> impl Parser> +where + I: RangeStream, + I::Error: ParseError, +{ + ( + timecode(), + optional(( + token(b'.'), + one_of([b'0', b'1'].iter().cloned()), + optional((token(b','), digits())), + )), + token(b'\t'), + mcc_payload(), + end_of_line(), + ) + .map(|(tc, _, _, value, _)| MccLine::Caption(tc, value)) + .message("while parsing caption") +} + +/// MCC parser the parses line-by-line and keeps track of the current state in the file. +impl MccParser { + pub fn new() -> Self { + Self { state: State::Init } + } + + pub fn reset(&mut self) { + self.state = State::Init; + } + + pub fn parse_line<'a>( + &mut self, + line: &'a [u8], + ) -> Result, combine::easy::Errors> + { + match self.state { + State::Init => header() + .message("while in Init state") + .easy_parse(line) + .map(|v| { + self.state = State::Header; + v.0 + }), + State::Header => empty_line() + .message("while in Header state") + .easy_parse(line) + .map(|v| { + self.state = State::Comments; + v.0 + }), + State::Comments => choice!(empty_line(), comment()) + .message("while in Comments state") + .easy_parse(line) + .map(|v| { + if v.0 == MccLine::Empty { + self.state = State::Metadata; + } + + v.0 + }), + State::Metadata => choice!(empty_line(), uuid(), time_code_rate(), metadata()) + .message("while in Metadata state") + .easy_parse(line) + .map(|v| { + if v.0 == MccLine::Empty { + self.state = State::Captions; + } + + v.0 + }), + State::Captions => caption() + .message("while in Captions state") + .easy_parse(line) + .map(|v| v.0), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use combine::error::UnexpectedParse; + + #[test] + fn test_timecode() { + let mut parser = timecode(); + assert_eq!( + parser.parse(b"11:12:13;14".as_ref()), + Ok(( + TimeCode { + hours: 11, + minutes: 12, + seconds: 13, + frames: 14, + drop_frame: true + }, + b"".as_ref() + )) + ); + + assert_eq!( + parser.parse(b"11:12:13:14".as_ref()), + Ok(( + TimeCode { + hours: 11, + minutes: 12, + seconds: 13, + frames: 14, + drop_frame: false + }, + b"".as_ref() + )) + ); + + assert_eq!( + parser.parse(b"11:12:13:14abcd".as_ref()), + Ok(( + TimeCode { + hours: 11, + minutes: 12, + seconds: 13, + frames: 14, + drop_frame: false + }, + b"abcd".as_ref() + )) + ); + + assert_eq!( + parser.parse(b"abcd11:12:13:14".as_ref()), + Err(UnexpectedParse::Unexpected) + ); + } + + #[test] + fn test_header() { + let mut parser = header(); + assert_eq!( + parser.parse(b"File Format=MacCaption_MCC V1.0".as_ref()), + Ok((MccLine::Header, b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"File Format=MacCaption_MCC V1.0\n".as_ref()), + Ok((MccLine::Header, b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"File Format=MacCaption_MCC V1.0\r\n".as_ref()), + Ok((MccLine::Header, b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"File Format=MacCaption_MCC V2.0\r\n".as_ref()), + Ok((MccLine::Header, b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"File Format=MacCaption_MCC V1.1".as_ref()), + Err(UnexpectedParse::Unexpected) + ); + } + + #[test] + fn test_empty_line() { + let mut parser = empty_line(); + assert_eq!( + parser.parse(b"".as_ref()), + Ok((MccLine::Empty, b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"\n".as_ref()), + Ok((MccLine::Empty, b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"\r\n".as_ref()), + Ok((MccLine::Empty, b"".as_ref())) + ); + + assert_eq!( + parser.parse(b" \r\n".as_ref()), + Err(UnexpectedParse::Unexpected) + ); + } + + #[test] + fn test_comment() { + let mut parser = comment(); + assert_eq!( + parser.parse(b"// blabla".as_ref()), + Ok((MccLine::Comment, b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"//\n".as_ref()), + Ok((MccLine::Comment, b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"//".as_ref()), + Ok((MccLine::Comment, b"".as_ref())) + ); + + assert_eq!( + parser.parse(b" //".as_ref()), + Err(UnexpectedParse::Unexpected) + ); + } + + #[test] + fn test_uuid() { + let mut parser = uuid(); + assert_eq!( + parser.parse(b"UUID=1234".as_ref()), + Ok((MccLine::UUID(b"1234".as_ref()), b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"UUID=1234\n".as_ref()), + Ok((MccLine::UUID(b"1234".as_ref()), b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"UUID=1234\r\n".as_ref()), + Ok((MccLine::UUID(b"1234".as_ref()), b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"UUID=".as_ref()), + Err(UnexpectedParse::Unexpected) + ); + + assert_eq!( + parser.parse(b"uUID=1234".as_ref()), + Err(UnexpectedParse::Unexpected) + ); + } + + #[test] + fn test_time_code_rate() { + let mut parser = time_code_rate(); + assert_eq!( + parser.parse(b"Time Code Rate=30".as_ref()), + Ok((MccLine::TimeCodeRate(30, false), b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"Time Code Rate=30DF".as_ref()), + Ok((MccLine::TimeCodeRate(30, true), b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"Time Code Rate=60".as_ref()), + Ok((MccLine::TimeCodeRate(60, false), b"".as_ref())) + ); + + assert_eq!( + parser.parse(b"Time Code Rate=17F".as_ref()), + Err(UnexpectedParse::Unexpected) + ); + + assert_eq!( + parser.parse(b"Time Code Rate=256".as_ref()), + Err(UnexpectedParse::Unexpected) + ); + } + + #[test] + fn test_metadata() { + let mut parser = metadata(); + assert_eq!( + parser.parse(b"Creation Date=Thursday, June 04, 2015".as_ref()), + Ok(( + MccLine::Metadata( + b"Creation Date".as_ref(), + b"Thursday, June 04, 2015".as_ref() + ), + b"".as_ref() + )) + ); + + assert_eq!( + parser.parse(b"Creation Date= ".as_ref()), + Ok(( + MccLine::Metadata(b"Creation Date".as_ref(), b" ".as_ref()), + b"".as_ref() + )) + ); + + assert_eq!( + parser.parse(b"Creation Date".as_ref()), + Err(UnexpectedParse::Eoi) + ); + + assert_eq!( + parser.parse(b"Creation Date\n".as_ref()), + Err(UnexpectedParse::Eoi) + ); + + assert_eq!( + parser.parse(b"Creation Date=".as_ref()), + Err(UnexpectedParse::Unexpected) + ); + + assert_eq!( + parser.parse(b"Creation Date=\n".as_ref()), + Err(UnexpectedParse::Unexpected) + ); + } + + #[test] + fn test_caption() { + let mut parser = caption(); + assert_eq!( + parser.parse(b"00:00:00:00\tT52S524F67ZZ72F4QROO7391UC13FFF74ZZAEB4".as_ref()), + Ok(( + MccLine::Caption( + TimeCode { + hours: 0, + minutes: 0, + seconds: 0, + frames: 0, + drop_frame: false + }, + vec![ + 0x61, 0x01, 0x52, 0x96, 0x69, 0x52, 0x4F, 0x67, 0x00, 0x00, 0x72, 0xF4, + 0xFC, 0x80, 0x80, 0xFD, 0x80, 0x80, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0x73, 0x91, 0xE1, 0x00, 0x00, 0xC1, 0x3F, 0xFF, 0x74, 0x00, 0x00, 0xAE, + 0xB4 + ] + ), + b"".as_ref() + )) + ); + + assert_eq!( + parser.parse(b"00:00:00:00.0\tT52S524F67ZZ72F4QROO7391UC13FFF74ZZAEB4".as_ref()), + Ok(( + MccLine::Caption( + TimeCode { + hours: 0, + minutes: 0, + seconds: 0, + frames: 0, + drop_frame: false + }, + vec![ + 0x61, 0x01, 0x52, 0x96, 0x69, 0x52, 0x4F, 0x67, 0x00, 0x00, 0x72, 0xF4, + 0xFC, 0x80, 0x80, 0xFD, 0x80, 0x80, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0x73, 0x91, 0xE1, 0x00, 0x00, 0xC1, 0x3F, 0xFF, 0x74, 0x00, 0x00, 0xAE, + 0xB4 + ] + ), + b"".as_ref() + )) + ); + + assert_eq!( + parser.parse(b"00:00:00:00.0,9\tT52S524F67ZZ72F4QROO7391UC13FFF74ZZAEB4".as_ref()), + Ok(( + MccLine::Caption( + TimeCode { + hours: 0, + minutes: 0, + seconds: 0, + frames: 0, + drop_frame: false + }, + vec![ + 0x61, 0x01, 0x52, 0x96, 0x69, 0x52, 0x4F, 0x67, 0x00, 0x00, 0x72, 0xF4, + 0xFC, 0x80, 0x80, 0xFD, 0x80, 0x80, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, 0xFA, 0x00, 0x00, + 0x73, 0x91, 0xE1, 0x00, 0x00, 0xC1, 0x3F, 0xFF, 0x74, 0x00, 0x00, 0xAE, + 0xB4 + ] + ), + b"".as_ref() + )) + ); + + assert_eq!( + parser.parse(b"Creation Date=\n".as_ref()), + Err(UnexpectedParse::Unexpected) + ); + } + + #[test] + fn test_parser() { + let mcc_file = include_bytes!("../tests/captions-test_708.mcc"); + let mut reader = crate::line_reader::LineReader::new(); + let mut parser = MccParser::new(); + let mut line_cnt = 0; + + reader.push(Vec::from(mcc_file.as_ref())); + + while let Some(line) = reader.get_line() { + let res = match parser.parse_line(line) { + Ok(res) => res, + Err(err) => panic!("Couldn't parse line {}: {:?}", line_cnt, err), + }; + + match line_cnt { + 0 => assert_eq!(res, MccLine::Header), + 1 | 37 | 43 => assert_eq!(res, MccLine::Empty), + x if x >= 2 && x <= 36 => assert_eq!(res, MccLine::Comment), + 38 => assert_eq!( + res, + MccLine::UUID(b"CA8BC94D-9931-4EEE-812F-2D68FA74F287".as_ref()) + ), + 39 => assert_eq!( + res, + MccLine::Metadata( + b"Creation Program".as_ref(), + b"Adobe Premiere Pro CC (Windows)".as_ref() + ) + ), + 40 => assert_eq!( + res, + MccLine::Metadata( + b"Creation Date".as_ref(), + b"Thursday, June 04, 2015".as_ref() + ) + ), + 41 => assert_eq!( + res, + MccLine::Metadata(b"Creation Time".as_ref(), b"13:48:25".as_ref()) + ), + 42 => assert_eq!(res, MccLine::TimeCodeRate(30, true)), + _ => match res { + MccLine::Caption(_, _) => (), + res => panic!("Expected caption at line {}, got {:?}", line_cnt, res), + }, + } + + line_cnt += 1; + } + } +} diff --git a/gst-plugin-closedcaption/tests/captions-test_708.mcc b/gst-plugin-closedcaption/tests/captions-test_708.mcc new file mode 100644 index 00000000..75d0aca8 --- /dev/null +++ b/gst-plugin-closedcaption/tests/captions-test_708.mcc @@ -0,0 +1,622 @@ +File Format=MacCaption_MCC V1.0 + +/////////////////////////////////////////////////////////////////////////////////// +// Computer Prompting and Captioning Company +// Ancillary Data Packet Transfer File +// +// Permission to generate this format is granted provided that +// 1. This ANC Transfer file format is used on an as-is basis and no warranty is given, and +// 2. This entire descriptive information text is included in a generated .mcc file. +// +// General file format: +// HH:MM:SS:FF(tab)[Hexadecimal ANC data in groups of 2 characters] +// Hexadecimal data starts with the Ancillary Data Packet DID (Data ID defined in S291M) +// and concludes with the Check Sum following the User Data Words. +// Each time code line must contain at most one complete ancillary data packet. +// To transfer additional ANC Data successive lines may contain identical time code. +// Time Code Rate=[24, 25, 30, 30DF, 50, 60] +// +// ANC data bytes may be represented by one ASCII character according to the following schema: +// G FAh 00h 00h +// H 2 x (FAh 00h 00h) +// I 3 x (FAh 00h 00h) +// J 4 x (FAh 00h 00h) +// K 5 x (FAh 00h 00h) +// L 6 x (FAh 00h 00h) +// M 7 x (FAh 00h 00h) +// N 8 x (FAh 00h 00h) +// O 9 x (FAh 00h 00h) +// P FBh 80h 80h +// Q FCh 80h 80h +// R FDh 80h 80h +// S 96h 69h +// T 61h 01h +// U E1h 00h 00h 00h +// Z 00h +// +/////////////////////////////////////////////////////////////////////////////////// + +UUID=CA8BC94D-9931-4EEE-812F-2D68FA74F287 +Creation Program=Adobe Premiere Pro CC (Windows) +Creation Date=Thursday, June 04, 2015 +Creation Time=13:48:25 +Time Code Rate=30DF + +00:00:00:00 T52S524F67ZZ72F4QRFF0222FE8CFFOM739181656E67817FFF74ZZ1CB4 +00:00:00:01 T52S524F67Z0172F4QRFF4527FE98ZFEZZFE0116FE11ZOJ739181656E67817FFF74Z0191B4 +00:00:00:02 T52S524F67Z0272F4QRFF8B34FE9004FE0354FE6865FE7365FE2061FE7265FE2037FE3038FE2063FE6103M739181656E67817FFF74Z0256B4 +00:00:00:03 T52S524F67Z0372F4QRFFC528FE7074FE696FFE6E73FE2003OJ739181656E67817FFF74Z030CB4 +00:00:00:04 T52S524F67Z0472F4QRFF082EFE9201FEZ28FE746FFE7020FE6C65FE6674FE2903OG739181656E67817FFF74Z0470B4 +00:00:00:05 T52S524F67Z0572F4QRFF4324FE88ZFE8BFFOL739181656E67817FFF74Z0544B4 +00:00:00:06 T52S524F67Z0672F4QRFF8222FE8CFEOM739181656E67817FFF74Z0691B4 +00:00:00:07 T52S524F67Z0772F4QRFFC527FE99ZFE1EZFE011BFE11ZOJ739181656E67817FFF74Z07E1B4 +00:00:00:08 T52S524F67Z0872F4QRFF0B34FE9004FE0392FEZ05FE5468FE6573FE6520FE6172FE6520FE3730FE3803M739181656E67817FFF74Z0817B4 +00:00:00:09 T52S524F67Z0972F4QRFF472BFE2063FE6170FE7469FE6F6EFE7320FE03ZOH739181656E67817FFF74Z098FB4 +00:00:00:10 T52S524F67Z0A72F4QRFF872CFE9201FE0E28FE6D69FE6464FE6C65FE2903OH739181656E67817FFF74Z0A8CB4 +00:00:00:11 T49S494F43Z0B72F4QROO74Z0BA9AB +00:00:00:12 T49S494F43Z0C72F4QROO74Z0CA7AB +00:00:00:13 T49S494F43Z0D72F4QROO74Z0DA5AB +00:00:00:14 T49S494F43Z0E72F4QROO74Z0EA3AB +00:00:00:15 T49S494F43Z0F72F4QROO74Z0FA1AB +00:00:00:16 T49S494F43Z1072F4QROO74Z109FAB +00:00:00:17 T49S494F43Z1172F4QROO74Z119DAB +00:00:00:18 T49S494F43Z1272F4QROO74Z129BAB +00:00:00:19 T49S494F43Z1372F4QROO74Z1399AB +00:00:00:20 T49S494F43Z1472F4QROO74Z1497AB +00:00:00:21 T49S494F43Z1572F4QROO74Z1595AB +00:00:00:22 T49S494F43Z1672F4QROO74Z1693AB +00:00:00:23 T49S494F43Z1772F4QROO74Z1791AB +00:00:00:24 T49S494F43Z1872F4QROO74Z188FAB +00:00:00:25 T49S494F43Z1972F4QROO74Z198DAB +00:00:00:26 T49S494F43Z1A72F4QROO74Z1A8BAB +00:00:00:27 T49S494F43Z1B72F4QROO74Z1B89AB +00:00:00:28 T49S494F43Z1C72F4QROO74Z1C87AB +00:00:00:29 T49S494F43Z1D72F4QROO74Z1D85AB +00:00:01:00 T49S494F43Z1E72F4QROO74Z1E83AB +00:00:01:01 T49S494F43Z1F72F4QROO74Z1F81AB +00:00:01:02 T49S494F43Z2072F4QROO74Z207FAB +00:00:01:03 T49S494F43Z2172F4QROO74Z217DAB +00:00:01:04 T49S494F43Z2272F4QROO74Z227BAB +00:00:01:05 T49S494F43Z2372F4QROO74Z2379AB +00:00:01:06 T49S494F43Z2472F4QROO74Z2477AB +00:00:01:07 T49S494F43Z2572F4QROO74Z2575AB +00:00:01:08 T49S494F43Z2672F4QROO74Z2673AB +00:00:01:09 T49S494F43Z2772F4QROO74Z2771AB +00:00:01:10 T49S494F43Z2872F4QROO74Z286FAB +00:00:01:11 T49S494F43Z2972F4QROO74Z296DAB +00:00:01:12 T49S494F43Z2A72F4QROO74Z2A6BAB +00:00:01:13 T49S494F43Z2B72F4QROO74Z2B69AB +00:00:01:14 T49S494F43Z2C72F4QROO74Z2C67AB +00:00:01:15 T49S494F43Z2D72F4QROO74Z2D65AB +00:00:01:16 T49S494F43Z2E72F4QROO74Z2E63AB +00:00:01:17 T49S494F43Z2F72F4QROO74Z2F61AB +00:00:01:18 T49S494F43Z3072F4QROO74Z305FAB +00:00:01:19 T49S494F43Z3172F4QROO74Z315DAB +00:00:01:20 T49S494F43Z3272F4QROO74Z325BAB +00:00:01:21 T49S494F43Z3372F4QROO74Z3359AB +00:00:01:22 T49S494F43Z3472F4QROO74Z3457AB +00:00:01:23 T49S494F43Z3572F4QROO74Z3555AB +00:00:01:24 T49S494F43Z3672F4QROO74Z3653AB +00:00:01:25 T49S494F43Z3772F4QROO74Z3751AB +00:00:01:26 T49S494F43Z3872F4QROO74Z384FAB +00:00:01:27 T49S494F43Z3972F4QROO74Z394DAB +00:00:01:28 T49S494F43Z3A72F4QROO74Z3A4BAB +00:00:01:29 T49S494F43Z3B72F4QROO74Z3B49AB +00:00:02:00 T49S494F43Z3C72F4QROO74Z3C47AB +00:00:02:01 T49S494F43Z3D72F4QROO74Z3D45AB +00:00:02:02 T49S494F43Z3E72F4QROO74Z3E43AB +00:00:02:03 T49S494F43Z3F72F4QROO74Z3F41AB +00:00:02:04 T49S494F43Z4072F4QROO74Z403FAB +00:00:02:05 T49S494F43Z4172F4QROO74Z413DAB +00:00:02:06 T49S494F43Z4272F4QROO74Z423BAB +00:00:02:07 T49S494F43Z4372F4QROO74Z4339AB +00:00:02:08 T49S494F43Z4472F4QROO74Z4437AB +00:00:02:09 T49S494F43Z4572F4QROO74Z4535AB +00:00:02:10 T49S494F43Z4672F4QROO74Z4633AB +00:00:02:11 T49S494F43Z4772F4QROO74Z4731AB +00:00:02:12 T49S494F43Z4872F4QROO74Z482FAB +00:00:02:13 T49S494F43Z4972F4QROO74Z492DAB +00:00:02:14 T49S494F43Z4A72F4QROO74Z4A2BAB +00:00:02:15 T49S494F43Z4B72F4QROO74Z4B29AB +00:00:02:16 T49S494F43Z4C72F4QROO74Z4C27AB +00:00:02:17 T49S494F43Z4D72F4QROO74Z4D25AB +00:00:02:18 T49S494F43Z4E72F4QROO74Z4E23AB +00:00:02:19 T49S494F43Z4F72F4QROO74Z4F21AB +00:00:02:20 T49S494F43Z5072F4QROO74Z501FAB +00:00:02:21 T49S494F43Z5172F4QROO74Z511DAB +00:00:02:22 T49S494F43Z5272F4QROO74Z521BAB +00:00:02:23 T49S494F43Z5372F4QROO74Z5319AB +00:00:02:24 T49S494F43Z5472F4QROO74Z5417AB +00:00:02:25 T49S494F43Z5572F4QROO74Z5515AB +00:00:02:26 T49S494F43Z5672F4QROO74Z5613AB +00:00:02:27 T49S494F43Z5772F4QROO74Z5711AB +00:00:02:28 T49S494F43Z5872F4QROO74Z580FAB +00:00:02:29 T49S494F43Z5972F4QROO74Z590DAB +00:00:03:00 T49S494F43Z5A72F4QROO74Z5A0BAB +00:00:03:01 T49S494F43Z5B72F4QROO74Z5B09AB +00:00:03:02 T49S494F43Z5C72F4QROO74Z5C07AB +00:00:03:03 T49S494F43Z5D72F4QROO74Z5D05AB +00:00:03:04 T49S494F43Z5E72F4QROO74Z5E03AB +00:00:03:05 T49S494F43Z5F72F4QROO74Z5F01AB +00:00:03:06 T49S494F43Z6072F4QROO74Z60FFAB +00:00:03:07 T49S494F43Z6172F4QROO74Z61FDAB +00:00:03:08 T49S494F43Z6272F4QROO74Z62FBAB +00:00:03:09 T49S494F43Z6372F4QROO74Z63F9AB +00:00:03:10 T49S494F43Z6472F4QROO74Z64F7AB +00:00:03:11 T49S494F43Z6572F4QROO74Z65F5AB +00:00:03:12 T49S494F43Z6672F4QROO74Z66F3AB +00:00:03:13 T49S494F43Z6772F4QROO74Z67F1AB +00:00:03:14 T49S494F43Z6872F4QROO74Z68EFAB +00:00:03:15 T49S494F43Z6972F4QROO74Z69EDAB +00:00:03:16 T49S494F43Z6A72F4QROO74Z6AEBAB +00:00:03:17 T49S494F43Z6B72F4QROO74Z6BE9AB +00:00:03:18 T49S494F43Z6C72F4QROO74Z6CE7AB +00:00:03:19 T49S494F43Z6D72F4QROO74Z6DE5AB +00:00:03:20 T49S494F43Z6E72F4QROO74Z6EE3AB +00:00:03:21 T49S494F43Z6F72F4QROO74Z6FE1AB +00:00:03:22 T49S494F43Z7072F4QROO74Z70DFAB +00:00:03:23 T49S494F43Z7172F4QROO74Z71DDAB +00:00:03:24 T49S494F43Z7272F4QROO74Z72DBAB +00:00:03:25 T49S494F43Z7372F4QROO74Z73D9AB +00:00:03:26 T49S494F43Z7472F4QROO74Z74D7AB +00:00:03:27 T49S494F43Z7572F4QROO74Z75D5AB +00:00:03:28 T49S494F43Z7672F4QROO74Z76D3AB +00:00:03:29 T49S494F43Z7772F4QROO74Z77D1AB +00:00:04:00 T49S494F43Z7872F4QROO74Z78CFAB +00:00:04:01 T49S494F43Z7972F4QROO74Z79CDAB +00:00:04:02 T49S494F43Z7A72F4QROO74Z7ACBAB +00:00:04:03 T49S494F43Z7B72F4QROO74Z7BC9AB +00:00:04:04 T49S494F43Z7C72F4QROO74Z7CC7AB +00:00:04:05 T49S494F43Z7D72F4QROO74Z7DC5AB +00:00:04:06 T49S494F43Z7E72F4QROO74Z7EC3AB +00:00:04:07 T49S494F43Z7F72F4QROO74Z7FC1AB +00:00:04:08 T49S494F43Z8072F4QROO74Z80BFAB +00:00:04:09 T49S494F43Z8172F4QROO74Z81BDAB +00:00:04:10 T49S494F43Z8272F4QROO74Z82BBAB +00:00:04:11 T49S494F43Z8372F4QROO74Z83B9AB +00:00:04:12 T49S494F43Z8472F4QROO74Z84B7AB +00:00:04:13 T49S494F43Z8572F4QROO74Z85B5AB +00:00:04:14 T49S494F43Z8672F4QROO74Z86B3AB +00:00:04:15 T49S494F43Z8772F4QROO74Z87B1AB +00:00:04:16 T49S494F43Z8872F4QROO74Z88AFAB +00:00:04:17 T49S494F43Z8972F4QROO74Z89ADAB +00:00:04:18 T49S494F43Z8A72F4QROO74Z8AABAB +00:00:04:19 T49S494F43Z8B72F4QROO74Z8BA9AB +00:00:04:20 T49S494F43Z8C72F4QROO74Z8CA7AB +00:00:04:21 T49S494F43Z8D72F4QROO74Z8DA5AB +00:00:04:22 T49S494F43Z8E72F4QROO74Z8EA3AB +00:00:04:23 T49S494F43Z8F72F4QROO74Z8FA1AB +00:00:04:24 T49S494F43Z9072F4QROO74Z909FAB +00:00:04:25 T49S494F43Z9172F4QROO74Z919DAB +00:00:04:26 T49S494F43Z9272F4QROO74Z929BAB +00:00:04:27 T52S524F67Z9372F4QRFFC222FE8C01OM739181656E67817FFF74Z9334B4 +00:00:04:28 T49S494F43Z9472F4QROO74Z9497AB +00:00:04:29 T49S494F43Z9572F4QROO74Z9595AB +00:00:05:00 T49S494F43Z9672F4QROO74Z9693AB +00:00:05:01 T49S494F43Z9772F4QROO74Z9791AB +00:00:05:02 T49S494F43Z9872F4QROO74Z988FAB +00:00:05:03 T49S494F43Z9972F4QROO74Z998DAB +00:00:05:04 T49S494F43Z9A72F4QROO74Z9A8BAB +00:00:05:05 T49S494F43Z9B72F4QROO74Z9B89AB +00:00:05:06 T49S494F43Z9C72F4QROO74Z9C87AB +00:00:05:07 T52S524F67Z9D72F4QRFF4324FE88ZFE8BFFOL739181656E67817FFF74Z9D14B4 +00:00:05:08 T52S524F67Z9E72F4QRFF8222FE8CFDOM739181656E67817FFF74Z9E62B4 +00:00:05:09 T52S524F67Z9F72F4QRFFC527FE98ZFE41ZFE0116FE11ZOJ739181656E67817FFF74Z9F94B4 +00:00:05:10 T52S524F67ZA072F4QRFF0B34FE9004FE0354FE6865FE7365FE2061FE7265FE2037FE3038FE2063FE6103M739181656E67817FFF74ZA09AB4 +00:00:05:11 T52S524F67ZA172F4QRFF4528FE7074FE696FFE6E73FE2003OJ739181656E67817FFF74ZA150B4 +00:00:05:12 T52S524F67ZA272F4QRFF8A31FE9201FEZ28FE626FFE7474FE6F6DFE206CFE6566FE7429FE03ZN739181656E67817FFF74ZA265B4 +00:00:05:13 T49S494F43ZA372F4QROO74ZA379AB +00:00:05:14 T49S494F43ZA472F4QROO74ZA477AB +00:00:05:15 T49S494F43ZA572F4QROO74ZA575AB +00:00:05:16 T49S494F43ZA672F4QROO74ZA673AB +00:00:05:17 T49S494F43ZA772F4QROO74ZA771AB +00:00:05:18 T49S494F43ZA872F4QROO74ZA86FAB +00:00:05:19 T49S494F43ZA972F4QROO74ZA96DAB +00:00:05:20 T49S494F43ZAA72F4QROO74ZAA6BAB +00:00:05:21 T49S494F43ZAB72F4QROO74ZAB69AB +00:00:05:22 T49S494F43ZAC72F4QROO74ZAC67AB +00:00:05:23 T49S494F43ZAD72F4QROO74ZAD65AB +00:00:05:24 T49S494F43ZAE72F4QROO74ZAE63AB +00:00:05:25 T49S494F43ZAF72F4QROO74ZAF61AB +00:00:05:26 T49S494F43ZB072F4QROO74ZB05FAB +00:00:05:27 T49S494F43ZB172F4QROO74ZB15DAB +00:00:05:28 T49S494F43ZB272F4QROO74ZB25BAB +00:00:05:29 T49S494F43ZB372F4QROO74ZB359AB +00:00:06:00 T49S494F43ZB472F4QROO74ZB457AB +00:00:06:01 T49S494F43ZB572F4QROO74ZB555AB +00:00:06:02 T49S494F43ZB672F4QROO74ZB653AB +00:00:06:03 T49S494F43ZB772F4QROO74ZB751AB +00:00:06:04 T49S494F43ZB872F4QROO74ZB84FAB +00:00:06:05 T49S494F43ZB972F4QROO74ZB94DAB +00:00:06:06 T49S494F43ZBA72F4QROO74ZBA4BAB +00:00:06:07 T49S494F43ZBB72F4QROO74ZBB49AB +00:00:06:08 T49S494F43ZBC72F4QROO74ZBC47AB +00:00:06:09 T49S494F43ZBD72F4QROO74ZBD45AB +00:00:06:10 T49S494F43ZBE72F4QROO74ZBE43AB +00:00:06:11 T49S494F43ZBF72F4QROO74ZBF41AB +00:00:06:12 T49S494F43ZC072F4QROO74ZC03FAB +00:00:06:13 T49S494F43ZC172F4QROO74ZC13DAB +00:00:06:14 T49S494F43ZC272F4QROO74ZC23BAB +00:00:06:15 T49S494F43ZC372F4QROO74ZC339AB +00:00:06:16 T49S494F43ZC472F4QROO74ZC437AB +00:00:06:17 T49S494F43ZC572F4QROO74ZC535AB +00:00:06:18 T49S494F43ZC672F4QROO74ZC633AB +00:00:06:19 T49S494F43ZC772F4QROO74ZC731AB +00:00:06:20 T49S494F43ZC872F4QROO74ZC82FAB +00:00:06:21 T49S494F43ZC972F4QROO74ZC92DAB +00:00:06:22 T49S494F43ZCA72F4QROO74ZCA2BAB +00:00:06:23 T49S494F43ZCB72F4QROO74ZCB29AB +00:00:06:24 T49S494F43ZCC72F4QROO74ZCC27AB +00:00:06:25 T49S494F43ZCD72F4QROO74ZCD25AB +00:00:06:26 T49S494F43ZCE72F4QROO74ZCE23AB +00:00:06:27 T49S494F43ZCF72F4QROO74ZCF21AB +00:00:06:28 T49S494F43ZD072F4QROO74ZD01FAB +00:00:06:29 T49S494F43ZD172F4QROO74ZD11DAB +00:00:07:00 T49S494F43ZD272F4QROO74ZD21BAB +00:00:07:01 T49S494F43ZD372F4QROO74ZD319AB +00:00:07:02 T49S494F43ZD472F4QROO74ZD417AB +00:00:07:03 T49S494F43ZD572F4QROO74ZD515AB +00:00:07:04 T49S494F43ZD672F4QROO74ZD613AB +00:00:07:05 T49S494F43ZD772F4QROO74ZD711AB +00:00:07:06 T49S494F43ZD872F4QROO74ZD80FAB +00:00:07:07 T49S494F43ZD972F4QROO74ZD90DAB +00:00:07:08 T49S494F43ZDA72F4QROO74ZDA0BAB +00:00:07:09 T49S494F43ZDB72F4QROO74ZDB09AB +00:00:07:10 T49S494F43ZDC72F4QROO74ZDC07AB +00:00:07:11 T49S494F43ZDD72F4QROO74ZDD05AB +00:00:07:12 T49S494F43ZDE72F4QROO74ZDE03AB +00:00:07:13 T49S494F43ZDF72F4QROO74ZDF01AB +00:00:07:14 T49S494F43ZE072F4QROO74ZE0FFAB +00:00:07:15 T49S494F43ZE172F4QROO74ZE1FDAB +00:00:07:16 T49S494F43ZE272F4QROO74ZE2FBAB +00:00:07:17 T49S494F43ZE372F4QROO74ZE3F9AB +00:00:07:18 T49S494F43ZE472F4QROO74ZE4F7AB +00:00:07:19 T49S494F43ZE572F4QROO74ZE5F5AB +00:00:07:20 T49S494F43ZE672F4QROO74ZE6F3AB +00:00:07:21 T49S494F43ZE772F4QROO74ZE7F1AB +00:00:07:22 T49S494F43ZE872F4QROO74ZE8EFAB +00:00:07:23 T49S494F43ZE972F4QROO74ZE9EDAB +00:00:07:24 T49S494F43ZEA72F4QROO74ZEAEBAB +00:00:07:25 T49S494F43ZEB72F4QROO74ZEBE9AB +00:00:07:26 T49S494F43ZEC72F4QROO74ZECE7AB +00:00:07:27 T49S494F43ZED72F4QROO74ZEDE5AB +00:00:07:28 T49S494F43ZEE72F4QROO74ZEEE3AB +00:00:07:29 T49S494F43ZEF72F4QROO74ZEFE1AB +00:00:08:00 T49S494F43ZF072F4QROO74ZF0DFAB +00:00:08:01 T49S494F43ZF172F4QROO74ZF1DDAB +00:00:08:02 T49S494F43ZF272F4QROO74ZF2DBAB +00:00:08:03 T49S494F43ZF372F4QROO74ZF3D9AB +00:00:08:04 T49S494F43ZF472F4QROO74ZF4D7AB +00:00:08:05 T49S494F43ZF572F4QROO74ZF5D5AB +00:00:08:06 T49S494F43ZF672F4QROO74ZF6D3AB +00:00:08:07 T49S494F43ZF772F4QROO74ZF7D1AB +00:00:08:08 T49S494F43ZF872F4QROO74ZF8CFAB +00:00:08:09 T49S494F43ZF972F4QROO74ZF9CDAB +00:00:08:10 T49S494F43ZFA72F4QROO74ZFACBAB +00:00:08:11 T49S494F43ZFB72F4QROO74ZFBC9AB +00:00:08:12 T49S494F43ZFC72F4QROO74ZFCC7AB +00:00:08:13 T49S494F43ZFD72F4QROO74ZFDC5AB +00:00:08:14 T49S494F43ZFE72F4QROO74ZFEC3AB +00:00:08:15 T49S494F43ZFF72F4QROO74ZFFC1AB +00:00:08:16 T49S494F4301Z72F4QROO7401ZBDAB +00:00:08:17 T49S494F43010172F4QROO740101BBAB +00:00:08:18 T49S494F43010272F4QROO740102B9AB +00:00:08:19 T49S494F43010372F4QROO740103B7AB +00:00:08:20 T49S494F43010472F4QROO740104B5AB +00:00:08:21 T49S494F43010572F4QROO740105B3AB +00:00:08:22 T49S494F43010672F4QROO740106B1AB +00:00:08:23 T49S494F43010772F4QROO740107AFAB +00:00:08:24 T49S494F43010872F4QROO740108ADAB +00:00:08:25 T49S494F43010972F4QROO740109ABAB +00:00:08:26 T49S494F43010A72F4QROO74010AA9AB +00:00:08:27 T49S494F43010B72F4QROO74010BA7AB +00:00:08:28 T49S494F43010C72F4QROO74010CA5AB +00:00:08:29 T49S494F43010D72F4QROO74010DA3AB +00:00:09:00 T49S494F43010E72F4QROO74010EA1AB +00:00:09:01 T49S494F43010F72F4QROO74010F9FAB +00:00:09:02 T49S494F43011072F4QROO7401109DAB +00:00:09:03 T49S494F43011172F4QROO7401119BAB +00:00:09:04 T49S494F43011272F4QROO74011299AB +00:00:09:05 T49S494F43011372F4QROO74011397AB +00:00:09:06 T49S494F43011472F4QROO74011495AB +00:00:09:07 T49S494F43011572F4QROO74011593AB +00:00:09:08 T49S494F43011672F4QROO74011691AB +00:00:09:09 T49S494F43011772F4QROO7401178FAB +00:00:09:10 T49S494F43011872F4QROO7401188DAB +00:00:09:11 T49S494F43011972F4QROO7401198BAB +00:00:09:12 T49S494F43011A72F4QROO74011A89AB +00:00:09:13 T49S494F43011B72F4QROO74011B87AB +00:00:09:14 T49S494F43011C72F4QROO74011C85AB +00:00:09:15 T49S494F43011D72F4QROO74011D83AB +00:00:09:16 T49S494F43011E72F4QROO74011E81AB +00:00:09:17 T49S494F43011F72F4QROO74011F7FAB +00:00:09:18 T49S494F43012072F4QROO7401207DAB +00:00:09:19 T49S494F43012172F4QROO7401217BAB +00:00:09:20 T49S494F43012272F4QROO74012279AB +00:00:09:21 T49S494F43012372F4QROO74012377AB +00:00:09:22 T49S494F43012472F4QROO74012475AB +00:00:09:23 T49S494F43012572F4QROO74012573AB +00:00:09:24 T49S494F43012672F4QROO74012671AB +00:00:09:25 T49S494F43012772F4QROO7401276FAB +00:00:09:26 T49S494F43012872F4QROO7401286DAB +00:00:09:27 T49S494F43012972F4QROO7401296BAB +00:00:09:28 T49S494F43012A72F4QROO74012A69AB +00:00:09:29 T49S494F43012B72F4QROO74012B67AB +00:00:10:00 T49S494F43012C72F4QROO74012C65AB +00:00:10:01 T49S494F43012D72F4QROO74012D63AB +00:00:10:02 T49S494F43012E72F4QROO74012E61AB +00:00:10:03 T49S494F43012F72F4QROO74012F5FAB +00:00:10:04 T49S494F43013072F4QROO7401305DAB +00:00:10:05 T49S494F43013172F4QROO7401315BAB +00:00:10:06 T49S494F43013272F4QROO74013259AB +00:00:10:07 T49S494F43013372F4QROO74013357AB +00:00:10:08 T49S494F43013472F4QROO74013455AB +00:00:10:09 T49S494F43013572F4QROO74013553AB +00:00:10:10 T49S494F43013672F4QROO74013651AB +00:00:10:11 T49S494F43013772F4QROO7401374FAB +00:00:10:12 T49S494F43013872F4QROO7401384DAB +00:00:10:13 T49S494F43013972F4QROO7401394BAB +00:00:10:14 T49S494F43013A72F4QROO74013A49AB +00:00:10:15 T49S494F43013B72F4QROO74013B47AB +00:00:10:16 T49S494F43013C72F4QROO74013C45AB +00:00:10:17 T49S494F43013D72F4QROO74013D43AB +00:00:10:18 T49S494F43013E72F4QROO74013E41AB +00:00:10:19 T49S494F43013F72F4QROO74013F3FAB +00:00:10:20 T49S494F43014072F4QROO7401403DAB +00:00:10:21 T49S494F43014172F4QROO7401413BAB +00:00:10:22 T49S494F43014272F4QROO74014239AB +00:00:10:23 T49S494F43014372F4QROO74014337AB +00:00:10:24 T49S494F43014472F4QROO74014435AB +00:00:10:25 T49S494F43014572F4QROO74014533AB +00:00:10:26 T49S494F43014672F4QROO74014631AB +00:00:10:27 T49S494F43014772F4QROO7401472FAB +00:00:10:28 T49S494F43014872F4QROO7401482DAB +00:00:10:29 T49S494F43014972F4QROO7401492BAB +00:00:11:00 T49S494F43014A72F4QROO74014A29AB +00:00:11:01 T49S494F43014B72F4QROO74014B27AB +00:00:11:02 T49S494F43014C72F4QROO74014C25AB +00:00:11:03 T49S494F43014D72F4QROO74014D23AB +00:00:11:04 T49S494F43014E72F4QROO74014E21AB +00:00:11:05 T49S494F43014F72F4QROO74014F1FAB +00:00:11:06 T49S494F43015072F4QROO7401501DAB +00:00:11:07 T49S494F43015172F4QROO7401511BAB +00:00:11:08 T49S494F43015272F4QROO74015219AB +00:00:11:09 T49S494F43015372F4QROO74015317AB +00:00:11:10 T49S494F43015472F4QROO74015415AB +00:00:11:11 T49S494F43015572F4QROO74015513AB +00:00:11:12 T49S494F43015672F4QROO74015611AB +00:00:11:13 T49S494F43015772F4QROO7401570FAB +00:00:11:14 T49S494F43015872F4QROO7401580DAB +00:00:11:15 T49S494F43015972F4QROO7401590BAB +00:00:11:16 T49S494F43015A72F4QROO74015A09AB +00:00:11:17 T49S494F43015B72F4QROO74015B07AB +00:00:11:18 T49S494F43015C72F4QROO74015C05AB +00:00:11:19 T49S494F43015D72F4QROO74015D03AB +00:00:11:20 T49S494F43015E72F4QROO74015E01AB +00:00:11:21 T49S494F43015F72F4QROO74015FFFAB +00:00:11:22 T49S494F43016072F4QROO740160FDAB +00:00:11:23 T49S494F43016172F4QROO740161FBAB +00:00:11:24 T49S494F43016272F4QROO740162F9AB +00:00:11:25 T49S494F43016372F4QROO740163F7AB +00:00:11:26 T49S494F43016472F4QROO740164F5AB +00:00:11:27 T52S524F67016572F4QRFF4222FE8C02OM739181656E67817FFF7401650DB4 +00:00:11:28 T49S494F43016672F4QROO740166F1AB +00:00:11:29 T49S494F43016772F4QROO740167EFAB +00:00:12:00 T49S494F43016872F4QROO740168EDAB +00:00:12:01 T49S494F43016972F4QROO740169EBAB +00:00:12:02 T49S494F43016A72F4QROO74016AE9AB +00:00:12:03 T49S494F43016B72F4QROO74016BE7AB +00:00:12:04 T49S494F43016C72F4QROO74016CE5AB +00:00:12:05 T49S494F43016D72F4QROO74016DE3AB +00:00:12:06 T49S494F43016E72F4QROO74016EE1AB +00:00:12:07 T52S524F67016F72F4QRFFC324FE88ZFE8BFFOL739181656E67817FFF74016FEEB4 +00:00:12:08 T49S494F43017072F4QROO740170DDAB +00:00:12:09 T49S494F43017172F4QROO740171DBAB +00:00:12:10 T49S494F43017272F4QROO740172D9AB +00:00:12:11 T49S494F43017372F4QROO740173D7AB +00:00:12:12 T49S494F43017472F4QROO740174D5AB +00:00:12:13 T49S494F43017572F4QROO740175D3AB +00:00:12:14 T49S494F43017672F4QROO740176D1AB +00:00:12:15 T49S494F43017772F4QROO740177CFAB +00:00:12:16 T49S494F43017872F4QROO740178CDAB +00:00:12:17 T49S494F43017972F4QROO740179CBAB +00:00:12:18 T49S494F43017A72F4QROO74017AC9AB +00:00:12:19 T49S494F43017B72F4QROO74017BC7AB +00:00:12:20 T49S494F43017C72F4QROO74017CC5AB +00:00:12:21 T49S494F43017D72F4QROO74017DC3AB +00:00:12:22 T49S494F43017E72F4QROO74017EC1AB +00:00:12:23 T49S494F43017F72F4QROO74017FBFAB +00:00:12:24 T49S494F43018072F4QROO740180BDAB +00:00:12:25 T49S494F43018172F4QROO740181BBAB +00:00:12:26 T49S494F43018272F4QROO740182B9AB +00:00:12:27 T49S494F43018372F4QROO740183B7AB +00:00:12:28 T49S494F43018472F4QROO740184B5AB +00:00:12:29 T49S494F43018572F4QROO740185B3AB +00:00:13:00 T49S494F43018672F4QROO740186B1AB +00:00:13:01 T49S494F43018772F4QROO740187AFAB +00:00:13:02 T49S494F43018872F4QROO740188ADAB +00:00:13:03 T49S494F43018972F4QROO740189ABAB +00:00:13:04 T49S494F43018A72F4QROO74018AA9AB +00:00:13:05 T49S494F43018B72F4QROO74018BA7AB +00:00:13:06 T49S494F43018C72F4QROO74018CA5AB +00:00:13:07 T49S494F43018D72F4QROO74018DA3AB +00:00:13:08 T49S494F43018E72F4QROO74018EA1AB +00:00:13:09 T49S494F43018F72F4QROO74018F9FAB +00:00:13:10 T49S494F43019072F4QROO7401909DAB +00:00:13:11 T49S494F43019172F4QROO7401919BAB +00:00:13:12 T49S494F43019272F4QROO74019299AB +00:00:13:13 T49S494F43019372F4QROO74019397AB +00:00:13:14 T49S494F43019472F4QROO74019495AB +00:00:13:15 T49S494F43019572F4QROO74019593AB +00:00:13:16 T49S494F43019672F4QROO74019691AB +00:00:13:17 T49S494F43019772F4QROO7401978FAB +00:00:13:18 T49S494F43019872F4QROO7401988DAB +00:00:13:19 T49S494F43019972F4QROO7401998BAB +00:00:13:20 T49S494F43019A72F4QROO74019A89AB +00:00:13:21 T49S494F43019B72F4QROO74019B87AB +00:00:13:22 T49S494F43019C72F4QROO74019C85AB +00:00:13:23 T49S494F43019D72F4QROO74019D83AB +00:00:13:24 T49S494F43019E72F4QROO74019E81AB +00:00:13:25 T49S494F43019F72F4QROO74019F7FAB +00:00:13:26 T49S494F4301A072F4QROO7401A07DAB +00:00:13:27 T49S494F4301A172F4QROO7401A17BAB +00:00:13:28 T49S494F4301A272F4QROO7401A279AB +00:00:13:29 T49S494F4301A372F4QROO7401A377AB +00:00:14:00 T49S494F4301A472F4QROO7401A475AB +00:00:14:01 T49S494F4301A572F4QROO7401A573AB +00:00:14:02 T49S494F4301A672F4QROO7401A671AB +00:00:14:03 T49S494F4301A772F4QROO7401A76FAB +00:00:14:04 T49S494F4301A872F4QROO7401A86DAB +00:00:14:05 T49S494F4301A972F4QROO7401A96BAB +00:00:14:06 T49S494F4301AA72F4QROO7401AA69AB +00:00:14:07 T49S494F4301AB72F4QROO7401AB67AB +00:00:14:08 T49S494F4301AC72F4QROO7401AC65AB +00:00:14:09 T49S494F4301AD72F4QROO7401AD63AB +00:00:14:10 T49S494F4301AE72F4QROO7401AE61AB +00:00:14:11 T49S494F4301AF72F4QROO7401AF5FAB +00:00:14:12 T49S494F4301B072F4QROO7401B05DAB +00:00:14:13 T49S494F4301B172F4QROO7401B15BAB +00:00:14:14 T49S494F4301B272F4QROO7401B259AB +00:00:14:15 T49S494F4301B372F4QROO7401B357AB +00:00:14:16 T49S494F4301B472F4QROO7401B455AB +00:00:14:17 T49S494F4301B572F4QROO7401B553AB +00:00:14:18 T49S494F4301B672F4QROO7401B651AB +00:00:14:19 T49S494F4301B772F4QROO7401B74FAB +00:00:14:20 T49S494F4301B872F4QROO7401B84DAB +00:00:14:21 T49S494F4301B972F4QROO7401B94BAB +00:00:14:22 T49S494F4301BA72F4QROO7401BA49AB +00:00:14:23 T49S494F4301BB72F4QROO7401BB47AB +00:00:14:24 T49S494F4301BC72F4QROO7401BC45AB +00:00:14:25 T49S494F4301BD72F4QROO7401BD43AB +00:00:14:26 T49S494F4301BE72F4QROO7401BE41AB +00:00:14:27 T49S494F4301BF72F4QROO7401BF3FAB +00:00:14:28 T49S494F4301C072F4QROO7401C03DAB +00:00:14:29 T49S494F4301C172F4QROO7401C13BAB +00:00:15:00 T49S494F4301C272F4QROO7401C239AB +00:00:15:01 T49S494F4301C372F4QROO7401C337AB +00:00:15:02 T49S494F4301C472F4QROO7401C435AB +00:00:15:03 T49S494F4301C572F4QROO7401C533AB +00:00:15:04 T49S494F4301C672F4QROO7401C631AB +00:00:15:05 T49S494F4301C772F4QROO7401C72FAB +00:00:15:06 T49S494F4301C872F4QROO7401C82DAB +00:00:15:07 T49S494F4301C972F4QROO7401C92BAB +00:00:15:08 T49S494F4301CA72F4QROO7401CA29AB +00:00:15:09 T49S494F4301CB72F4QROO7401CB27AB +00:00:15:10 T49S494F4301CC72F4QROO7401CC25AB +00:00:15:11 T49S494F4301CD72F4QROO7401CD23AB +00:00:15:12 T49S494F4301CE72F4QROO7401CE21AB +00:00:15:13 T49S494F4301CF72F4QROO7401CF1FAB +00:00:15:14 T49S494F4301D072F4QROO7401D01DAB +00:00:15:15 T49S494F4301D172F4QROO7401D11BAB +00:00:15:16 T49S494F4301D272F4QROO7401D219AB +00:00:15:17 T49S494F4301D372F4QROO7401D317AB +00:00:15:18 T49S494F4301D472F4QROO7401D415AB +00:00:15:19 T49S494F4301D572F4QROO7401D513AB +00:00:15:20 T49S494F4301D672F4QROO7401D611AB +00:00:15:21 T49S494F4301D772F4QROO7401D70FAB +00:00:15:22 T49S494F4301D872F4QROO7401D80DAB +00:00:15:23 T49S494F4301D972F4QROO7401D90BAB +00:00:15:24 T49S494F4301DA72F4QROO7401DA09AB +00:00:15:25 T49S494F4301DB72F4QROO7401DB07AB +00:00:15:26 T49S494F4301DC72F4QROO7401DC05AB +00:00:15:27 T49S494F4301DD72F4QROO7401DD03AB +00:00:15:28 T49S494F4301DE72F4QROO7401DE01AB +00:00:15:29 T49S494F4301DF72F4QROO7401DFFFAB +00:00:16:00 T49S494F4301E072F4QROO7401E0FDAB +00:00:16:01 T49S494F4301E172F4QROO7401E1FBAB +00:00:16:02 T49S494F4301E272F4QROO7401E2F9AB +00:00:16:03 T49S494F4301E372F4QROO7401E3F7AB +00:00:16:04 T49S494F4301E472F4QROO7401E4F5AB +00:00:16:05 T49S494F4301E572F4QROO7401E5F3AB +00:00:16:06 T49S494F4301E672F4QROO7401E6F1AB +00:00:16:07 T49S494F4301E772F4QROO7401E7EFAB +00:00:16:08 T49S494F4301E872F4QROO7401E8EDAB +00:00:16:09 T49S494F4301E972F4QROO7401E9EBAB +00:00:16:10 T49S494F4301EA72F4QROO7401EAE9AB +00:00:16:11 T49S494F4301EB72F4QROO7401EBE7AB +00:00:16:12 T49S494F4301EC72F4QROO7401ECE5AB +00:00:16:13 T49S494F4301ED72F4QROO7401EDE3AB +00:00:16:14 T49S494F4301EE72F4QROO7401EEE1AB +00:00:16:15 T49S494F4301EF72F4QROO7401EFDFAB +00:00:16:16 T49S494F4301F072F4QROO7401F0DDAB +00:00:16:17 T49S494F4301F172F4QROO7401F1DBAB +00:00:16:18 T49S494F4301F272F4QROO7401F2D9AB +00:00:16:19 T49S494F4301F372F4QROO7401F3D7AB +00:00:16:20 T49S494F4301F472F4QROO7401F4D5AB +00:00:16:21 T49S494F4301F572F4QROO7401F5D3AB +00:00:16:22 T49S494F4301F672F4QROO7401F6D1AB +00:00:16:23 T49S494F4301F772F4QROO7401F7CFAB +00:00:16:24 T49S494F4301F872F4QROO7401F8CDAB +00:00:16:25 T49S494F4301F972F4QROO7401F9CBAB +00:00:16:26 T49S494F4301FA72F4QROO7401FAC9AB +00:00:16:27 T49S494F4301FB72F4QROO7401FBC7AB +00:00:16:28 T49S494F4301FC72F4QROO7401FCC5AB +00:00:16:29 T49S494F4301FD72F4QROO7401FDC3AB +00:00:17:00 T49S494F4301FE72F4QROO7401FEC1AB +00:00:17:01 T49S494F4301FF72F4QROO7401FFBFAB +00:00:17:02 T49S494F4302Z72F4QROO7402ZBBAB +00:00:17:03 T49S494F43020172F4QROO740201B9AB +00:00:17:04 T49S494F43020272F4QROO740202B7AB +00:00:17:05 T49S494F43020372F4QROO740203B5AB +00:00:17:06 T49S494F43020472F4QROO740204B3AB +00:00:17:07 T49S494F43020572F4QROO740205B1AB +00:00:17:08 T49S494F43020672F4QROO740206AFAB +00:00:17:09 T49S494F43020772F4QROO740207ADAB +00:00:17:10 T49S494F43020872F4QROO740208ABAB +00:00:17:11 T49S494F43020972F4QROO740209A9AB +00:00:17:12 T49S494F43020A72F4QROO74020AA7AB +00:00:17:13 T49S494F43020B72F4QROO74020BA5AB +00:00:17:14 T49S494F43020C72F4QROO74020CA3AB +00:00:17:15 T49S494F43020D72F4QROO74020DA1AB +00:00:17:16 T49S494F43020E72F4QROO74020E9FAB +00:00:17:17 T49S494F43020F72F4QROO74020F9DAB +00:00:17:18 T49S494F43021072F4QROO7402109BAB +00:00:17:19 T49S494F43021172F4QROO74021199AB +00:00:17:20 T49S494F43021272F4QROO74021297AB +00:00:17:21 T49S494F43021372F4QROO74021395AB +00:00:17:22 T49S494F43021472F4QROO74021493AB +00:00:17:23 T49S494F43021572F4QROO74021591AB +00:00:17:24 T49S494F43021672F4QROO7402168FAB +00:00:17:25 T49S494F43021772F4QROO7402178DAB +00:00:17:26 T49S494F43021872F4QROO7402188BAB +00:00:17:27 T49S494F43021972F4QROO74021989AB +00:00:17:28 T49S494F43021A72F4QROO74021A87AB +00:00:17:29 T49S494F43021B72F4QROO74021B85AB +00:00:18:00 T49S494F43021C72F4QROO74021C83AB +00:00:18:01 T49S494F43021D72F4QROO74021D81AB +00:00:18:02 T49S494F43021E72F4QROO74021E7FAB +00:00:18:03 T49S494F43021F72F4QROO74021F7DAB +00:00:18:04 T49S494F43022072F4QROO7402207BAB +00:00:18:05 T49S494F43022172F4QROO74022179AB +00:00:18:06 T49S494F43022272F4QROO74022277AB +00:00:18:07 T49S494F43022372F4QROO74022375AB +00:00:18:08 T49S494F43022472F4QROO74022473AB +00:00:18:09 T49S494F43022572F4QROO74022571AB +00:00:18:10 T49S494F43022672F4QROO7402266FAB +00:00:18:11 T49S494F43022772F4QROO7402276DAB +00:00:18:12 T49S494F43022872F4QROO7402286BAB +00:00:18:13 T49S494F43022972F4QROO74022969AB +00:00:18:14 T49S494F43022A72F4QROO74022A67AB +00:00:18:15 T49S494F43022B72F4QROO74022B65AB +00:00:18:16 T49S494F43022C72F4QROO74022C63AB +00:00:18:17 T49S494F43022D72F4QROO74022D61AB +00:00:18:18 T49S494F43022E72F4QROO74022E5FAB +00:00:18:19 T49S494F43022F72F4QROO74022F5DAB +00:00:18:20 T49S494F43023072F4QROO7402305BAB +00:00:18:21 T49S494F43023172F4QROO74023159AB +00:00:18:22 T49S494F43023272F4QROO74023257AB +00:00:18:23 T49S494F43023372F4QROO74023355AB +00:00:18:24 T49S494F43023472F4QROO74023453AB +00:00:18:25 T49S494F43023572F4QROO74023551AB +00:00:18:26 T49S494F43023672F4QROO7402364FAB +00:00:18:27 T49S494F43023772F4QROO7402374DAB +00:00:18:28 T49S494F43023872F4QROO7402384BAB +00:00:18:29 T49S494F43023972F4QROO74023949AB +00:00:19:00 T49S494F43023A72F4QROO74023A47AB +00:00:19:01 T49S494F43023B72F4QROO74023B45AB +00:00:19:02 T49S494F43023C72F4QROO74023C43AB +00:00:19:03 T49S494F43023D72F4QROO74023D41AB +00:00:19:04 T49S494F43023E72F4QROO74023E3FAB +00:00:19:05 T49S494F43023F72F4QROO74023F3DAB +00:00:19:06 T49S494F43024072F4QROO7402403BAB +00:00:19:07 T52S524F67024172F4QRFF4222FE8CFFOM739181656E67817FFF74024156B4 diff --git a/gst-plugin-closedcaption/tests/mcc_enc.rs b/gst-plugin-closedcaption/tests/mcc_enc.rs new file mode 100644 index 00000000..4e4b267d --- /dev/null +++ b/gst-plugin-closedcaption/tests/mcc_enc.rs @@ -0,0 +1,143 @@ +// Copyright (C) 2018 Sebastian Dröge +// +// 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. + +extern crate glib; +use glib::prelude::*; + +extern crate gstreamer as gst; +extern crate gstreamer_check as gst_check; +extern crate gstreamer_video as gst_video; + +extern crate gstrsclosedcaption; + +#[macro_use] +extern crate pretty_assertions; + +fn init() { + use std::sync::{Once, ONCE_INIT}; + static INIT: Once = ONCE_INIT; + + INIT.call_once(|| { + gst::init().unwrap(); + gstrsclosedcaption::plugin_register_static(); + }); +} + +/// Encode a single CDP packet and compare the output +#[test] +fn test_encode() { + init(); + + let input = [ + 0x96, 0x69, 0x52, 0x4f, 0x67, 0x00, 0x00, 0x72, 0xf4, 0xfc, 0x80, 0x80, 0xfd, 0x80, 0x80, + 0xff, 0x02, 0x22, 0xfe, 0x8c, 0xff, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, + 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, + 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, + 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x73, 0x91, 0x81, 0x65, 0x6e, 0x67, + 0x81, 0x7f, 0xff, 0x74, 0x00, 0x00, 0x1c, + ]; + + let expected_output = b"File Format=MacCaption_MCC V1.0\r\n\ +\r\n\ +///////////////////////////////////////////////////////////////////////////////////\r\n\ +// Computer Prompting and Captioning Company\r\n\ +// Ancillary Data Packet Transfer File\r\n\ +//\r\n\ +// Permission to generate this format is granted provided that\r\n\ +// 1. This ANC Transfer file format is used on an as-is basis and no warranty is given, and\r\n\ +// 2. This entire descriptive information text is included in a generated .mcc file.\r\n\ +//\r\n\ +// General file format:\r\n\ +// HH:MM:SS:FF(tab)[Hexadecimal ANC data in groups of 2 characters]\r\n\ +// Hexadecimal data starts with the Ancillary Data Packet DID (Data ID defined in S291M)\r\n\ +// and concludes with the Check Sum following the User Data Words.\r\n\ +// Each time code line must contain at most one complete ancillary data packet.\r\n\ +// To transfer additional ANC Data successive lines may contain identical time code.\r\n\ +// Time Code Rate=[24, 25, 30, 30DF, 50, 60]\r\n\ +//\r\n\ +// ANC data bytes may be represented by one ASCII character according to the following schema:\r\n\ +// G FAh 00h 00h\r\n\ +// H 2 x (FAh 00h 00h)\r\n\ +// I 3 x (FAh 00h 00h)\r\n\ +// J 4 x (FAh 00h 00h)\r\n\ +// K 5 x (FAh 00h 00h)\r\n\ +// L 6 x (FAh 00h 00h)\r\n\ +// M 7 x (FAh 00h 00h)\r\n\ +// N 8 x (FAh 00h 00h)\r\n\ +// O 9 x (FAh 00h 00h)\r\n\ +// P FBh 80h 80h\r\n\ +// Q FCh 80h 80h\r\n\ +// R FDh 80h 80h\r\n\ +// S 96h 69h\r\n\ +// T 61h 01h\r\n\ +// U E1h 00h 00h 00h\r\n\ +// Z 00h\r\n\ +//\r\n\ +///////////////////////////////////////////////////////////////////////////////////\r\n\ +\r\n\ +UUID=14720C04-857D-40E2-86FC-F080DE44CE74\r\n\ +Creation Program=GStreamer MCC Encoder 0.4.0\r\n\ +Creation Date=Thursday, December 27, 2018\r\n\ +Creation Time=17:34:47\r\n\ +Time Code Rate=30DF\r\n\ +\r\n\ +11:12:13;14 T52S524F67ZZ72F4QRFF0222FE8CFFOM739181656E67817FFF74ZZ1CZ\r\n"; + + let mut h = gst_check::Harness::new("mccenc"); + { + let enc = h.get_element().expect("could not create encoder"); + enc.set_property("uuid", &"14720C04-857D-40E2-86FC-F080DE44CE74") + .unwrap(); + enc.set_property( + "creation-date", + &glib::DateTime::new_utc(2018, 12, 27, 17, 34, 47.0), + ) + .unwrap(); + } + + h.set_src_caps_str( + "closedcaption/x-cea-708, format=(string)cdp, framerate=(fraction)30000/1001", + ); + + let buf = { + let mut buf = gst::Buffer::from_mut_slice(Vec::from(&input[..])); + let buf_ref = buf.get_mut().unwrap(); + let tc = gst_video::ValidVideoTimeCode::new( + gst::Fraction::new(30000, 1001), + None, + gst_video::VideoTimeCodeFlags::DROP_FRAME, + 11, + 12, + 13, + 14, + 0, + ) + .unwrap(); + gst_video::VideoTimeCodeMeta::add(buf_ref, &tc); + buf + }; + + assert_eq!(h.push(buf), Ok(gst::FlowSuccess::Ok)); + h.push_event(gst::Event::new_eos().build()); + + let buf = h.pull().expect("Couldn't pull buffer"); + let map = buf.map_readable().expect("Couldn't map buffer readable"); + assert_eq!( + std::str::from_utf8(map.as_ref()), + std::str::from_utf8(expected_output.as_ref()) + ); +} diff --git a/gst-plugin-closedcaption/tests/mcc_parse.rs b/gst-plugin-closedcaption/tests/mcc_parse.rs new file mode 100644 index 00000000..27203a50 --- /dev/null +++ b/gst-plugin-closedcaption/tests/mcc_parse.rs @@ -0,0 +1,136 @@ +// Copyright (C) 2018 Sebastian Dröge +// +// 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. + +extern crate glib; + +extern crate gstreamer as gst; +use gst::prelude::*; +extern crate gstreamer_check as gst_check; +extern crate gstreamer_video as gst_video; + +extern crate rand; +use rand::{Rng, SeedableRng}; + +extern crate gstrsclosedcaption; + +#[macro_use] +extern crate pretty_assertions; + +fn init() { + use std::sync::{Once, ONCE_INIT}; + static INIT: Once = ONCE_INIT; + + INIT.call_once(|| { + gst::init().unwrap(); + gstrsclosedcaption::plugin_register_static(); + }); +} + +/// Randomized test passing buffers of arbitrary sizes to the parser +#[test] +fn test_parse() { + init(); + let mut data = include_bytes!("captions-test_708.mcc").as_ref(); + + let mut rnd = if let Ok(seed) = std::env::var("MCC_PARSE_TEST_SEED") { + rand::rngs::SmallRng::seed_from_u64( + seed.parse::() + .expect("MCC_PARSE_TEST_SEED has to contain a 64 bit integer seed"), + ) + } else { + let seed = rand::random::(); + println!("seed {}", seed); + rand::rngs::SmallRng::seed_from_u64(seed) + }; + + let mut h = gst_check::Harness::new("mccparse"); + + let mut input_len = 0; + let mut output_len = 0; + let mut checksum = 0u32; + let mut expected_timecode = None; + + while !data.is_empty() { + let l = if data.len() == 1 { + 1 + } else { + rnd.gen_range(1, data.len()) + }; + let buf = gst::Buffer::from_mut_slice(Vec::from(&data[0..l])); + input_len += buf.get_size(); + assert_eq!(h.push(buf), Ok(gst::FlowSuccess::Ok)); + while let Some(buf) = h.try_pull() { + output_len += buf.get_size(); + checksum = checksum.wrapping_add( + buf.map_readable() + .unwrap() + .iter() + .fold(0u32, |s, v| s.wrapping_add(*v as u32)), + ); + + let tc_meta = buf + .get_meta::() + .expect("No timecode meta"); + if let Some(ref timecode) = expected_timecode { + assert_eq!(&tc_meta.get_tc(), timecode); + } else { + expected_timecode = Some(tc_meta.get_tc()); + } + expected_timecode.as_mut().map(|tc| tc.increment_frame()); + } + data = &data[l..]; + } + + h.push_event(gst::Event::new_eos().build()); + while let Some(buf) = h.try_pull() { + output_len += buf.get_size(); + checksum = checksum.wrapping_add( + buf.map_readable() + .unwrap() + .iter() + .fold(0u32, |s, v| s.wrapping_add(*v as u32)), + ); + + let tc_meta = buf + .get_meta::() + .expect("No timecode meta"); + if let Some(ref timecode) = expected_timecode { + assert_eq!(&tc_meta.get_tc(), timecode); + } else { + expected_timecode = Some(tc_meta.get_tc()); + } + expected_timecode.as_mut().map(|tc| tc.increment_frame()); + } + + assert!(expected_timecode.is_some()); + assert_eq!(input_len, 28818); + assert_eq!(output_len, 42383); + assert_eq!(checksum, 3988480); + + let caps = h + .get_sinkpad() + .expect("harness has no sinkpad") + .get_current_caps() + .expect("pad has no caps"); + assert_eq!( + caps, + gst::Caps::builder("closedcaption/x-cea-708") + .field("format", &"cdp") + .field("framerate", &gst::Fraction::new(30000, 1001)) + .build() + ); +}