| 1 | use nihav_core::codecs::*; |
| 2 | use nihav_core::io::byteio::*; |
| 3 | use nihav_codec_support::codecs::HAMShuffler; |
| 4 | |
| 5 | const RGB555_FORMAT: NAPixelFormaton = NAPixelFormaton { |
| 6 | model: ColorModel::RGB(RGBSubmodel::RGB), components: 3, |
| 7 | comp_info: [ |
| 8 | Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 10, comp_offs: 0, next_elem: 2 }), |
| 9 | Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 5, comp_offs: 0, next_elem: 2 }), |
| 10 | Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 0, comp_offs: 0, next_elem: 2 }), |
| 11 | None, None], |
| 12 | elem_size: 2, be: false, alpha: false, palette: false }; |
| 13 | |
| 14 | pub const ARGB_FORMAT: NAPixelFormaton = NAPixelFormaton { |
| 15 | model: ColorModel::RGB(RGBSubmodel::RGB), components: 4, |
| 16 | comp_info: [ |
| 17 | Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 4 }), |
| 18 | Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 4 }), |
| 19 | Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 3, next_elem: 4 }), |
| 20 | Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 4 }), |
| 21 | None ], |
| 22 | elem_size: 4, be: false, alpha: true, palette: false }; |
| 23 | |
| 24 | #[derive(Default)] |
| 25 | struct RleDecoder { |
| 26 | info: NACodecInfoRef, |
| 27 | hams: HAMShuffler<u8>, |
| 28 | hams16: HAMShuffler<u16>, |
| 29 | width: usize, |
| 30 | height: usize, |
| 31 | depth: u8, |
| 32 | } |
| 33 | |
| 34 | #[allow(clippy::needless_range_loop)] |
| 35 | fn unpack_mono(src: u16, dst: &mut [u8; 16]) { |
| 36 | for i in 0..16 { |
| 37 | dst[i] = ((src >> (15 - i)) & 1) as u8; |
| 38 | } |
| 39 | } |
| 40 | |
| 41 | #[allow(clippy::needless_range_loop)] |
| 42 | fn unpack_pixels(src: u32, dst: &mut [u8; 16], depth: u8) { |
| 43 | let depth = depth as usize; |
| 44 | let mask = (1 << depth) - 1; |
| 45 | for i in 0..32 / depth { |
| 46 | dst[i] = ((src >> (32 - depth - i * depth)) & mask) as u8; |
| 47 | } |
| 48 | } |
| 49 | |
| 50 | impl RleDecoder { |
| 51 | fn new() -> Self { |
| 52 | Self::default() |
| 53 | } |
| 54 | fn decode_mono(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u8>, start_line: usize, end_line: usize) -> DecoderResult<bool> { |
| 55 | let mut has_skips = false; |
| 56 | let mut pix_buf = [0u8; 16]; |
| 57 | let npixels = 16; |
| 58 | |
| 59 | let stride = frm.stride[0]; |
| 60 | let mut doff = frm.offset[0] + start_line * stride; |
| 61 | let mut y = start_line; |
| 62 | while y < end_line { |
| 63 | let mut x = 0; |
| 64 | while x < self.width { |
| 65 | let skip_code = br.read_byte()?; |
| 66 | let rle_code = br.read_byte()? as i8; |
| 67 | if x == 0 { |
| 68 | validate!((skip_code & 0x80) != 0); |
| 69 | } |
| 70 | if rle_code == 0 { |
| 71 | return Ok(false); |
| 72 | } |
| 73 | if x != 0 && (skip_code & 0x80) != 0 { |
| 74 | x = 0; |
| 75 | y += 1; |
| 76 | validate!(y < end_line); |
| 77 | doff += stride; |
| 78 | has_skips = true; |
| 79 | } |
| 80 | let skip = (skip_code & 0x1F) as usize; |
| 81 | if skip > 0 { |
| 82 | has_skips = true; |
| 83 | } |
| 84 | validate!(x + skip * npixels <= self.width); |
| 85 | x += skip * npixels; |
| 86 | if rle_code < 0 { |
| 87 | let len = (-i16::from(rle_code)) as usize; |
| 88 | validate!(x + len * npixels <= self.width); |
| 89 | let val = br.read_u16be()?; |
| 90 | unpack_mono(val, &mut pix_buf); |
| 91 | for _ in 0..len { |
| 92 | for el in pix_buf.iter() { |
| 93 | frm.data[doff + x] = *el; |
| 94 | x += 1; |
| 95 | } |
| 96 | } |
| 97 | } else { |
| 98 | let len = rle_code as usize; |
| 99 | validate!(x + len * npixels <= self.width); |
| 100 | for _ in 0..len { |
| 101 | let val = br.read_u16be()?; |
| 102 | unpack_mono(val, &mut pix_buf); |
| 103 | for el in pix_buf.iter() { |
| 104 | frm.data[doff + x] = *el; |
| 105 | x += 1; |
| 106 | } |
| 107 | } |
| 108 | } |
| 109 | } |
| 110 | doff += stride; |
| 111 | y += 1; |
| 112 | } |
| 113 | |
| 114 | Ok(has_skips) |
| 115 | } |
| 116 | fn decode_pal(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u8>, start_line: usize, end_line: usize) -> DecoderResult<bool> { |
| 117 | let mut has_skips = false; |
| 118 | let mut pix_buf = [0u8; 16]; |
| 119 | let npixels = match self.depth { |
| 120 | 2 => 16, |
| 121 | 4 => 8, |
| 122 | 8 => 4, |
| 123 | _ => return Err(DecoderError::InvalidData), |
| 124 | }; |
| 125 | |
| 126 | let stride = frm.stride[0]; |
| 127 | let mut doff = frm.offset[0] + start_line * stride; |
| 128 | for _ in start_line..end_line { |
| 129 | let mut x = 0; |
| 130 | let mut skip_mode = true; |
| 131 | while x < self.width { |
| 132 | if skip_mode { |
| 133 | let skip_code = br.read_byte()?; |
| 134 | if skip_code == 0 { |
| 135 | return Ok(true); |
| 136 | } else { |
| 137 | let skip = (skip_code - 1) as usize; |
| 138 | validate!(x + skip * npixels <= self.width); |
| 139 | x += skip * npixels; |
| 140 | has_skips = true; |
| 141 | } |
| 142 | skip_mode = false; |
| 143 | } else { |
| 144 | let rle_code = br.read_byte()? as i8; |
| 145 | if rle_code == 0 { |
| 146 | skip_mode = true; |
| 147 | } else if rle_code == -1 { |
| 148 | if x < self.width { |
| 149 | has_skips = true; |
| 150 | } |
| 151 | break; |
| 152 | } else if rle_code < 0 { |
| 153 | let len = (-i16::from(rle_code)) as usize; |
| 154 | validate!(x + len * npixels <= self.width); |
| 155 | let val = br.read_u32be()?; |
| 156 | unpack_pixels(val, &mut pix_buf, self.depth); |
| 157 | for _ in 0..len { |
| 158 | for el in pix_buf.iter().take(npixels) { |
| 159 | frm.data[doff + x] = *el; |
| 160 | x += 1; |
| 161 | } |
| 162 | } |
| 163 | } else { |
| 164 | let len = rle_code as usize; |
| 165 | validate!(x + len * npixels <= self.width); |
| 166 | for _ in 0..len { |
| 167 | let val = br.read_u32be()?; |
| 168 | unpack_pixels(val, &mut pix_buf, self.depth); |
| 169 | for el in pix_buf.iter().take(npixels) { |
| 170 | frm.data[doff + x] = *el; |
| 171 | x += 1; |
| 172 | } |
| 173 | } |
| 174 | } |
| 175 | } |
| 176 | } |
| 177 | if x == self.width { |
| 178 | let eol = br.read_byte()? as i8; |
| 179 | validate!(eol == -1); |
| 180 | } |
| 181 | doff += stride; |
| 182 | } |
| 183 | |
| 184 | Ok(has_skips) |
| 185 | } |
| 186 | fn decode_16bit(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u16>, start_line: usize, end_line: usize) -> DecoderResult<bool> { |
| 187 | let mut has_skips = false; |
| 188 | |
| 189 | let stride = frm.stride[0]; |
| 190 | let mut doff = frm.offset[0] + start_line * stride; |
| 191 | for _ in start_line..end_line { |
| 192 | let mut x = 0; |
| 193 | let mut skip_mode = true; |
| 194 | while x < self.width { |
| 195 | if skip_mode { |
| 196 | let skip_code = br.read_byte()?; |
| 197 | if skip_code == 0 { |
| 198 | return Ok(true); |
| 199 | } else { |
| 200 | let skip = (skip_code - 1) as usize; |
| 201 | validate!(x + skip <= self.width); |
| 202 | x += skip; |
| 203 | has_skips = true; |
| 204 | } |
| 205 | skip_mode = false; |
| 206 | } else { |
| 207 | let rle_code = br.read_byte()? as i8; |
| 208 | if rle_code == 0 { |
| 209 | skip_mode = true; |
| 210 | } else if rle_code == -1 { |
| 211 | if x < self.width { |
| 212 | has_skips = true; |
| 213 | } |
| 214 | break; |
| 215 | } else if rle_code < 0 { |
| 216 | let len = (-i16::from(rle_code)) as usize; |
| 217 | validate!(x + len <= self.width); |
| 218 | let pix = br.read_u16be()?; |
| 219 | for _ in 0..len { |
| 220 | frm.data[doff + x] = pix; |
| 221 | x += 1; |
| 222 | } |
| 223 | } else { |
| 224 | let len = rle_code as usize; |
| 225 | validate!(x + len <= self.width); |
| 226 | for _ in 0..len { |
| 227 | frm.data[doff + x] = br.read_u16be()?; |
| 228 | x += 1; |
| 229 | } |
| 230 | } |
| 231 | } |
| 232 | } |
| 233 | if x == self.width { |
| 234 | let eol = br.read_byte()? as i8; |
| 235 | validate!(eol == -1); |
| 236 | } |
| 237 | doff += stride; |
| 238 | } |
| 239 | |
| 240 | Ok(has_skips) |
| 241 | } |
| 242 | fn decode_24bit(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u8>, start_line: usize, end_line: usize) -> DecoderResult<bool> { |
| 243 | let mut has_skips = false; |
| 244 | let mut rgb = [0u8; 3]; |
| 245 | |
| 246 | let stride = frm.stride[0]; |
| 247 | let mut doff = frm.offset[0] + start_line * stride; |
| 248 | for _ in start_line..end_line { |
| 249 | let mut x = 0; |
| 250 | let mut skip_mode = true; |
| 251 | while x < self.width { |
| 252 | if skip_mode { |
| 253 | let skip_code = br.read_byte()?; |
| 254 | if skip_code == 0 { |
| 255 | return Ok(true); |
| 256 | } else { |
| 257 | let skip = (skip_code - 1) as usize; |
| 258 | validate!(x + skip <= self.width); |
| 259 | x += skip; |
| 260 | has_skips = true; |
| 261 | } |
| 262 | skip_mode = false; |
| 263 | } else { |
| 264 | let rle_code = br.read_byte()? as i8; |
| 265 | if rle_code == 0 { |
| 266 | skip_mode = true; |
| 267 | } else if rle_code == -1 { |
| 268 | if x < self.width { |
| 269 | has_skips = true; |
| 270 | } |
| 271 | break; |
| 272 | } else if rle_code < 0 { |
| 273 | let len = (-i16::from(rle_code)) as usize; |
| 274 | validate!(x + len <= self.width); |
| 275 | br.read_buf(&mut rgb)?; |
| 276 | for _ in 0..len { |
| 277 | frm.data[doff + x * 3] = rgb[0]; |
| 278 | frm.data[doff + x * 3 + 1] = rgb[1]; |
| 279 | frm.data[doff + x * 3 + 2] = rgb[2]; |
| 280 | x += 1; |
| 281 | } |
| 282 | } else { |
| 283 | let len = rle_code as usize; |
| 284 | validate!(x + len <= self.width); |
| 285 | br.read_buf(&mut frm.data[doff + x * 3..][..len * 3])?; |
| 286 | x += len; |
| 287 | } |
| 288 | } |
| 289 | } |
| 290 | if x == self.width { |
| 291 | let eol = br.read_byte()? as i8; |
| 292 | validate!(eol == -1); |
| 293 | } |
| 294 | doff += stride; |
| 295 | } |
| 296 | |
| 297 | Ok(has_skips) |
| 298 | } |
| 299 | fn decode_32bit(&self, br: &mut ByteReader, frm: &mut NASimpleVideoFrame<u8>, start_line: usize, end_line: usize) -> DecoderResult<bool> { |
| 300 | let mut has_skips = false; |
| 301 | let mut rgb = [0u8; 4]; |
| 302 | |
| 303 | let stride = frm.stride[0]; |
| 304 | let mut doff = frm.offset[0] + start_line * stride; |
| 305 | for _ in start_line..end_line { |
| 306 | let mut x = 0; |
| 307 | let mut skip_mode = true; |
| 308 | while x < self.width { |
| 309 | if skip_mode { |
| 310 | let skip_code = br.read_byte()?; |
| 311 | if skip_code == 0 { |
| 312 | return Ok(true); |
| 313 | } else { |
| 314 | let skip = (skip_code - 1) as usize; |
| 315 | validate!(x + skip <= self.width); |
| 316 | x += skip; |
| 317 | has_skips = true; |
| 318 | } |
| 319 | skip_mode = false; |
| 320 | } else { |
| 321 | let rle_code = br.read_byte()? as i8; |
| 322 | if rle_code == 0 { |
| 323 | skip_mode = true; |
| 324 | } else if rle_code == -1 { |
| 325 | if x < self.width { |
| 326 | has_skips = true; |
| 327 | } |
| 328 | break; |
| 329 | } else if rle_code < 0 { |
| 330 | let len = (-i16::from(rle_code)) as usize; |
| 331 | validate!(x + len <= self.width); |
| 332 | br.read_buf(&mut rgb)?; |
| 333 | for _ in 0..len { |
| 334 | frm.data[doff + x * 4] = rgb[0]; |
| 335 | frm.data[doff + x * 4 + 1] = rgb[1]; |
| 336 | frm.data[doff + x * 4 + 2] = rgb[2]; |
| 337 | frm.data[doff + x * 4 + 3] = rgb[3]; |
| 338 | x += 1; |
| 339 | } |
| 340 | } else { |
| 341 | let len = rle_code as usize; |
| 342 | validate!(x + len <= self.width); |
| 343 | br.read_buf(&mut frm.data[doff + x * 4..][..len * 4])?; |
| 344 | x += len; |
| 345 | } |
| 346 | } |
| 347 | } |
| 348 | if x == self.width { |
| 349 | let eol = br.read_byte()? as i8; |
| 350 | validate!(eol == -1); |
| 351 | } |
| 352 | doff += stride; |
| 353 | } |
| 354 | |
| 355 | Ok(has_skips) |
| 356 | } |
| 357 | } |
| 358 | |
| 359 | impl NADecoder for RleDecoder { |
| 360 | fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> { |
| 361 | if let NACodecTypeInfo::Video(vinfo) = info.get_properties() { |
| 362 | self.width = vinfo.get_width(); |
| 363 | self.height = vinfo.get_height(); |
| 364 | self.depth = vinfo.bits; |
| 365 | let fmt = match self.depth { |
| 366 | 1 | 2 | 4 | 8 => PAL8_FORMAT, |
| 367 | 15 | 16 => RGB555_FORMAT, |
| 368 | 24 => RGB24_FORMAT, |
| 369 | 32 => ARGB_FORMAT, |
| 370 | _ => return Err(DecoderError::InvalidData), |
| 371 | }; |
| 372 | let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(self.width, self.height, false, fmt)); |
| 373 | self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref(); |
| 374 | |
| 375 | Ok(()) |
| 376 | } else { |
| 377 | Err(DecoderError::InvalidData) |
| 378 | } |
| 379 | } |
| 380 | fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> { |
| 381 | let src = pkt.get_buffer(); |
| 382 | validate!(src.len() >= 2); |
| 383 | let mut mr = MemoryReader::new_read(src.as_slice()); |
| 384 | let mut br = ByteReader::new(&mut mr); |
| 385 | |
| 386 | let id = br.read_byte()?; |
| 387 | validate!(id == 0x40 || id == 0x00); |
| 388 | let length = br.read_u24be()? as usize; |
| 389 | validate!(length == src.len()); |
| 390 | |
| 391 | let flags = br.read_u16be()?; |
| 392 | let (start_line, end_line) = if (flags & 0x8) != 0 { |
| 393 | let start = br.read_u16be()? as usize; |
| 394 | br.read_skip(2)?; |
| 395 | let h = br.read_u16be()? as usize; |
| 396 | br.read_skip(2)?; |
| 397 | validate!(start + h <= self.height); |
| 398 | (start, start + h) |
| 399 | } else { |
| 400 | (0, self.height) |
| 401 | }; |
| 402 | |
| 403 | let mut has_skips; |
| 404 | let buftype; |
| 405 | if self.depth <= 8 { |
| 406 | let bufret = self.hams.clone_ref(); |
| 407 | let mut buf; |
| 408 | if let Some(bbuf) = bufret { |
| 409 | buf = bbuf; |
| 410 | } else { |
| 411 | let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?; |
| 412 | buf = bufinfo.get_vbuf().unwrap(); |
| 413 | self.hams.add_frame(buf); |
| 414 | buf = self.hams.get_output_frame().unwrap(); |
| 415 | } |
| 416 | let mut frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap(); |
| 417 | if self.depth != 1 { |
| 418 | has_skips = self.decode_pal(&mut br, &mut frm, start_line, end_line)?; |
| 419 | } else { |
| 420 | has_skips = self.decode_mono(&mut br, &mut frm, start_line, end_line)?; |
| 421 | } |
| 422 | |
| 423 | let paloff = frm.offset[1]; |
| 424 | let dpal = &mut frm.data[paloff..]; |
| 425 | for sd in pkt.side_data.iter() { |
| 426 | match *sd { |
| 427 | NASideData::Palette(_, ref pal) => { |
| 428 | for (dst, src) in dpal.chunks_mut(3).zip(pal.chunks(4)) { |
| 429 | dst[0] = src[0]; |
| 430 | dst[1] = src[1]; |
| 431 | dst[2] = src[2]; |
| 432 | } |
| 433 | break; |
| 434 | }, |
| 435 | _ => {}, |
| 436 | }; |
| 437 | } |
| 438 | buftype = NABufferType::Video(buf); |
| 439 | } else if self.depth == 16 { |
| 440 | let bufret = self.hams16.clone_ref(); |
| 441 | let mut buf; |
| 442 | if let Some(bbuf) = bufret { |
| 443 | buf = bbuf; |
| 444 | } else { |
| 445 | let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?; |
| 446 | buf = bufinfo.get_vbuf16().unwrap(); |
| 447 | self.hams16.add_frame(buf); |
| 448 | buf = self.hams16.get_output_frame().unwrap(); |
| 449 | } |
| 450 | let mut frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap(); |
| 451 | has_skips = self.decode_16bit(&mut br, &mut frm, start_line, end_line)?; |
| 452 | buftype = NABufferType::Video16(buf); |
| 453 | } else if self.depth == 24 { |
| 454 | let bufret = self.hams.clone_ref(); |
| 455 | let mut buf; |
| 456 | if let Some(bbuf) = bufret { |
| 457 | buf = bbuf; |
| 458 | } else { |
| 459 | let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?; |
| 460 | buf = bufinfo.get_vbuf().unwrap(); |
| 461 | self.hams.add_frame(buf); |
| 462 | buf = self.hams.get_output_frame().unwrap(); |
| 463 | } |
| 464 | let mut frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap(); |
| 465 | has_skips = self.decode_24bit(&mut br, &mut frm, start_line, end_line)?; |
| 466 | buftype = NABufferType::Video(buf); |
| 467 | } else if self.depth == 32 { |
| 468 | let bufret = self.hams.clone_ref(); |
| 469 | let mut buf; |
| 470 | if let Some(bbuf) = bufret { |
| 471 | buf = bbuf; |
| 472 | } else { |
| 473 | let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?; |
| 474 | buf = bufinfo.get_vbuf().unwrap(); |
| 475 | self.hams.add_frame(buf); |
| 476 | buf = self.hams.get_output_frame().unwrap(); |
| 477 | } |
| 478 | let mut frm = NASimpleVideoFrame::from_video_buf(&mut buf).unwrap(); |
| 479 | has_skips = self.decode_32bit(&mut br, &mut frm, start_line, end_line)?; |
| 480 | buftype = NABufferType::Video(buf); |
| 481 | } else { |
| 482 | return Err(DecoderError::InvalidData); |
| 483 | } |
| 484 | if (start_line != 0) || (end_line != self.height) { |
| 485 | has_skips = true; |
| 486 | } |
| 487 | |
| 488 | let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), buftype); |
| 489 | frm.set_keyframe(!has_skips); |
| 490 | frm.set_frame_type(if !has_skips { FrameType::I } else { FrameType::P }); |
| 491 | Ok(frm.into_ref()) |
| 492 | } |
| 493 | fn flush(&mut self) { |
| 494 | self.hams.clear(); |
| 495 | self.hams16.clear(); |
| 496 | } |
| 497 | } |
| 498 | |
| 499 | impl NAOptionHandler for RleDecoder { |
| 500 | fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } |
| 501 | fn set_options(&mut self, _options: &[NAOption]) { } |
| 502 | fn query_option_value(&self, _name: &str) -> Option<NAValue> { None } |
| 503 | } |
| 504 | |
| 505 | pub fn get_decoder() -> Box<dyn NADecoder + Send> { |
| 506 | Box::new(RleDecoder::new()) |
| 507 | } |
| 508 | |
| 509 | #[cfg(test)] |
| 510 | mod test { |
| 511 | use nihav_core::codecs::RegisteredDecoders; |
| 512 | use nihav_core::demuxers::RegisteredDemuxers; |
| 513 | use nihav_codec_support::test::dec_video::*; |
| 514 | use crate::qt_register_all_decoders; |
| 515 | use nihav_commonfmt::generic_register_all_demuxers; |
| 516 | // samples from https://samples.mplayerhq.hu/V-codecs/QTRLE |
| 517 | #[test] |
| 518 | fn test_qt_rle_1bit() { |
| 519 | let mut dmx_reg = RegisteredDemuxers::new(); |
| 520 | generic_register_all_demuxers(&mut dmx_reg); |
| 521 | let mut dec_reg = RegisteredDecoders::new(); |
| 522 | qt_register_all_decoders(&mut dec_reg); |
| 523 | |
| 524 | //test_file_decoding("mov", "assets/QT/Animation-Monochrome.mov", Some(6), true, false, Some("qtrle-mono"), &dmx_reg, &dec_reg); |
| 525 | test_decoding("mov", "qt-rle", "assets/QT/Animation-Monochrome.mov", Some(6), &dmx_reg, &dec_reg, |
| 526 | ExpectedTestResult::MD5Frames(vec![ |
| 527 | [0xc5b6fd2b, 0x87aae95c, 0xc32d0aaa, 0x4ed21592], |
| 528 | [0xe13aa599, 0x2ec6421e, 0xfcfdcc81, 0x8c2ee2ef], |
| 529 | [0xd835547b, 0xe2ffd6c9, 0xe24135c1, 0x7d2bb64f], |
| 530 | [0x6176e812, 0xb637444c, 0x71b1cbe5, 0xfc98905f], |
| 531 | [0x53a6b414, 0xbbf266c0, 0x859c3d10, 0x179a2252], |
| 532 | [0x56bc8cdd, 0x6438ba4d, 0x056e79c1, 0xb851e767], |
| 533 | [0xc25b9fec, 0xfc93233a, 0x30301b6d, 0xb290f5d7]])); |
| 534 | } |
| 535 | #[test] |
| 536 | fn test_qt_rle_4bit() { |
| 537 | let mut dmx_reg = RegisteredDemuxers::new(); |
| 538 | generic_register_all_demuxers(&mut dmx_reg); |
| 539 | let mut dec_reg = RegisteredDecoders::new(); |
| 540 | qt_register_all_decoders(&mut dec_reg); |
| 541 | |
| 542 | test_decoding("mov", "qt-rle", "assets/QT/Animation-16Greys.mov", Some(6), &dmx_reg, &dec_reg, |
| 543 | ExpectedTestResult::MD5Frames(vec![ |
| 544 | [0x280c82aa, 0xa8bd11a6, 0x5b5babda, 0xeff58dd9], |
| 545 | [0x5c732231, 0x81d20be3, 0x41249639, 0xab2a9841], |
| 546 | [0xb689268d, 0x26de8510, 0x506e0a06, 0xb0dcfc40], |
| 547 | [0x09dced38, 0xbd0f5482, 0x3803efc9, 0x84bcaac4], |
| 548 | [0x5c49f8cc, 0xc1e2bd17, 0x1c22b849, 0x8f09afd5], |
| 549 | [0xe9f7b847, 0x13a4e429, 0x1b8af943, 0x82766ed2], |
| 550 | [0x2833c41a, 0x53781343, 0xce083e07, 0xdc3b24e9]])); |
| 551 | } |
| 552 | #[test] |
| 553 | fn test_qt_rle_8bit() { |
| 554 | let mut dmx_reg = RegisteredDemuxers::new(); |
| 555 | generic_register_all_demuxers(&mut dmx_reg); |
| 556 | let mut dec_reg = RegisteredDecoders::new(); |
| 557 | qt_register_all_decoders(&mut dec_reg); |
| 558 | |
| 559 | test_decoding("mov", "qt-rle", "assets/QT/Animation-256Greys.mov", Some(6), &dmx_reg, &dec_reg, |
| 560 | ExpectedTestResult::MD5Frames(vec![ |
| 561 | [0x3c439212, 0x419944a5, 0xb274d9f5, 0xf3c53b12], |
| 562 | [0xd2a51886, 0xfbd37c2e, 0x899806c6, 0x465a66e0], |
| 563 | [0xbd59029e, 0x9de8766c, 0xd681bf0c, 0xa7fe4dfe], |
| 564 | [0x6150d380, 0xe8d67e0b, 0x0beb8455, 0xfcfd899d], |
| 565 | [0xba0f6b50, 0xba253267, 0xb727c5d7, 0x10dbf0c7], |
| 566 | [0x4f93f1aa, 0x2f10aa86, 0xfa97b35f, 0x687065df], |
| 567 | [0x730270e2, 0x3a3e02f1, 0xb906f478, 0xdb42af87]])); |
| 568 | } |
| 569 | #[test] |
| 570 | fn test_qt_rle_16bit() { |
| 571 | let mut dmx_reg = RegisteredDemuxers::new(); |
| 572 | generic_register_all_demuxers(&mut dmx_reg); |
| 573 | let mut dec_reg = RegisteredDecoders::new(); |
| 574 | qt_register_all_decoders(&mut dec_reg); |
| 575 | |
| 576 | test_decoding("mov", "qt-rle", "assets/QT/Animation-Highcolour.mov", Some(6), &dmx_reg, &dec_reg, |
| 577 | ExpectedTestResult::MD5Frames(vec![ |
| 578 | [0x8fa5361b, 0xd36d6def, 0x33b250e9, 0xab98a41c], |
| 579 | [0xdd253ce0, 0xbc5fd3a1, 0x51fe2394, 0x950f18e4], |
| 580 | [0xbf34ca8d, 0x1faa24ee, 0x8d70af09, 0x742a4056], |
| 581 | [0x9feca59b, 0xdca7dc1d, 0xb6fe14f1, 0xd88c8b67], |
| 582 | [0x2e1544b8, 0x89a7e788, 0x0efcde09, 0xec4e7995], |
| 583 | [0x1e28b2a8, 0xd53495ca, 0x405a9b6e, 0x59338cad], |
| 584 | [0xe90156a4, 0xb64bca4a, 0x5cdf6681, 0xc32945fb]])); |
| 585 | } |
| 586 | #[test] |
| 587 | fn test_qt_rle_24bit() { |
| 588 | let mut dmx_reg = RegisteredDemuxers::new(); |
| 589 | generic_register_all_demuxers(&mut dmx_reg); |
| 590 | let mut dec_reg = RegisteredDecoders::new(); |
| 591 | qt_register_all_decoders(&mut dec_reg); |
| 592 | |
| 593 | test_decoding("mov", "qt-rle", "assets/QT/Animation-Truecolour.mov", Some(6), &dmx_reg, &dec_reg, |
| 594 | ExpectedTestResult::MD5Frames(vec![ |
| 595 | [0x84d00c89, 0xf92c7f81, 0x6c1bd9e7, 0x35dd8f57], |
| 596 | [0x5ff0a7c9, 0xb589a484, 0xecc230b3, 0xe4e53bd3], |
| 597 | [0xbb394f7b, 0x2591b6c6, 0x12b0070c, 0xfa0952fc], |
| 598 | [0x380c1756, 0x72be8b16, 0xa7bbff48, 0x106017d4], |
| 599 | [0x27d8cc7c, 0x43ee384d, 0x542b95b1, 0x0a3ee031], |
| 600 | [0xa29529de, 0xcb53d03b, 0x4f2b6ec5, 0x4ea5d738], |
| 601 | [0x181d471b, 0x90d389e7, 0xc627b263, 0xa9d42323]])); |
| 602 | } |
| 603 | #[test] |
| 604 | fn test_qt_rle_32bit() { |
| 605 | let mut dmx_reg = RegisteredDemuxers::new(); |
| 606 | generic_register_all_demuxers(&mut dmx_reg); |
| 607 | let mut dec_reg = RegisteredDecoders::new(); |
| 608 | qt_register_all_decoders(&mut dec_reg); |
| 609 | |
| 610 | test_decoding("mov", "qt-rle", "assets/QT/Jag-finder-renaming.mov", Some(10), &dmx_reg, &dec_reg, |
| 611 | ExpectedTestResult::MD5Frames(vec![ |
| 612 | [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125], |
| 613 | [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125], |
| 614 | [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125], |
| 615 | [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125], |
| 616 | [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125], |
| 617 | [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125], |
| 618 | [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125], |
| 619 | [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125], |
| 620 | [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125], |
| 621 | [0xe82390cf, 0xfaceab34, 0xcc857b2f, 0xed47f125], |
| 622 | [0xe67d4be5, 0xe41ce60e, 0x4e6912c3, 0xc96dc521]])); |
| 623 | } |
| 624 | } |