nihav-core/src/scale/repack.rs

   1 use crate::formats::*;
   2 use super::*;
   3 use super::kernel::Kernel;
   4
   5 fn convert_depth(val: u32, indepth: u8, outdepth: u8) -> u32 {
   6     if indepth >= outdepth {
   7         val >> (indepth - outdepth)
   8     } else {
   9         let mut val2 = val << (outdepth - indepth);
  10         let mut shift = outdepth - indepth;
  11         while shift >= indepth {
  12             shift -= indepth;
  13             val2 |= val << shift;
  14         }
  15         if shift > 0 {
  16             val2 |= val >> (indepth - shift);
  17         }
  18         val2
  19     }
  20 }
  21
  22 #[derive(Default)]
  23 struct PackKernel {
  24     shifts: [u8;  MAX_CHROMATONS],
  25     depths: [u8;  MAX_CHROMATONS],
  26     ncomps: usize,
  27     osize:  [u8;  MAX_CHROMATONS],
  28     ooff:   [usize; MAX_CHROMATONS],
  29 }
  30
  31 impl PackKernel {
  32     fn new() -> Self { Self::default() }
  33 }
  34
  35 impl Kernel for PackKernel {
  36     fn init(&mut self, in_fmt: &ScaleInfo, dest_fmt: &ScaleInfo) -> ScaleResult<NABufferType> {
  37         self.ncomps = in_fmt.fmt.components as usize;
  38         for i in 0..self.ncomps {
  39             let ichr = in_fmt.fmt.comp_info[i].unwrap();
  40             let ochr = dest_fmt.fmt.comp_info[i].unwrap();
  41             self.shifts[i] = ochr.shift;
  42             self.osize[i] = ochr.depth;
  43             self.depths[i] = ichr.depth;
  44             self.ooff[i] = ochr.comp_offs as usize;
  45         }
  46         let res = alloc_video_buffer(NAVideoInfo::new(in_fmt.width, in_fmt.height, false, dest_fmt.fmt), 3);
  47         if res.is_err() { return Err(ScaleError::AllocError); }
  48         Ok(res.unwrap())
  49     }
  50     fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) {
  51         if let Some(ref buf) = pic_in.get_vbuf() {
  52             if let Some(ref mut dbuf) = pic_out.get_vbuf() {
  53                 let dstride = dbuf.get_stride(0);
  54                 for comp in 0..self.ncomps {
  55                     let ioff = buf.get_offset(comp);
  56                     let istride = buf.get_stride(comp);
  57                     let step = dbuf.get_info().get_format().get_chromaton(comp).unwrap().get_step() as usize;
  58                     let (w, h) = dbuf.get_dimensions(comp);
  59                     let sdata = buf.get_data();
  60                     let sdata = &sdata[ioff..];
  61                     let ddata = dbuf.get_data_mut().unwrap();
  62                     for (src, dst) in sdata.chunks(istride).zip(ddata.chunks_mut(dstride)).take(h) {
  63                         for x in 0..w {
  64                             dst[x * step + self.ooff[comp]] = convert_depth(u32::from(src[x]), self.depths[comp], self.osize[comp]) as u8;
  65                         }
  66                     }
  67                 }
  68             } else if let Some(ref mut dbuf) = pic_out.get_vbuf16() {
  69                 let (w, h) = dbuf.get_dimensions(0);
  70                 let dstride = dbuf.get_stride(0);
  71                 let ddata = dbuf.get_data_mut().unwrap();
  72                 let src = buf.get_data();
  73                 let mut ioff: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS];
  74                 let mut istride: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS];
  75                 for comp in 0..self.ncomps {
  76                     ioff[comp] = buf.get_offset(comp);
  77                     istride[comp] = buf.get_stride(comp);
  78                 }
  79                 for dst in ddata.chunks_mut(dstride).take(h) {
  80                     for x in 0..w {
  81                         let mut elem: u32 = 0;
  82                         for comp in 0..self.ncomps {
  83                             let c = u32::from(src[ioff[comp] + x]);
  84                             elem |= convert_depth(c, self.depths[comp], self.osize[comp]) << self.shifts[comp];
  85                         }
  86                         dst[x] = elem as u16;
  87                     }
  88                     for comp in 0..self.ncomps {
  89                         ioff[comp] += istride[comp];
  90                     }
  91                 }
  92             } else {
  93 unimplemented!();
  94             }
  95         } else if let Some(ref _buf) = pic_in.get_vbuf16() {
  96 unimplemented!();
  97         } else if let Some(ref _buf) = pic_in.get_vbuf32() {
  98 unimplemented!();
  99         } else {
 100             unreachable!();
 101         }
 102     }
 103 }
 104
 105 pub fn create_pack() -> Box<dyn Kernel> {
 106     Box::new(PackKernel::new())
 107 }
 108
 109 #[derive(Default)]
 110 struct UnpackKernel {
 111     shifts: [u8;  MAX_CHROMATONS],
 112     masks:  [u32; MAX_CHROMATONS],
 113     depths: [u8;  MAX_CHROMATONS],
 114     ncomps: usize,
 115     osize:  [u8;  MAX_CHROMATONS],
 116 }
 117
 118 impl UnpackKernel {
 119     fn new() -> Self { Self::default() }
 120 }
 121
 122 impl Kernel for UnpackKernel {
 123     fn init(&mut self, in_fmt: &ScaleInfo, dest_fmt: &ScaleInfo) -> ScaleResult<NABufferType> {
 124         self.ncomps = in_fmt.fmt.components as usize;
 125         let mut chr: Vec<Option<NAPixelChromaton>> = Vec::with_capacity(MAX_CHROMATONS);
 126         for i in 0..self.ncomps {
 127             let ichr = in_fmt.fmt.comp_info[i].unwrap();
 128             let ochr = dest_fmt.fmt.comp_info[i].unwrap();
 129             self.shifts[i] = ichr.shift;
 130             self.masks[i] = (1 << ichr.depth) - 1;
 131             if ochr.depth > ichr.depth {
 132                 self.osize[i] = ochr.depth;
 133             } else {
 134                 self.osize[i] = (ichr.depth + 7) & !7;
 135             }
 136             self.depths[i] = ichr.depth;
 137             let mut dchr = ichr;
 138             dchr.packed     = false;
 139             dchr.depth      = self.osize[i];
 140             dchr.shift      = 0;
 141             dchr.comp_offs  = 0;
 142             dchr.next_elem  = 0;
 143             chr.push(Some(dchr));
 144         }
 145         let mut df = in_fmt.fmt;
 146         for i in 0..self.ncomps {
 147             df.comp_info[i] = chr[i];
 148         }
 149         df.palette = false;
 150 println!(" [intermediate format {}]", df);
 151         let res = alloc_video_buffer(NAVideoInfo::new(in_fmt.width, in_fmt.height, false, df), 3);
 152         if res.is_err() { return Err(ScaleError::AllocError); }
 153         Ok(res.unwrap())
 154     }
 155     fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) {
 156         if let Some(ref buf) = pic_in.get_vbuf() {
 157             let step = buf.get_info().get_format().get_chromaton(0).unwrap().get_step() as usize;
 158             let mut soff: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS];
 159             for i in 0..self.ncomps {
 160                 soff[i] = buf.get_info().get_format().get_chromaton(i).unwrap().get_offset() as usize;
 161             }
 162             let (w, h) = buf.get_dimensions(0);
 163             let ioff = buf.get_offset(0);
 164             let istride = buf.get_stride(0);
 165             let sdata1 = buf.get_data();
 166             let sdata = &sdata1[ioff..];
 167             if let Some(ref mut dbuf) = pic_out.get_vbuf() {
 168                 let mut ostride: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS];
 169                 let mut offs: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS];
 170                 for i in 0..self.ncomps {
 171                     ostride[i] = dbuf.get_stride(i);
 172                     offs[i]    = dbuf.get_offset(i);
 173                 }
 174                 let dst = dbuf.get_data_mut().unwrap();
 175                 for src in sdata.chunks(istride).take(h) {
 176                     for x in 0..w {
 177                         for i in 0..self.ncomps {
 178                             dst[offs[i] + x] = src[x * step + soff[i]];
 179                         }
 180                     }
 181                     for i in 0..self.ncomps { offs[i] += ostride[i]; }
 182                 }
 183             } else {
 184 unimplemented!();
 185             }
 186         } else if let Some(ref buf) = pic_in.get_vbuf16() {
 187             let (w, h) = buf.get_dimensions(0);
 188             let ioff = buf.get_offset(0);
 189             let istride = buf.get_stride(0);
 190             let sdata1 = buf.get_data();
 191             let sdata = &sdata1[ioff..];
 192             if let Some(ref mut dbuf) = pic_out.get_vbuf() {
 193                 let mut ostride: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS];
 194                 let mut offs: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS];
 195                 for i in 0..self.ncomps {
 196                     ostride[i] = dbuf.get_stride(i);
 197                     offs[i]    = dbuf.get_offset(i);
 198                 }
 199                 let dst = dbuf.get_data_mut().unwrap();
 200                 for src in sdata.chunks(istride).take(h) {
 201                     for x in 0..w {
 202                         let elem = u32::from(src[x]);
 203                         for i in 0..self.ncomps {
 204                             dst[offs[i] + x] = convert_depth((elem >> self.shifts[i]) & self.masks[i], self.depths[i], self.osize[i]) as u8;
 205                         }
 206                     }
 207                     for i in 0..self.ncomps { offs[i] += ostride[i]; }
 208                 }
 209             } else {
 210 unimplemented!();
 211             }
 212         } else if let Some(ref _buf) = pic_in.get_vbuf32() {
 213 unimplemented!();
 214         } else {
 215             unreachable!();
 216         }
 217     }
 218 }
 219
 220 pub fn create_unpack() -> Box<dyn Kernel> {
 221     Box::new(UnpackKernel::new())
 222 }
 223
 224 #[derive(Default)]
 225 struct DepalKernel {
 226     depths:     [u8; MAX_CHROMATONS],
 227     coffs:      [usize; MAX_CHROMATONS],
 228     ncomps:     usize,
 229     palstep:    usize,
 230 }
 231
 232 impl DepalKernel {
 233     fn new() -> Self { Self::default() }
 234 }
 235
 236 impl Kernel for DepalKernel {
 237     fn init(&mut self, in_fmt: &ScaleInfo, _dest_fmt: &ScaleInfo) -> ScaleResult<NABufferType> {
 238 //todo select output more fitting for dest_fmt if possible
 239         self.ncomps = in_fmt.fmt.components as usize;
 240         let mut chr: Vec<Option<NAPixelChromaton>> = Vec::with_capacity(MAX_CHROMATONS);
 241         self.palstep = in_fmt.fmt.elem_size as usize;
 242         for i in 0..self.ncomps {
 243             let ichr = in_fmt.fmt.comp_info[i].unwrap();
 244             self.coffs[i]  = ichr.comp_offs as usize;
 245             self.depths[i] = ichr.depth;
 246             let mut dchr = ichr;
 247             dchr.packed     = false;
 248             dchr.depth      = 8;
 249             dchr.shift      = 0;
 250             dchr.comp_offs  = i as u8;
 251             dchr.next_elem  = 0;
 252             chr.push(Some(dchr));
 253         }
 254         let mut df = in_fmt.fmt;
 255         df.palette = false;
 256         for i in 0..self.ncomps {
 257             df.comp_info[i] = chr[i];
 258         }
 259 println!(" [intermediate format {}]", df);
 260         let res = alloc_video_buffer(NAVideoInfo::new(in_fmt.width, in_fmt.height, false, df), 3);
 261         if res.is_err() { return Err(ScaleError::AllocError); }
 262         Ok(res.unwrap())
 263     }
 264     fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) {
 265         if let (Some(ref sbuf), Some(ref mut dbuf)) = (pic_in.get_vbuf(), pic_out.get_vbuf()) {
 266             let ioff = sbuf.get_offset(0);
 267             let paloff = sbuf.get_offset(1);
 268             let (w, h) = sbuf.get_dimensions(0);
 269             let istride = sbuf.get_stride(0);
 270             let sdata1 = sbuf.get_data();
 271             let sdata = &sdata1[ioff..];
 272             let pal = &sdata1[paloff..];
 273
 274             let mut ostride: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS];
 275             let mut offs: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS];
 276             for i in 0..self.ncomps {
 277                 ostride[i] = dbuf.get_stride(i);
 278                 offs[i]    = dbuf.get_offset(i);
 279             }
 280             let dst = dbuf.get_data_mut().unwrap();
 281             for src in sdata.chunks(istride).take(h) {
 282                 for x in 0..w {
 283                     let palidx = src[x] as usize;
 284                     for i in 0..self.ncomps {
 285                         let elem = u32::from(pal[palidx * self.palstep + self.coffs[i]]);
 286                         dst[offs[i] + x] = convert_depth(elem, self.depths[i], 8) as u8;
 287                     }
 288                 }
 289                 for i in 0..self.ncomps { offs[i] += ostride[i]; }
 290             }
 291         } else {
 292             unreachable!();
 293         }
 294     }
 295 }
 296
 297 pub fn create_depal() -> Box<dyn Kernel> {
 298     Box::new(DepalKernel::new())
 299 }