#[allow(dead_code)]
#[derive(Clone,Copy,PartialEq)]
pub struct NAAudioInfo {
- sample_rate: u32,
- channels: u8,
- format: NASoniton,
- block_len: usize,
+ pub sample_rate: u32,
+ pub channels: u8,
+ pub format: NASoniton,
+ pub block_len: usize,
}
impl NAAudioInfo {
info: NAAudioInfo,
data: NABufferRef<Vec<T>>,
offs: Vec<usize>,
+ stride: usize,
chmap: NAChannelMap,
len: usize,
}
if idx >= self.offs.len() { 0 }
else { self.offs[idx] }
}
+ pub fn get_stride(&self) -> usize { self.stride }
pub fn get_info(&self) -> NAAudioInfo { self.info }
- pub fn get_chmap(&self) -> NAChannelMap { self.chmap.clone() }
+ pub fn get_chmap(&self) -> &NAChannelMap { &self.chmap }
pub fn get_data(&self) -> &Vec<T> { self.data.as_ref() }
pub fn get_data_mut(&mut self) -> Option<&mut Vec<T>> { self.data.as_mut() }
pub fn copy_buffer(&mut self) -> Self {
data.clone_from(self.data.as_ref());
let mut offs: Vec<usize> = Vec::with_capacity(self.offs.len());
offs.clone_from(&self.offs);
- NAAudioBuffer { info: self.info, data: NABufferRef::new(data), offs, chmap: self.get_chmap(), len: self.len }
+ NAAudioBuffer { info: self.info, data: NABufferRef::new(data), offs, chmap: self.get_chmap().clone(), len: self.len, stride: self.stride }
}
pub fn get_length(&self) -> usize { self.len }
}
impl NAAudioBuffer<u8> {
pub fn new_from_buf(info: NAAudioInfo, data: NABufferRef<Vec<u8>>, chmap: NAChannelMap) -> Self {
let len = data.len();
- NAAudioBuffer { info, data, chmap, offs: Vec::new(), len }
+ NAAudioBuffer { info, data, chmap, offs: Vec::new(), len, stride: 0 }
}
}
_ => None,
}
}
+ pub fn get_audio_info(&self) -> Option<NAAudioInfo> {
+ match *self {
+ NABufferType::AudioU8(ref ab) => Some(ab.get_info()),
+ NABufferType::AudioI16(ref ab) => Some(ab.get_info()),
+ NABufferType::AudioI32(ref ab) => Some(ab.get_info()),
+ NABufferType::AudioF32(ref ab) => Some(ab.get_info()),
+ NABufferType::AudioPacked(ref ab) => Some(ab.get_info()),
+ _ => None,
+ }
+ }
+ pub fn get_chmap(&self) -> Option<&NAChannelMap> {
+ match *self {
+ NABufferType::AudioU8(ref ab) => Some(ab.get_chmap()),
+ NABufferType::AudioI16(ref ab) => Some(ab.get_chmap()),
+ NABufferType::AudioI32(ref ab) => Some(ab.get_chmap()),
+ NABufferType::AudioF32(ref ab) => Some(ab.get_chmap()),
+ NABufferType::AudioPacked(ref ab) => Some(ab.get_chmap()),
+ _ => None,
+ }
+ }
+ pub fn get_audio_length(&self) -> usize {
+ match *self {
+ NABufferType::AudioU8(ref ab) => ab.get_length(),
+ NABufferType::AudioI16(ref ab) => ab.get_length(),
+ NABufferType::AudioI32(ref ab) => ab.get_length(),
+ NABufferType::AudioF32(ref ab) => ab.get_length(),
+ NABufferType::AudioPacked(ref ab) => ab.get_length(),
+ _ => 0,
+ }
+ }
+ pub fn get_audio_stride(&self) -> usize {
+ match *self {
+ NABufferType::AudioU8(ref ab) => ab.get_stride(),
+ NABufferType::AudioI16(ref ab) => ab.get_stride(),
+ NABufferType::AudioI32(ref ab) => ab.get_stride(),
+ NABufferType::AudioF32(ref ab) => ab.get_stride(),
+ NABufferType::AudioPacked(ref ab) => ab.get_stride(),
+ _ => 0,
+ }
+ }
pub fn get_abuf_u8(&self) -> Option<NAAudioBuffer<u8>> {
match *self {
NABufferType::AudioU8(ref ab) => Some(ab.clone()),
let len = nsamples.checked_mul(ainfo.channels as usize);
if len == None { return Err(AllocatorError::TooLargeDimensions); }
let length = len.unwrap();
+ let stride = nsamples;
for i in 0..ainfo.channels {
- offs.push((i as usize) * nsamples);
+ offs.push((i as usize) * stride);
}
if ainfo.format.is_float() {
if ainfo.format.get_bits() == 32 {
let data: Vec<f32> = vec![0.0; length];
- let buf: NAAudioBuffer<f32> = NAAudioBuffer { data: NABufferRef::new(data), info: ainfo, offs, chmap, len: nsamples };
+ let buf: NAAudioBuffer<f32> = NAAudioBuffer { data: NABufferRef::new(data), info: ainfo, offs, chmap, len: nsamples, stride };
Ok(NABufferType::AudioF32(buf))
} else {
Err(AllocatorError::TooLargeDimensions)
} else {
if ainfo.format.get_bits() == 8 && !ainfo.format.is_signed() {
let data: Vec<u8> = vec![0; length];
- let buf: NAAudioBuffer<u8> = NAAudioBuffer { data: NABufferRef::new(data), info: ainfo, offs, chmap, len: nsamples };
+ let buf: NAAudioBuffer<u8> = NAAudioBuffer { data: NABufferRef::new(data), info: ainfo, offs, chmap, len: nsamples, stride };
Ok(NABufferType::AudioU8(buf))
} else if ainfo.format.get_bits() == 16 && ainfo.format.is_signed() {
let data: Vec<i16> = vec![0; length];
- let buf: NAAudioBuffer<i16> = NAAudioBuffer { data: NABufferRef::new(data), info: ainfo, offs, chmap, len: nsamples };
+ let buf: NAAudioBuffer<i16> = NAAudioBuffer { data: NABufferRef::new(data), info: ainfo, offs, chmap, len: nsamples, stride };
Ok(NABufferType::AudioI16(buf))
} else {
Err(AllocatorError::TooLargeDimensions)
if len == None { return Err(AllocatorError::TooLargeDimensions); }
let length = ainfo.format.get_audio_size(len.unwrap() as u64);
let data: Vec<u8> = vec![0; length];
- let buf: NAAudioBuffer<u8> = NAAudioBuffer { data: NABufferRef::new(data), info: ainfo, offs, chmap, len: nsamples };
+ let buf: NAAudioBuffer<u8> = NAAudioBuffer { data: NABufferRef::new(data), info: ainfo, offs, chmap, len: nsamples, stride: 0 };
Ok(NABufferType::AudioPacked(buf))
}
}
pub fn set_pts(&mut self, pts: Option<u64>) { self.pts = pts; }
pub fn set_dts(&mut self, dts: Option<u64>) { self.dts = dts; }
pub fn set_duration(&mut self, dur: Option<u64>) { self.duration = dur; }
+
+ 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 tmp = time.checked_mul(tb_num);
+ if let Some(tmp) = tmp {
+ tmp / base / tb_den
+ } else {
+ let tmp = time.checked_mul(tb_num);
+ if let Some(tmp) = tmp {
+ tmp / base / tb_den
+ } else {
+ let coarse = time / base;
+ let tmp = coarse.checked_mul(tb_num);
+ if let Some(tmp) = tmp {
+ tmp / tb_den
+ } else {
+ (coarse / tb_den) * tb_num
+ }
+ }
+ }
+ }
+ 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 tmp = ts.checked_mul(base);
+ if let Some(tmp) = tmp {
+ let tmp2 = tmp.checked_mul(tb_num);
+ if let Some(tmp2) = tmp2 {
+ tmp2 / tb_den
+ } else {
+ (tmp / tb_den) * tb_num
+ }
+ } else {
+ let tmp = ts.checked_mul(tb_num);
+ if let Some(tmp) = tmp {
+ (tmp / tb_den) * base
+ } else {
+ (ts / tb_den) * base * tb_num
+ }
+ }
+ }
}
#[allow(dead_code)]
#[derive(Clone)]
pub struct NAFrame {
ts: NATimeInfo,
+ id: i64,
buffer: NABufferType,
info: NACodecInfoRef,
ftype: FrameType,
info: NACodecInfoRef,
options: HashMap<String, NAValue>,
buffer: NABufferType) -> Self {
- NAFrame { ts, buffer, info, ftype, key: keyframe, options }
+ NAFrame { ts, id: 0, buffer, info, ftype, key: keyframe, options }
}
pub fn get_info(&self) -> NACodecInfoRef { self.info.clone() }
pub fn get_frame_type(&self) -> FrameType { self.ftype }
pub fn get_time_information(&self) -> NATimeInfo { self.ts }
pub fn get_pts(&self) -> Option<u64> { self.ts.get_pts() }
pub fn get_dts(&self) -> Option<u64> { self.ts.get_dts() }
+ pub fn get_id(&self) -> i64 { self.id }
pub fn get_duration(&self) -> Option<u64> { self.ts.get_duration() }
pub fn set_pts(&mut self, pts: Option<u64>) { self.ts.set_pts(pts); }
pub fn set_dts(&mut self, dts: Option<u64>) { self.ts.set_dts(dts); }
+ pub fn set_id(&mut self, id: i64) { self.id = id; }
pub fn set_duration(&mut self, dur: Option<u64>) { self.ts.set_duration(dur); }
pub fn get_buffer(&self) -> NABufferType { self.buffer.clone() }
}
/// Possible stream types.
-#[derive(Debug,Clone,Copy)]
+#[derive(Debug,Clone,Copy,PartialEq)]
#[allow(dead_code)]
pub enum StreamType {
/// video stream
NAStream { media_type: mt, id, num: 0, info: info.into_ref(), tb_num: n, tb_den: d }
}
pub fn get_id(&self) -> u32 { self.id }
+ pub fn get_media_type(&self) -> StreamType { self.media_type }
pub fn get_num(&self) -> usize { self.num }
pub fn set_num(&mut self, num: usize) { self.num = num; }
pub fn get_info(&self) -> NACodecInfoRef { self.info.clone() }
projects / nihav.git / blobdiff