]>
Commit | Line | Data |
---|---|---|
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 | df.comp_info[..self.ncomps].clone_from_slice(&chr[..self.ncomps]); | |
147 | df.palette = false; | |
148 | println!(" [intermediate format {}]", df); | |
149 | let res = alloc_video_buffer(NAVideoInfo::new(in_fmt.width, in_fmt.height, false, df), 3); | |
150 | if res.is_err() { return Err(ScaleError::AllocError); } | |
151 | Ok(res.unwrap()) | |
152 | } | |
153 | fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) { | |
154 | if let Some(ref buf) = pic_in.get_vbuf() { | |
155 | let step = buf.get_info().get_format().get_chromaton(0).unwrap().get_step() as usize; | |
156 | let mut soff: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS]; | |
157 | for i in 0..self.ncomps { | |
158 | soff[i] = buf.get_info().get_format().get_chromaton(i).unwrap().get_offset() as usize; | |
159 | } | |
160 | let (w, h) = buf.get_dimensions(0); | |
161 | let ioff = buf.get_offset(0); | |
162 | let istride = buf.get_stride(0); | |
163 | let sdata1 = buf.get_data(); | |
164 | let sdata = &sdata1[ioff..]; | |
165 | if let Some(ref mut dbuf) = pic_out.get_vbuf() { | |
166 | let mut ostride: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS]; | |
167 | let mut offs: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS]; | |
168 | for i in 0..self.ncomps { | |
169 | ostride[i] = dbuf.get_stride(i); | |
170 | offs[i] = dbuf.get_offset(i); | |
171 | } | |
172 | let dst = dbuf.get_data_mut().unwrap(); | |
173 | for src in sdata.chunks(istride).take(h) { | |
174 | for x in 0..w { | |
175 | for i in 0..self.ncomps { | |
176 | dst[offs[i] + x] = src[x * step + soff[i]]; | |
177 | } | |
178 | } | |
179 | for i in 0..self.ncomps { offs[i] += ostride[i]; } | |
180 | } | |
181 | } else { | |
182 | unimplemented!(); | |
183 | } | |
184 | } else if let Some(ref buf) = pic_in.get_vbuf16() { | |
185 | let (w, h) = buf.get_dimensions(0); | |
186 | let ioff = buf.get_offset(0); | |
187 | let istride = buf.get_stride(0); | |
188 | let sdata1 = buf.get_data(); | |
189 | let sdata = &sdata1[ioff..]; | |
190 | if let Some(ref mut dbuf) = pic_out.get_vbuf() { | |
191 | let mut ostride: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS]; | |
192 | let mut offs: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS]; | |
193 | for i in 0..self.ncomps { | |
194 | ostride[i] = dbuf.get_stride(i); | |
195 | offs[i] = dbuf.get_offset(i); | |
196 | } | |
197 | let dst = dbuf.get_data_mut().unwrap(); | |
198 | for src in sdata.chunks(istride).take(h) { | |
199 | for x in 0..w { | |
200 | let elem = u32::from(src[x]); | |
201 | for i in 0..self.ncomps { | |
202 | dst[offs[i] + x] = convert_depth((elem >> self.shifts[i]) & self.masks[i], self.depths[i], self.osize[i]) as u8; | |
203 | } | |
204 | } | |
205 | for i in 0..self.ncomps { offs[i] += ostride[i]; } | |
206 | } | |
207 | } else { | |
208 | unimplemented!(); | |
209 | } | |
210 | } else if let Some(ref _buf) = pic_in.get_vbuf32() { | |
211 | unimplemented!(); | |
212 | } else { | |
213 | unreachable!(); | |
214 | } | |
215 | } | |
216 | } | |
217 | ||
218 | pub fn create_unpack() -> Box<dyn Kernel> { | |
219 | Box::new(UnpackKernel::new()) | |
220 | } | |
221 | ||
222 | #[derive(Default)] | |
223 | struct DepalKernel { | |
224 | depths: [u8; MAX_CHROMATONS], | |
225 | coffs: [usize; MAX_CHROMATONS], | |
226 | ncomps: usize, | |
227 | palstep: usize, | |
228 | } | |
229 | ||
230 | impl DepalKernel { | |
231 | fn new() -> Self { Self::default() } | |
232 | } | |
233 | ||
234 | impl Kernel for DepalKernel { | |
235 | fn init(&mut self, in_fmt: &ScaleInfo, _dest_fmt: &ScaleInfo) -> ScaleResult<NABufferType> { | |
236 | //todo select output more fitting for dest_fmt if possible | |
237 | self.ncomps = in_fmt.fmt.components as usize; | |
238 | let mut chr: Vec<Option<NAPixelChromaton>> = Vec::with_capacity(MAX_CHROMATONS); | |
239 | self.palstep = in_fmt.fmt.elem_size as usize; | |
240 | for i in 0..self.ncomps { | |
241 | let ichr = in_fmt.fmt.comp_info[i].unwrap(); | |
242 | self.coffs[i] = ichr.comp_offs as usize; | |
243 | self.depths[i] = ichr.depth; | |
244 | let mut dchr = ichr; | |
245 | dchr.packed = false; | |
246 | dchr.depth = 8; | |
247 | dchr.shift = 0; | |
248 | dchr.comp_offs = i as u8; | |
249 | dchr.next_elem = 0; | |
250 | chr.push(Some(dchr)); | |
251 | } | |
252 | let mut df = in_fmt.fmt; | |
253 | df.palette = false; | |
254 | df.comp_info[..self.ncomps].clone_from_slice(&chr[..self.ncomps]); | |
255 | println!(" [intermediate format {}]", df); | |
256 | let res = alloc_video_buffer(NAVideoInfo::new(in_fmt.width, in_fmt.height, false, df), 3); | |
257 | if res.is_err() { return Err(ScaleError::AllocError); } | |
258 | Ok(res.unwrap()) | |
259 | } | |
260 | fn process(&mut self, pic_in: &NABufferType, pic_out: &mut NABufferType) { | |
261 | if let (Some(ref sbuf), Some(ref mut dbuf)) = (pic_in.get_vbuf(), pic_out.get_vbuf()) { | |
262 | let ioff = sbuf.get_offset(0); | |
263 | let paloff = sbuf.get_offset(1); | |
264 | let (w, h) = sbuf.get_dimensions(0); | |
265 | let istride = sbuf.get_stride(0); | |
266 | let sdata1 = sbuf.get_data(); | |
267 | let sdata = &sdata1[ioff..]; | |
268 | let pal = &sdata1[paloff..]; | |
269 | ||
270 | let mut ostride: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS]; | |
271 | let mut offs: [usize; MAX_CHROMATONS] = [0; MAX_CHROMATONS]; | |
272 | for i in 0..self.ncomps { | |
273 | ostride[i] = dbuf.get_stride(i); | |
274 | offs[i] = dbuf.get_offset(i); | |
275 | } | |
276 | let dst = dbuf.get_data_mut().unwrap(); | |
277 | for src in sdata.chunks(istride).take(h) { | |
278 | for x in 0..w { | |
279 | let palidx = src[x] as usize; | |
280 | for i in 0..self.ncomps { | |
281 | let elem = u32::from(pal[palidx * self.palstep + self.coffs[i]]); | |
282 | dst[offs[i] + x] = convert_depth(elem, self.depths[i], 8) as u8; | |
283 | } | |
284 | } | |
285 | for i in 0..self.ncomps { offs[i] += ostride[i]; } | |
286 | } | |
287 | } else { | |
288 | unreachable!(); | |
289 | } | |
290 | } | |
291 | } | |
292 | ||
293 | pub fn create_depal() -> Box<dyn Kernel> { | |
294 | Box::new(DepalKernel::new()) | |
295 | } |