use std::cmp::max;
//use std::collections::HashMap;
use std::fmt;
-use std::sync::Arc;
+pub use std::sync::Arc;
pub use crate::formats::*;
pub use crate::refs::*;
pub flipped: bool,
/// Picture pixel format.
pub format: NAPixelFormaton,
+ /// Declared bits per sample.
+ pub bits: u8,
}
impl NAVideoInfo {
/// Constructs a new `NAVideoInfo` instance.
pub fn new(w: usize, h: usize, flip: bool, fmt: NAPixelFormaton) -> Self {
- NAVideoInfo { width: w, height: h, flipped: flip, format: fmt }
+ let bits = fmt.get_total_depth();
+ NAVideoInfo { width: w, height: h, flipped: flip, format: fmt, bits }
}
/// Returns picture width.
pub fn get_width(&self) -> usize { self.width as usize }
pub fn get_chmap(&self) -> &NAChannelMap { &self.chmap }
/// Returns an immutable reference to the data.
pub fn get_data(&self) -> &Vec<T> { self.data.as_ref() }
+ /// Returns reference to the data.
+ pub fn get_data_ref(&self) -> NABufferRef<Vec<T>> { self.data.clone() }
/// Returns a mutable reference to the data.
pub fn get_data_mut(&mut self) -> Option<&mut Vec<T>> { self.data.as_mut() }
/// Clones current `NAAudioBuffer` into a new one.
properties: NACodecTypeInfo::None,
extradata: None };
-/// A list of accepted option values.
-#[derive(Debug,Clone)]
-pub enum NAValue {
- /// Empty value.
- None,
- /// Integer value.
- Int(i32),
- /// Long integer value.
- Long(i64),
- /// String value.
- String(String),
- /// Binary data value.
- Data(Arc<Vec<u8>>),
-}
-
/// A list of recognized frame types.
#[derive(Debug,Clone,Copy,PartialEq)]
#[allow(dead_code)]
/// Converts time in given scale into timestamp in given base.
pub fn time_to_ts(time: u64, base: u64, tb_num: u32, tb_den: u32) -> u64 {
- let tb_num = tb_num as u64;
- let tb_den = tb_den as u64;
+ let tb_num = u64::from(tb_num);
+ let tb_den = u64::from(tb_den);
let tmp = time.checked_mul(tb_num);
if let Some(tmp) = tmp {
tmp / base / tb_den
}
/// Converts timestamp in given base into time in given scale.
pub fn ts_to_time(ts: u64, base: u64, tb_num: u32, tb_den: u32) -> u64 {
- let tb_num = tb_num as u64;
- let tb_den = tb_den as u64;
+ let tb_num = u64::from(tb_num);
+ let tb_den = u64::from(tb_den);
let tmp = ts.checked_mul(base);
if let Some(tmp) = tmp {
let tmp2 = tmp.checked_mul(tb_num);
}
}
+/// Side data that may accompany demuxed data.
+#[derive(Clone)]
+pub enum NASideData {
+ /// Palette information.
+ ///
+ /// This side data contains a flag signalling that palette has changed since previous time and a reference to the current palette.
+ /// Palette is stored in 8-bit RGBA format.
+ Palette(bool, Arc<[u8; 1024]>),
+ /// Generic user data.
+ UserData(Arc<Vec<u8>>),
+}
+
/// Packet with compressed data.
#[allow(dead_code)]
pub struct NAPacket {
/// Keyframe flag.
pub keyframe: bool,
// options: HashMap<String, NAValue<'a>>,
+ /// Packet side data (e.g. palette for paletted formats).
+ pub side_data: Vec<NASideData>,
}
impl NAPacket {
pub fn new(str: NAStreamRef, ts: NATimeInfo, kf: bool, vec: Vec<u8>) -> Self {
// let mut vec: Vec<u8> = Vec::new();
// vec.resize(size, 0);
- NAPacket { stream: str, ts, keyframe: kf, buffer: NABufferRef::new(vec) }
+ NAPacket { stream: str, ts, keyframe: kf, buffer: NABufferRef::new(vec), side_data: Vec::new() }
+ }
+ /// Constructs a new `NAPacket` instance reusing a buffer reference.
+ pub fn new_from_refbuf(str: NAStreamRef, ts: NATimeInfo, kf: bool, buffer: NABufferRef<Vec<u8>>) -> Self {
+ NAPacket { stream: str, ts, keyframe: kf, buffer, side_data: Vec::new() }
}
/// Returns information about the stream packet belongs to.
pub fn get_stream(&self) -> NAStreamRef { self.stream.clone() }
pub fn is_keyframe(&self) -> bool { self.keyframe }
/// Returns a reference to packet data.
pub fn get_buffer(&self) -> NABufferRef<Vec<u8>> { self.buffer.clone() }
+ /// Adds side data for a packet.
+ pub fn add_side_data(&mut self, side_data: NASideData) { self.side_data.push(side_data); }
+ /// Assigns packet to a new stream.
+ pub fn reassign(&mut self, str: NAStreamRef, ts: NATimeInfo) {
+ self.stream = str;
+ self.ts = ts;
+ }
}
impl Drop for NAPacket {