| 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::cognitive_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 | } |