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