}
}
-pub type BufferRef = Rc<RefCell<Vec<u8>>>;
-
pub type NABufferRefT<T> = Rc<RefCell<Vec<T>>>;
#[derive(Clone)]
pub struct NAVideoBuffer<T> {
- info: NAVideoInfo,
- data: NABufferRefT<T>,
- offs: Vec<usize>,
+ info: NAVideoInfo,
+ data: NABufferRefT<T>,
+ offs: Vec<usize>,
+ strides: Vec<usize>,
}
impl<T: Clone> NAVideoBuffer<T> {
data.clone_from(self.data.borrow().as_ref());
let mut offs: Vec<usize> = Vec::with_capacity(self.offs.len());
offs.clone_from(&self.offs);
- NAVideoBuffer { info: self.info, data: Rc::new(RefCell::new(data)), offs: offs }
+ let mut strides: Vec<usize> = Vec::with_capacity(self.strides.len());
+ strides.clone_from(&self.strides);
+ NAVideoBuffer { info: self.info, data: Rc::new(RefCell::new(data)), offs: offs, strides: strides }
}
pub fn get_stride(&self, idx: usize) -> usize {
- if idx >= self.info.get_format().get_num_comp() { return 0; }
- self.info.get_format().get_chromaton(idx).unwrap().get_linesize(self.info.get_width())
+ if idx >= self.strides.len() { return 0; }
+ self.strides[idx]
}
pub fn get_dimensions(&self, idx: usize) -> (usize, usize) {
get_plane_size(&self.info, idx)
}
}
+impl NAAudioBuffer<u8> {
+ pub fn new_from_buf(info: NAAudioInfo, data: NABufferRefT<u8>, chmap: NAChannelMap) -> Self {
+ NAAudioBuffer { info: info, data: data, chmap: chmap, offs: Vec::new() }
+ }
+}
+
#[derive(Clone)]
pub enum NABufferType {
Video (NAVideoBuffer<u8>),
VideoPacked(NAVideoBuffer<u8>),
AudioU8 (NAAudioBuffer<u8>),
AudioI16 (NAAudioBuffer<i16>),
+ AudioI32 (NAAudioBuffer<i32>),
AudioF32 (NAAudioBuffer<f32>),
AudioPacked(NAAudioBuffer<u8>),
Data (NABufferRefT<u8>),
pub fn get_vbuf(&mut self) -> Option<NAVideoBuffer<u8>> {
match *self {
NABufferType::Video(ref vb) => Some(vb.clone()),
+ NABufferType::VideoPacked(ref vb) => Some(vb.clone()),
+ _ => None,
+ }
+ }
+ pub fn get_vbuf16(&mut self) -> Option<NAVideoBuffer<u16>> {
+ match *self {
+ NABufferType::Video16(ref vb) => Some(vb.clone()),
+ _ => None,
+ }
+ }
+ pub fn get_abuf_u8(&mut self) -> Option<NAAudioBuffer<u8>> {
+ match *self {
+ NABufferType::AudioU8(ref ab) => Some(ab.clone()),
+ NABufferType::AudioPacked(ref ab) => Some(ab.clone()),
+ _ => None,
+ }
+ }
+ pub fn get_abuf_i16(&mut self) -> Option<NAAudioBuffer<i16>> {
+ match *self {
+ NABufferType::AudioI16(ref ab) => Some(ab.clone()),
+ _ => None,
+ }
+ }
+ pub fn get_abuf_i32(&mut self) -> Option<NAAudioBuffer<i32>> {
+ match *self {
+ NABufferType::AudioI32(ref ab) => Some(ab.clone()),
+ _ => None,
+ }
+ }
+ pub fn get_abuf_f32(&mut self) -> Option<NAAudioBuffer<f32>> {
+ match *self {
+ NABufferType::AudioF32(ref ab) => Some(ab.clone()),
_ => None,
}
}
pub fn alloc_video_buffer(vinfo: NAVideoInfo, align: u8) -> Result<NABufferType, AllocatorError> {
let fmt = &vinfo.format;
let mut new_size: usize = 0;
- let mut offs: Vec<usize> = Vec::new();
+ let mut offs: Vec<usize> = Vec::new();
+ let mut strides: Vec<usize> = Vec::new();
for i in 0..fmt.get_num_comp() {
if fmt.get_chromaton(i) == None { return Err(AllocatorError::FormatError); }
let mut max_depth = 0;
let mut all_packed = true;
for i in 0..fmt.get_num_comp() {
- let chr = fmt.get_chromaton(i).unwrap();
+ let ochr = fmt.get_chromaton(i);
+ if let None = ochr { continue; }
+ let chr = ochr.unwrap();
if !chr.is_packed() {
all_packed = false;
break;
}
//todo semi-packed like NV12
- if !all_packed {
+ if fmt.is_paletted() {
+//todo various-sized palettes?
+ let stride = vinfo.get_format().get_chromaton(0).unwrap().get_linesize(width);
+ let pic_sz = stride.checked_mul(height);
+ if pic_sz == None { return Err(AllocatorError::TooLargeDimensions); }
+ let pal_size = 256 * (fmt.get_elem_size() as usize);
+ let new_size = pic_sz.unwrap().checked_add(pal_size);
+ if new_size == None { return Err(AllocatorError::TooLargeDimensions); }
+ offs.push(0);
+ offs.push(stride * height);
+ strides.push(stride);
+ let mut data: Vec<u8> = Vec::with_capacity(new_size.unwrap());
+ data.resize(new_size.unwrap(), 0);
+ let buf: NAVideoBuffer<u8> = NAVideoBuffer { data: Rc::new(RefCell::new(data)), info: vinfo, offs: offs, strides: strides };
+ Ok(NABufferType::Video(buf))
+ } else if !all_packed {
for i in 0..fmt.get_num_comp() {
- let chr = fmt.get_chromaton(i).unwrap();
+ let ochr = fmt.get_chromaton(i);
+ if let None = ochr { continue; }
+ let chr = ochr.unwrap();
if !vinfo.is_flipped() {
offs.push(new_size as usize);
}
- let cur_w = chr.get_width(width);
+ let stride = chr.get_linesize(width);
let cur_h = chr.get_height(height);
- let cur_sz = cur_w.checked_mul(cur_h);
+ let cur_sz = stride.checked_mul(cur_h);
if cur_sz == None { return Err(AllocatorError::TooLargeDimensions); }
let new_sz = new_size.checked_add(cur_sz.unwrap());
if new_sz == None { return Err(AllocatorError::TooLargeDimensions); }
if vinfo.is_flipped() {
offs.push(new_size as usize);
}
+ strides.push(stride);
}
if max_depth <= 8 {
let mut data: Vec<u8> = Vec::with_capacity(new_size);
data.resize(new_size, 0);
- let buf: NAVideoBuffer<u8> = NAVideoBuffer { data: Rc::new(RefCell::new(data)), info: vinfo, offs: offs };
+ let buf: NAVideoBuffer<u8> = NAVideoBuffer { data: Rc::new(RefCell::new(data)), info: vinfo, offs: offs, strides: strides };
Ok(NABufferType::Video(buf))
} else {
let mut data: Vec<u16> = Vec::with_capacity(new_size);
data.resize(new_size, 0);
- let buf: NAVideoBuffer<u16> = NAVideoBuffer { data: Rc::new(RefCell::new(data)), info: vinfo, offs: offs };
+ let buf: NAVideoBuffer<u16> = NAVideoBuffer { data: Rc::new(RefCell::new(data)), info: vinfo, offs: offs, strides: strides };
Ok(NABufferType::Video16(buf))
}
} else {
new_size = new_sz.unwrap();
let mut data: Vec<u8> = Vec::with_capacity(new_size);
data.resize(new_size, 0);
- let buf: NAVideoBuffer<u8> = NAVideoBuffer { data: Rc::new(RefCell::new(data)), info: vinfo, offs: offs };
+ strides.push(line_sz.unwrap());
+ let buf: NAVideoBuffer<u8> = NAVideoBuffer { data: Rc::new(RefCell::new(data)), info: vinfo, offs: offs, strides: strides };
Ok(NABufferType::VideoPacked(buf))
}
}
I,
P,
B,
+ Skip,
Other,
}
FrameType::I => write!(f, "I"),
FrameType::P => write!(f, "P"),
FrameType::B => write!(f, "B"),
+ FrameType::Skip => write!(f, "skip"),
FrameType::Other => write!(f, "x"),
}
}
projects / nihav.git / blobdiff