]>
Commit | Line | Data |
---|---|---|
4c1582cf KS |
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::*; | |
78fb6560 | 514 | use crate::qt_register_all_decoders; |
4c1582cf | 515 | use nihav_commonfmt::generic_register_all_demuxers; |
886cde48 | 516 | // samples from https://samples.mplayerhq.hu/V-codecs/QTRLE |
4c1582cf KS |
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(); | |
78fb6560 | 522 | qt_register_all_decoders(&mut dec_reg); |
4c1582cf KS |
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(); | |
78fb6560 | 540 | qt_register_all_decoders(&mut dec_reg); |
4c1582cf KS |
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(); | |
78fb6560 | 557 | qt_register_all_decoders(&mut dec_reg); |
4c1582cf KS |
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(); | |
78fb6560 | 574 | qt_register_all_decoders(&mut dec_reg); |
4c1582cf KS |
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(); | |
78fb6560 | 591 | qt_register_all_decoders(&mut dec_reg); |
4c1582cf | 592 | |
180a78c5 | 593 | test_decoding("mov", "qt-rle", "assets/QT/Animation-Truecolour.mov", Some(6), &dmx_reg, &dec_reg, |
4c1582cf | 594 | ExpectedTestResult::MD5Frames(vec![ |
180a78c5 KS |
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]])); | |
4c1582cf KS |
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(); | |
78fb6560 | 608 | qt_register_all_decoders(&mut dec_reg); |
4c1582cf KS |
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], | |
f5066527 | 622 | [0xe67d4be5, 0xe41ce60e, 0x4e6912c3, 0xc96dc521]])); |
4c1582cf KS |
623 | } |
624 | } |