]>
Commit | Line | Data |
---|---|---|
1 | use nihav_core::codecs::*; | |
2 | use nihav_core::io::byteio::*; | |
3 | use nihav_codec_support::codecs::HAMShuffler; | |
4 | ||
5 | struct SmcDecoder { | |
6 | info: NACodecInfoRef, | |
7 | hams: HAMShuffler<u8>, | |
8 | width: usize, | |
9 | height: usize, | |
10 | pairs: [[u8; 2]; 256], | |
11 | quads: [[u8; 4]; 256], | |
12 | octets: [[u8; 8]; 256], | |
13 | } | |
14 | ||
15 | impl SmcDecoder { | |
16 | fn new() -> Self { | |
17 | Self { | |
18 | info: NACodecInfoRef::default(), | |
19 | hams: HAMShuffler::default(), | |
20 | width: 0, | |
21 | height: 0, | |
22 | pairs: [[0; 2]; 256], | |
23 | quads: [[0; 4]; 256], | |
24 | octets: [[0; 8]; 256], | |
25 | } | |
26 | } | |
27 | fn put_block(dst: &mut [u8], dstride: usize, block: &[u8; 16]) { | |
28 | for (line, src) in dst.chunks_mut(dstride).take(4).zip(block.chunks(4)) { | |
29 | (&mut line[..4]).copy_from_slice(src); | |
30 | } | |
31 | } | |
32 | fn put_blocks(&self, dst: &mut [u8], stride: usize, doff: &mut usize, x: &mut usize, len: usize, block: &[u8; 16]) { | |
33 | for _ in 0..len { | |
34 | Self::put_block(&mut dst[*doff + *x..], stride, block); | |
35 | *x += 4; | |
36 | if *x == self.width { | |
37 | *x = 0; | |
38 | *doff += stride * 4; | |
39 | } | |
40 | ||
41 | } | |
42 | } | |
43 | } | |
44 | ||
45 | impl NADecoder for SmcDecoder { | |
46 | fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> { | |
47 | if let NACodecTypeInfo::Video(vinfo) = info.get_properties() { | |
48 | self.width = (vinfo.get_width() + 3) & !3; | |
49 | self.height = (vinfo.get_height() + 3) & !3; | |
50 | let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(self.width, self.height, false, PAL8_FORMAT)); | |
51 | self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref(); | |
52 | ||
53 | Ok(()) | |
54 | } else { | |
55 | Err(DecoderError::InvalidData) | |
56 | } | |
57 | } | |
58 | #[allow(clippy::cyclomatic_complexity)] | |
59 | fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> { | |
60 | let src = pkt.get_buffer(); | |
61 | validate!(src.len() >= 2); | |
62 | let mut mr = MemoryReader::new_read(src.as_slice()); | |
63 | let mut br = ByteReader::new(&mut mr); | |
64 | ||
65 | let id = br.read_byte()?; | |
66 | validate!(id == 0x80); | |
67 | let length = br.read_u24be()? as usize; | |
68 | validate!(length == src.len()); | |
69 | ||
70 | let bufret = self.hams.clone_ref(); | |
71 | let mut buf; | |
72 | if let Some(bbuf) = bufret { | |
73 | buf = bbuf; | |
74 | } else { | |
75 | let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 2)?; | |
76 | buf = bufinfo.get_vbuf().unwrap(); | |
77 | self.hams.add_frame(buf); | |
78 | buf = self.hams.get_output_frame().unwrap(); | |
79 | } | |
80 | let frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap(); | |
81 | let stride = frm.stride[0]; | |
82 | let mut doff = frm.offset[0]; | |
83 | ||
84 | self.pairs = [[0; 2]; 256]; | |
85 | self.quads = [[0; 4]; 256]; | |
86 | self.octets = [[0; 8]; 256]; | |
87 | ||
88 | let mut x = 0; | |
89 | let nblocks = (self.width / 4) * (self.height / 4); | |
90 | let mut blockpos = 0; | |
91 | let mut pair_idx = 0; | |
92 | let mut quad_idx = 0; | |
93 | let mut oct_idx = 0; | |
94 | let mut has_skips = false; | |
95 | let mut block = [0u8; 16]; | |
96 | let mut lblock = [0u8; 16]; | |
97 | let mut llblock = [0u8; 16]; | |
98 | while blockpos < nblocks { | |
99 | let opcode = br.read_byte()?; | |
100 | let ext_opcode = (opcode & 0x10) != 0; | |
101 | let len = if !ext_opcode || (opcode >= 0x80) { | |
102 | ((opcode & 0xF) as usize) + 1 | |
103 | } else { | |
104 | (br.read_byte()? as usize) + 1 | |
105 | }; | |
106 | validate!(blockpos + len <= nblocks); | |
107 | match opcode >> 5 { | |
108 | 0 => { | |
109 | has_skips = true; | |
110 | for _ in 0..len { | |
111 | x += 4; | |
112 | if x == self.width { | |
113 | x = 0; | |
114 | doff += stride * 4; | |
115 | } | |
116 | } | |
117 | }, | |
118 | 1 => { | |
119 | self.put_blocks(frm.data, stride, &mut doff, &mut x, len, &lblock); | |
120 | llblock = lblock; | |
121 | }, | |
122 | 2 => { | |
123 | for i in 0..len { | |
124 | if (i & 1) == 0 { | |
125 | Self::put_block(&mut frm.data[doff + x..], stride, &llblock); | |
126 | } else { | |
127 | Self::put_block(&mut frm.data[doff + x..], stride, &lblock); | |
128 | } | |
129 | x += 4; | |
130 | if x == self.width { | |
131 | x = 0; | |
132 | doff += stride * 4; | |
133 | } | |
134 | } | |
135 | }, | |
136 | 3 => { | |
137 | let clr = br.read_byte()?; | |
138 | block = [clr; 16]; | |
139 | self.put_blocks(frm.data, stride, &mut doff, &mut x, len, &block); | |
140 | if len > 1 { | |
141 | llblock = block; | |
142 | } else { | |
143 | llblock = lblock; | |
144 | } | |
145 | lblock = block; | |
146 | }, | |
147 | 4 => { | |
148 | let clr; | |
149 | if !ext_opcode { | |
150 | br.read_buf(&mut self.pairs[pair_idx])?; | |
151 | clr = self.pairs[pair_idx]; | |
152 | pair_idx = (pair_idx + 1) & 0xFF; | |
153 | } else { | |
154 | let idx = br.read_byte()? as usize; | |
155 | clr = self.pairs[idx]; | |
156 | } | |
157 | for _ in 0..len { | |
158 | let flags = br.read_u16be()? as usize; | |
159 | for i in 0..16 { | |
160 | block[i] = clr[(flags >> (15 - i)) & 1]; | |
161 | } | |
162 | Self::put_block(&mut frm.data[doff + x..], stride, &block); | |
163 | x += 4; | |
164 | if x == self.width { | |
165 | x = 0; | |
166 | doff += stride * 4; | |
167 | } | |
168 | llblock = lblock; | |
169 | lblock = block; | |
170 | } | |
171 | }, | |
172 | 5 => { | |
173 | let clr; | |
174 | if !ext_opcode { | |
175 | br.read_buf(&mut self.quads[quad_idx])?; | |
176 | clr = self.quads[quad_idx]; | |
177 | quad_idx = (quad_idx + 1) & 0xFF; | |
178 | } else { | |
179 | let idx = br.read_byte()? as usize; | |
180 | clr = self.quads[idx]; | |
181 | } | |
182 | for _ in 0..len { | |
183 | let flags = br.read_u32be()? as usize; | |
184 | for i in 0..16 { | |
185 | block[i] = clr[(flags >> (30 - i * 2)) & 3]; | |
186 | } | |
187 | Self::put_block(&mut frm.data[doff + x..], stride, &block); | |
188 | x += 4; | |
189 | if x == self.width { | |
190 | x = 0; | |
191 | doff += stride * 4; | |
192 | } | |
193 | llblock = lblock; | |
194 | lblock = block; | |
195 | } | |
196 | }, | |
197 | 6 => { | |
198 | let clr; | |
199 | if !ext_opcode { | |
200 | br.read_buf(&mut self.octets[oct_idx])?; | |
201 | clr = self.octets[oct_idx]; | |
202 | oct_idx = (oct_idx + 1) & 0xFF; | |
203 | } else { | |
204 | let idx = br.read_byte()? as usize; | |
205 | clr = self.octets[idx]; | |
206 | } | |
207 | for _ in 0..len { | |
208 | let flg0 = br.read_u16be()? as usize; | |
209 | let flg1 = br.read_u16be()? as usize; | |
210 | let flg2 = br.read_u16be()? as usize; | |
211 | ||
212 | let line0 = flg0 >> 4; | |
213 | let line1 = flg1 >> 4; | |
214 | let line2 = flg2 >> 4; | |
215 | let line3 = ((flg0 & 0xF) << 8) | ((flg1 & 0xF) << 4) | (flg2 & 0xF); | |
216 | let flags = [line0, line1, line2, line3]; | |
217 | for j in 0..4 { | |
218 | let flg = flags[j]; | |
219 | for i in 0..4 { | |
220 | block[i + j * 4] = clr[(flg >> (9 - i * 3)) & 7]; | |
221 | } | |
222 | } | |
223 | Self::put_block(&mut frm.data[doff + x..], stride, &block); | |
224 | x += 4; | |
225 | if x == self.width { | |
226 | x = 0; | |
227 | doff += stride * 4; | |
228 | } | |
229 | llblock = lblock; | |
230 | lblock = block; | |
231 | } | |
232 | }, | |
233 | _ => { | |
234 | validate!((opcode & 0xF0) != 0xF0); | |
235 | for _ in 0..len { | |
236 | br.read_buf(&mut block)?; | |
237 | Self::put_block(&mut frm.data[doff + x..], stride, &block); | |
238 | x += 4; | |
239 | if x == self.width { | |
240 | x = 0; | |
241 | doff += stride * 4; | |
242 | } | |
243 | llblock = lblock; | |
244 | lblock = block; | |
245 | } | |
246 | }, | |
247 | }; | |
248 | blockpos += len; | |
249 | } | |
250 | ||
251 | let paloff = frm.offset[1]; | |
252 | let dpal = &mut frm.data[paloff..]; | |
253 | for sd in pkt.side_data.iter() { | |
254 | match *sd { | |
255 | NASideData::Palette(_, ref pal) => { | |
256 | for (dst, src) in dpal.chunks_mut(3).zip(pal.chunks(4)) { | |
257 | dst[0] = src[0]; | |
258 | dst[1] = src[1]; | |
259 | dst[2] = src[2]; | |
260 | } | |
261 | break; | |
262 | }, | |
263 | _ => {}, | |
264 | }; | |
265 | } | |
266 | let buftype = NABufferType::Video(buf); | |
267 | ||
268 | let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buftype); | |
269 | frm.set_keyframe(!has_skips); | |
270 | frm.set_frame_type(if !has_skips { FrameType::I } else { FrameType::P }); | |
271 | Ok(frm.into_ref()) | |
272 | } | |
273 | fn flush(&mut self) { | |
274 | self.hams.clear(); | |
275 | } | |
276 | } | |
277 | ||
278 | impl NAOptionHandler for SmcDecoder { | |
279 | fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } | |
280 | fn set_options(&mut self, _options: &[NAOption]) { } | |
281 | fn query_option_value(&self, _name: &str) -> Option<NAValue> { None } | |
282 | } | |
283 | ||
284 | pub fn get_decoder() -> Box<dyn NADecoder + Send> { | |
285 | Box::new(SmcDecoder::new()) | |
286 | } | |
287 | ||
288 | #[cfg(test)] | |
289 | mod test { | |
290 | use nihav_core::codecs::RegisteredDecoders; | |
291 | use nihav_core::demuxers::RegisteredDemuxers; | |
292 | use nihav_codec_support::test::dec_video::*; | |
293 | use crate::qt_register_all_decoders; | |
294 | use nihav_commonfmt::generic_register_all_demuxers; | |
295 | #[test] | |
296 | fn test_smc() { | |
297 | let mut dmx_reg = RegisteredDemuxers::new(); | |
298 | generic_register_all_demuxers(&mut dmx_reg); | |
299 | let mut dec_reg = RegisteredDecoders::new(); | |
300 | qt_register_all_decoders(&mut dec_reg); | |
301 | ||
302 | test_decoding("mov", "qt-smc", "assets/QT/aletrek-smc.mov", Some(6), &dmx_reg, &dec_reg, | |
303 | ExpectedTestResult::MD5Frames(vec![ | |
304 | [0x4ea351ee, 0x279beedd, 0x71738173, 0x0fba61e8], | |
305 | [0x2c5ea61c, 0x1f539c55, 0x9234aa95, 0xd60be3ef], | |
306 | [0x307955c9, 0x0bc6d4cb, 0x7bebef1e, 0x5f2f3aee], | |
307 | [0x00db3e90, 0x9f57baef, 0x23e6c43b, 0xe9d6dc44], | |
308 | [0x54f2e3eb, 0x6313a0df, 0xb4b52777, 0x10f020f0], | |
309 | [0xdefb0b7d, 0xbdaa77c8, 0xb053d60c, 0xe836b9b0], | |
310 | [0xb820f95b, 0x0ce11d8a, 0xcfd8f623, 0x2b3acb1d]])); | |
311 | } | |
312 | #[test] | |
313 | fn test_smc_gray() { | |
314 | let mut dmx_reg = RegisteredDemuxers::new(); | |
315 | generic_register_all_demuxers(&mut dmx_reg); | |
316 | let mut dec_reg = RegisteredDecoders::new(); | |
317 | qt_register_all_decoders(&mut dec_reg); | |
318 | ||
319 | test_decoding("mov", "qt-smc", "assets/QT/aletrek-smc-gray.mov", Some(6), &dmx_reg, &dec_reg, | |
320 | ExpectedTestResult::MD5Frames(vec![ | |
321 | [0x72e87d61, 0x85cde631, 0x780eea35, 0x7dfb8dfb], | |
322 | [0xc41fa1a8, 0x1f038e2e, 0xd67189fd, 0x566e74a8], | |
323 | [0xc2d8e57f, 0x501c5618, 0xdd6cd85a, 0x2c05f0b0], | |
324 | [0x7d530e44, 0xf02646d6, 0xbab960d0, 0x39ea2344], | |
325 | [0x46a2d3dc, 0x93684f3e, 0x88102523, 0x02d19236], | |
326 | [0x78995cd8, 0x3fbcbba2, 0x692d6e19, 0x25334ed0], | |
327 | [0x9632de1a, 0xccbe20a8, 0x4cc5fabe, 0x4dadddbe]])); | |
328 | } | |
329 | } |