pub fn get_dimensions(&self, idx: usize) -> (usize, usize) {
get_plane_size(&self.info, idx)
}
+ pub fn into_ref(self) -> NABufferRef<Self> {
+ NABufferRef::new(self)
+ }
}
+pub type NAVideoBufferRef<T> = NABufferRef<NAVideoBuffer<T>>;
+
#[derive(Clone)]
pub struct NAAudioBuffer<T> {
info: NAAudioInfo,
#[derive(Clone)]
pub enum NABufferType {
- Video (NAVideoBuffer<u8>),
- Video16 (NAVideoBuffer<u16>),
- Video32 (NAVideoBuffer<u32>),
- VideoPacked(NAVideoBuffer<u8>),
+ Video (NAVideoBufferRef<u8>),
+ Video16 (NAVideoBufferRef<u16>),
+ Video32 (NAVideoBufferRef<u32>),
+ VideoPacked(NAVideoBufferRef<u8>),
AudioU8 (NAAudioBuffer<u8>),
AudioI16 (NAAudioBuffer<i16>),
AudioI32 (NAAudioBuffer<i32>),
_ => None,
}
}
- pub fn get_vbuf(&self) -> Option<NAVideoBuffer<u8>> {
+ pub fn get_vbuf(&self) -> Option<NAVideoBufferRef<u8>> {
match *self {
NABufferType::Video(ref vb) => Some(vb.clone()),
NABufferType::VideoPacked(ref vb) => Some(vb.clone()),
_ => None,
}
}
- pub fn get_vbuf16(&self) -> Option<NAVideoBuffer<u16>> {
+ pub fn get_vbuf16(&self) -> Option<NAVideoBufferRef<u16>> {
match *self {
NABufferType::Video16(ref vb) => Some(vb.clone()),
_ => None,
}
}
- pub fn get_vbuf32(&self) -> Option<NAVideoBuffer<u32>> {
+ pub fn get_vbuf32(&self) -> Option<NAVideoBufferRef<u32>> {
match *self {
NABufferType::Video32(ref vb) => Some(vb.clone()),
_ => None,
let mut data: Vec<u8> = Vec::with_capacity(new_size.unwrap());
data.resize(new_size.unwrap(), 0);
let buf: NAVideoBuffer<u8> = NAVideoBuffer { data: NABufferRef::new(data), info: vinfo, offs: offs, strides: strides };
- Ok(NABufferType::Video(buf))
+ Ok(NABufferType::Video(buf.into_ref()))
} else if !all_packed {
for i in 0..fmt.get_num_comp() {
let ochr = fmt.get_chromaton(i);
let mut data: Vec<u8> = Vec::with_capacity(new_size);
data.resize(new_size, 0);
let buf: NAVideoBuffer<u8> = NAVideoBuffer { data: NABufferRef::new(data), info: vinfo, offs: offs, strides: strides };
- Ok(NABufferType::Video(buf))
+ Ok(NABufferType::Video(buf.into_ref()))
} else if max_depth <= 16 {
let mut data: Vec<u16> = Vec::with_capacity(new_size);
data.resize(new_size, 0);
let buf: NAVideoBuffer<u16> = NAVideoBuffer { data: NABufferRef::new(data), info: vinfo, offs: offs, strides: strides };
- Ok(NABufferType::Video16(buf))
+ Ok(NABufferType::Video16(buf.into_ref()))
} else {
let mut data: Vec<u32> = Vec::with_capacity(new_size);
data.resize(new_size, 0);
let buf: NAVideoBuffer<u32> = NAVideoBuffer { data: NABufferRef::new(data), info: vinfo, offs: offs, strides: strides };
- Ok(NABufferType::Video32(buf))
+ Ok(NABufferType::Video32(buf.into_ref()))
}
} else if all_bytealigned || unfit_elem_size {
let elem_sz = fmt.get_elem_size();
data.resize(new_size, 0);
strides.push(line_sz.unwrap());
let buf: NAVideoBuffer<u8> = NAVideoBuffer { data: NABufferRef::new(data), info: vinfo, offs: offs, strides: strides };
- Ok(NABufferType::VideoPacked(buf))
+ Ok(NABufferType::VideoPacked(buf.into_ref()))
} else {
let elem_sz = fmt.get_elem_size();
let new_sz = width.checked_mul(height);
data.resize(new_size, 0);
strides.push(width);
let buf: NAVideoBuffer<u16> = NAVideoBuffer { data: NABufferRef::new(data), info: vinfo, offs: offs, strides: strides };
- Ok(NABufferType::Video16(buf))
+ Ok(NABufferType::Video16(buf.into_ref()))
},
4 => {
let mut data: Vec<u32> = Vec::with_capacity(new_size);
data.resize(new_size, 0);
strides.push(width);
let buf: NAVideoBuffer<u32> = NAVideoBuffer { data: NABufferRef::new(data), info: vinfo, offs: offs, strides: strides };
- Ok(NABufferType::Video32(buf))
+ Ok(NABufferType::Video32(buf.into_ref()))
},
_ => unreachable!(),
}
buf.clone()
}
-pub struct NABufferPool {
- pool: Vec<NABufferRef<NABufferType>>,
+pub struct NAVideoBufferPool<T:Copy> {
+ pool: Vec<NAVideoBufferRef<T>>,
max_len: usize,
+ add_len: usize,
}
-impl NABufferPool {
+impl<T:Copy> NAVideoBufferPool<T> {
pub fn new(max_len: usize) -> Self {
Self {
pool: Vec::with_capacity(max_len),
max_len,
+ add_len: 0,
+ }
+ }
+ pub fn set_dec_bufs(&mut self, add_len: usize) {
+ self.add_len = add_len;
+ }
+ pub fn get_free(&mut self) -> Option<NAVideoBufferRef<T>> {
+ for e in self.pool.iter() {
+ if e.get_num_refs() == 1 {
+ return Some(e.clone());
+ }
}
+ None
+ }
+ pub fn get_copy(&mut self, rbuf: &NAVideoBufferRef<T>) -> Option<NAVideoBufferRef<T>> {
+ let res = self.get_free();
+ if res.is_none() {
+ return None;
+ }
+ let mut dbuf = res.unwrap();
+ dbuf.data.copy_from_slice(&rbuf.data);
+ Some(dbuf)
+ }
+ pub fn reset(&mut self) {
+ self.pool.truncate(0);
}
+}
+
+impl NAVideoBufferPool<u8> {
pub fn prealloc_video(&mut self, vinfo: NAVideoInfo, align: u8) -> Result<(), AllocatorError> {
- let nbufs = self.max_len - self.pool.len();
+ let nbufs = self.max_len + self.add_len - self.pool.len();
for _ in 0..nbufs {
- let buf = alloc_video_buffer(vinfo.clone(), align)?;
- self.pool.push(NABufferRef::new(buf));
+ let vbuf = alloc_video_buffer(vinfo.clone(), align)?;
+ if let NABufferType::Video(buf) = vbuf {
+ self.pool.push(buf);
+ } else if let NABufferType::VideoPacked(buf) = vbuf {
+ self.pool.push(buf);
+ } else {
+ return Err(AllocatorError::FormatError);
+ }
}
Ok(())
}
- pub fn prealloc_audio(&mut self, ainfo: NAAudioInfo, nsamples: usize, chmap: NAChannelMap) -> Result<(), AllocatorError> {
- let nbufs = self.max_len - self.pool.len();
+}
+
+impl NAVideoBufferPool<u16> {
+ pub fn prealloc_video(&mut self, vinfo: NAVideoInfo, align: u8) -> Result<(), AllocatorError> {
+ let nbufs = self.max_len + self.add_len - self.pool.len();
for _ in 0..nbufs {
- let buf = alloc_audio_buffer(ainfo.clone(), nsamples, chmap.clone())?;
- self.pool.push(NABufferRef::new(buf));
+ let vbuf = alloc_video_buffer(vinfo.clone(), align)?;
+ if let NABufferType::Video16(buf) = vbuf {
+ self.pool.push(buf);
+ } else {
+ return Err(AllocatorError::FormatError);
+ }
}
Ok(())
}
- pub fn add(&mut self, buf: NABufferType) -> bool {
- if self.pool.len() < self.max_len {
- self.pool.push(NABufferRef::new(buf));
- true
- } else {
- false
- }
- }
- pub fn get_free(&mut self) -> Option<NABufferRef<NABufferType>> {
- for e in self.pool.iter() {
- if e.get_num_refs() == 1 {
- return Some(e.clone());
+}
+
+impl NAVideoBufferPool<u32> {
+ pub fn prealloc_video(&mut self, vinfo: NAVideoInfo, align: u8) -> Result<(), AllocatorError> {
+ let nbufs = self.max_len + self.add_len - self.pool.len();
+ for _ in 0..nbufs {
+ let vbuf = alloc_video_buffer(vinfo.clone(), align)?;
+ if let NABufferType::Video32(buf) = vbuf {
+ self.pool.push(buf);
+ } else {
+ return Err(AllocatorError::FormatError);
}
}
- None
+ Ok(())
}
}
projects / nihav.git / blobdiff