X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;ds=inline;f=nihav-core%2Fsrc%2Fframe.rs;h=af7b498e92811b1acd1c3697482b32e14aacd46f;hb=01613464323864a655c994820d3c43df1954e3b2;hp=d97850b7c7b59cd5a8f9d28975f10f842e0cee7d;hpb=70910ac3fdc02c7b7727a4a294f55134e9f5141d;p=nihav.git

diff --git a/nihav-core/src/frame.rs b/nihav-core/src/frame.rs
index d97850b..af7b498 100644
--- a/nihav-core/src/frame.rs
+++ b/nihav-core/src/frame.rs
@@ -1,8 +1,6 @@
 use std::cmp::max;
 use std::collections::HashMap;
 use std::fmt;
-pub use std::rc::Rc;
-pub use std::cell::*;
 use std::sync::Arc;
 pub use crate::formats::*;
 pub use crate::refs::*;
@@ -136,8 +134,13 @@ impl<T: Clone> NAVideoBuffer<T> {
     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,
@@ -175,10 +178,10 @@ impl NAAudioBuffer<u8> {
 
 #[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>),
@@ -211,20 +214,20 @@ impl NABufferType {
             _ => 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,
@@ -352,7 +355,7 @@ pub fn alloc_video_buffer(vinfo: NAVideoInfo, align: u8) -> Result<NABufferType,
         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);
@@ -377,17 +380,17 @@ pub fn alloc_video_buffer(vinfo: NAVideoInfo, align: u8) -> Result<NABufferType,
             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();
@@ -400,7 +403,7 @@ pub fn alloc_video_buffer(vinfo: NAVideoInfo, align: u8) -> Result<NABufferType,
         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);
@@ -412,14 +415,14 @@ pub fn alloc_video_buffer(vinfo: NAVideoInfo, align: u8) -> Result<NABufferType,
                     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!(),
         }
@@ -481,49 +484,89 @@ pub fn copy_buffer(buf: NABufferType) -> NABufferType {
     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(())
     }
 }
 
@@ -653,7 +696,7 @@ pub struct NAFrame {
     options:        HashMap<String, NAValue>,
 }
 
-pub type NAFrameRef = Rc<RefCell<NAFrame>>;
+pub type NAFrameRef = Arc<NAFrame>;
 
 fn get_plane_size(info: &NAVideoInfo, idx: usize) -> (usize, usize) {
     let chromaton = info.get_format().get_chromaton(idx);
@@ -687,6 +730,8 @@ impl NAFrame {
     pub fn set_duration(&mut self, dur: Option<u64>) { self.ts.set_duration(dur); }
 
     pub fn get_buffer(&self) -> NABufferType { self.buffer.clone() }
+
+    pub fn into_ref(self) -> NAFrameRef { Arc::new(self) }
 }
 
 impl fmt::Display for NAFrame {