src/frame.rs

   1 use std::collections::HashMap;
   2 use std::rc::Rc;
   3
   4 #[allow(dead_code)]
   5 #[derive(Copy,Clone)]
   6 pub struct NASoniton {
   7     bits:       u8,
   8     is_be:      bool,
   9     packed:     bool,
  10     planar:     bool,
  11     float:      bool,
  12 }
  13
  14 #[allow(dead_code)]
  15 pub const SND_U8_FORMAT: NASoniton = NASoniton { bits: 8, is_be: false, packed: false, planar: false, float: false };
  16 #[allow(dead_code)]
  17 pub const SND_S16_FORMAT: NASoniton = NASoniton { bits: 16, is_be: false, packed: false, planar: false, float: false };
  18
  19 #[allow(dead_code)]
  20 #[derive(Clone,Copy)]
  21 pub struct NAAudioInfo {
  22     sample_rate: u32,
  23     channels:    u8,
  24     format:      NASoniton,
  25     block_len:   usize,
  26 }
  27
  28 impl NAAudioInfo {
  29     pub fn new(sr: u32, ch: u8, fmt: NASoniton, bl: usize) -> Self {
  30         NAAudioInfo { sample_rate: sr, channels: ch, format: fmt, block_len: bl }
  31     }
  32 }
  33
  34 #[derive(Debug,Clone,Copy)]
  35 pub enum ColorModel {
  36     RGB,
  37     YUV,
  38     CMYK,
  39     HSV,
  40     LAB,
  41 }
  42
  43 #[allow(dead_code)]
  44 #[derive(Clone,Copy)]
  45 pub struct NAPixelChromaton {
  46     h_ss:           u8,
  47     v_ss:           u8,
  48     is_packed:      bool,
  49     depth:          u8,
  50     shift:          u8,
  51     comp_offs:      u8,
  52     next_elem:      u8,
  53 }
  54
  55 #[allow(dead_code)]
  56 #[derive(Clone,Copy)]
  57 pub struct NAPixelFormaton {
  58     model:      ColorModel,
  59     components: u8,
  60     comp_info:  [Option<NAPixelChromaton>; 5],
  61     elem_size:  u8,
  62     has_alpha:  bool,
  63     is_palette: bool,
  64 }
  65
  66 macro_rules! chromaton {
  67     ($hs: expr, $vs: expr, $pck: expr, $d: expr, $sh: expr, $co: expr, $ne: expr) => ({
  68         Some(NAPixelChromaton{ h_ss: $hs, v_ss: $vs, is_packed: $pck, depth: $d, shift: $sh, comp_offs: $co, next_elem: $ne })
  69     });
  70     (yuv8; $hs: expr, $vs: expr, $co: expr) => ({
  71         Some(NAPixelChromaton{ h_ss: $hs, v_ss: $vs, is_packed: false, depth: 8, shift: 0, comp_offs: $co, next_elem: 1 })
  72     });
  73     (pal8; $co: expr) => ({
  74         Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, is_packed: true, depth: 8, shift: 0, comp_offs: $co, next_elem: 3 })
  75     });
  76 }
  77
  78 #[allow(dead_code)]
  79 pub const YUV420_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::YUV, components: 3,
  80                                         comp_info: [
  81                                             chromaton!(0, 0, false, 8, 0, 0, 1),
  82                                             chromaton!(yuv8; 1, 1, 1),
  83                                             chromaton!(yuv8; 1, 1, 2),
  84                                             None, None],
  85                                         elem_size: 0, has_alpha: false, is_palette: false };
  86
  87 #[allow(dead_code)]
  88 pub const PAL8_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB, components: 3,
  89                                         comp_info: [
  90                                             chromaton!(pal8; 0),
  91                                             chromaton!(pal8; 1),
  92                                             chromaton!(pal8; 2),
  93                                             None, None],
  94                                         elem_size: 1, has_alpha: false, is_palette: true };
  95
  96
  97 #[allow(dead_code)]
  98 #[derive(Clone,Copy)]
  99 pub struct NAVideoInfo {
 100     width:      u32,
 101     height:     u32,
 102     flipped:    bool,
 103     format:     NAPixelFormaton,
 104 }
 105
 106 impl NAVideoInfo {
 107     pub fn new(w: u32, h: u32, flip: bool, fmt: NAPixelFormaton) -> Self {
 108         NAVideoInfo { width: w, height: h, flipped: flip, format: fmt }
 109     }
 110 }
 111
 112 #[derive(Clone,Copy)]
 113 pub enum NACodecTypeInfo {
 114     None,
 115     Audio(NAAudioInfo),
 116     Video(NAVideoInfo),
 117 }
 118
 119 #[allow(dead_code)]
 120 pub struct NABuffer<'a> {
 121     id:   u64,
 122     data: &'a mut [u8],
 123 }
 124
 125 #[allow(dead_code)]
 126 #[derive(Clone)]
 127 pub struct NACodecInfo {
 128     properties: NACodecTypeInfo,
 129     extradata:  Option<Rc<Vec<u8>>>,
 130 }
 131
 132 impl NACodecInfo {
 133     pub fn new(p: NACodecTypeInfo, edata: Option<Vec<u8>>) -> Self {
 134         let extradata = match edata {
 135             None => None,
 136             Some(vec) => Some(Rc::new(vec)),
 137         };
 138         NACodecInfo { properties: p, extradata: extradata }
 139     }
 140     pub fn get_properties(&self) -> NACodecTypeInfo { self.properties }
 141     pub fn get_extradata(&self) -> Option<Rc<Vec<u8>>> {
 142         if let Some(ref vec) = self.extradata { return Some(vec.clone()); }
 143         None
 144     }
 145 }
 146
 147 pub trait NABufferAllocator {
 148     fn alloc_buf(info: &NACodecInfo) -> NABuffer<'static>;
 149 }
 150
 151 #[derive(Debug)]
 152 pub enum NAValue<'a> {
 153     None,
 154     Int(i32),
 155     Long(i64),
 156     String(String),
 157     Data(&'a [u8]),
 158 }
 159
 160 #[allow(dead_code)]
 161 pub struct NAFrame<'a> {
 162     pts:            Option<u64>,
 163     dts:            Option<u64>,
 164     duration:       Option<u64>,
 165     buffer:         &'a mut NABuffer<'a>,
 166     info:           &'a NACodecInfo,
 167     options:        HashMap<String, NAValue<'a>>,
 168 }
 169
 170 #[allow(dead_code)]
 171 pub struct NACodecContext<'a> {
 172     info:           &'a NACodecInfo,
 173 }