projects / nihav.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
switch NACodecInfo to Arc
[nihav.git] / nihav-duck / src / codecs / truemotion2x.rs
1 use nihav_core::codecs::*;
2 use nihav_core::io::byteio::*;
3
4 #[derive(Default)]
5 struct Decryptor {
6 key: [u8; 4],
7 }
8
9 impl Decryptor {
10 fn decrypt(&mut self, buf: &mut [u8]) {
11 let mut pos: u8 = 0;
12 for el in buf.iter_mut() {
13 *el ^= self.key[(pos & 3) as usize];
14 pos = pos.wrapping_add(1);
15 }
16 }
17 fn set_state(&mut self, mut key: u32) {
18 for _ in 0..3 {
19 let bit31 = (key >> 31) & 1;
20 let bit21 = (key >> 21) & 1;
21 let bit01 = (key >> 1) & 1;
22 let nbit0 = !key & 1;
23 key = (key << 1) | (bit31 ^ bit21 ^ bit01 ^ nbit0);
24 }
25 for i in 0..4 {
26 self.key[i] = (key >> (8 * (i ^ 3))) as u8;
27 }
28 }
29 }
30
31 struct Deltas {
32 tabs: [[i16; 256]; 2],
33 codebook: [[u8; 8]; 256],
34 num_elems: [usize; 256],
35 num_vq: usize,
36 vq_idx: usize,
37 vq_pos: usize,
38 vq_esc: u8,
39 }
40
41 impl Deltas {
42 fn reset(&mut self, br: &mut ByteReader) -> DecoderResult<()> {
43 let b = br.read_byte()? as usize;
44 self.vq_idx = b;
45 self.vq_pos = 0;
46 Ok(())
47 }
48 fn get_val(&mut self, br: &mut ByteReader) -> DecoderResult<u8> {
49 if self.vq_idx > self.codebook.len() { return Err(DecoderError::ShortData); }
50 let ret = self.codebook[self.vq_idx][self.vq_pos];
51 self.vq_pos += 1;
52 if self.vq_pos == self.num_elems[self.vq_idx] {
53 if br.left() > 0 {
54 self.reset(br)?;
55 } else {
56 self.vq_idx = self.codebook.len() + 1;
57 }
58 }
59 Ok(ret)
60 }
61 fn remap(val: u16) -> i16 {
62 let hval = (val >> 1) as i16;
63 if (val & 1) == 0 {
64 hval
65 } else {
66 -1 - hval
67 }
68 }
69 fn get_int(&mut self, br: &mut ByteReader) -> DecoderResult<i16> {
70 let b = self.get_val(br)?;
71 if b != self.vq_esc - 1 {
72 return Ok(Self::remap(b as u16));
73 }
74 let mut run = 0;
75 let mut val;
76 let mut pow = self.vq_esc as u16;
77 loop {
78 let b = self.get_val(br)?;
79 run += 1;
80 if b != self.vq_esc - 1 {
81 val = (b as u16) * pow;
82 break;
83 }
84 pow *= self.vq_esc as u16;
85 }
86
87 for _ in 0..run {
88 pow /= self.vq_esc as u16;
89 let b = self.get_val(br)? as u16;
90 val += pow * (b as u16);
91 }
92 Ok(Self::remap(val))
93 }
94 fn get_dy(&mut self, br: &mut ByteReader) -> DecoderResult<i16> {
95 let b = self.get_val(br)?;
96 Ok(self.tabs[1][b as usize])
97 }
98 fn get_dc(&mut self, br: &mut ByteReader) -> DecoderResult<i16> {
99 let b = self.get_val(br)?;
100 Ok(self.tabs[0][b as usize])
101 }
102 }
103
104 impl Default for Deltas {
105 fn default() -> Self {
106 Self {
107 tabs: [[0; 256]; 2],
108 codebook: [[0; 8]; 256],
109 num_elems: [0; 256],
110 num_vq: 0,
111 vq_idx: 0,
112 vq_pos: 0,
113 vq_esc: 0,
114 }
115 }
116 }
117
118 #[derive(Clone,Copy, Default)]
119 struct BlkInfo {
120 btype: u8,
121 mode: u8,
122 mv_x: i16,
123 mv_y: i16,
124 }
125
126 const NUM_CPARAMS: usize = 25;
127 const CPARAM_NONE: u8 = 42;
128 const CPARAM_MISSING: u8 = 42 * 2;
129 const CPARAM_MV: u8 = 42 * 3;
130
131 macro_rules! apply_delta {
132 ($buf:expr, $off:expr, $stride:expr, $hpred: expr, $delta:expr) => {
133 $hpred = $hpred.wrapping_add($delta);
134 $buf[$off] = $buf[$off - $stride].wrapping_add($hpred);
135 };
136 }
137 macro_rules! copy_line {
138 ($buf:expr, $off:expr, $stride:expr) => {
139 for i in 0..8 {
140 $buf[$off + i] = $buf[$off + i - $stride];
141 }
142 };
143 }
144
145 #[derive(Default)]
146 struct Frame {
147 ydata: Vec<i16>,
148 udata: Vec<i16>,
149 vdata: Vec<i16>,
150 stride: usize,
151 }
152
153 impl Frame {
154 fn resize(&mut self, w: usize, h: usize) {
155 self.stride = w;
156 self.ydata.resize(self.stride * (h + 1), 0x80);
157 self.udata.resize(self.stride * (h + 1), 0x80);
158 self.vdata.resize(self.stride * (h + 1), 0x80);
159 }
160 }
161
162 #[derive(Default)]
163 struct TM2XDecoder {
164 info: NACodecInfoRef,
165 width: usize,
166 height: usize,
167 dec_buf: Vec<u8>,
168 version: u8,
169 is_intra: bool,
170 deltas: Deltas,
171 blk_info: Vec<BlkInfo>,
172 tile_size: usize,
173 cparams: [[u8; 8]; NUM_CPARAMS],
174 cur_frame: Frame,
175 ref_frame: Frame,
176 }
177
178 impl TM2XDecoder {
179 fn new() -> Self { Self::default() }
180 fn output_frame(&mut self, buf: &mut NAVideoBuffer<u8>) {
181 let mut offs = [ buf.get_offset(0), buf.get_offset(1), buf.get_offset(2) ];
182 let strides = [ buf.get_stride(0), buf.get_stride(1), buf.get_stride(2) ];
183 let data = buf.get_data_mut().unwrap();
184 let dst = data.as_mut_slice();
185
186 let mut pos = self.cur_frame.stride;
187 for _y in 0..self.height {
188 for x in 0..self.width {
189 let y = self.cur_frame.ydata[pos + x];
190 let u = self.cur_frame.udata[pos + x];
191 let v = self.cur_frame.vdata[pos + x];
192 dst[offs[0] + x] = y.max(0).min(255) as u8;
193 dst[offs[1] + x] = u.max(0).min(255) as u8;
194 dst[offs[2] + x] = v.max(0).min(255) as u8;
195 }
196 for c in 0..3 {
197 offs[c] += strides[c];
198 }
199 pos += self.cur_frame.stride;
200 }
201 }
202 fn parse_init(&mut self, version: u8) -> DecoderResult<()> {
203 self.version = version;
204
205 let mut mr = MemoryReader::new_read(&self.dec_buf);
206 let mut br = ByteReader::new(&mut mr);
207 if version > 4 {
208 let _smth = br.read_u32be()?;
209 }
210 let height = br.read_u16be()? as usize;
211 let width = br.read_u16be()? as usize;
212 validate!(width == self.width && height == self.height);
213 if version > 4 {
214 let _smth = br.read_u32be()?;
215 }
216 let _smth = br.read_byte()?;
217 let _nfuncs = br.read_byte()? as usize;
218 let _smth = br.read_u16be()? as usize;
219 let has_mv = br.read_byte()?;
220 self.is_intra = has_mv == 0;
221 if version >= 4 {
222 let _flags = br.read_u16be()?;
223 let id_len = br.read_byte()? as usize;
224 br.read_skip(id_len)?;
225 let _smth1 = br.read_byte()?;
226 let len = br.read_byte()? as usize;
227 br.read_skip(len)?;
228 let _smth = br.read_u32be()?;
229 }
230
231 Ok(())
232 }
233 fn parse_tabs(&mut self) -> DecoderResult<()> {
234 let mut mr = MemoryReader::new_read(&self.dec_buf);
235 let mut br = ByteReader::new(&mut mr);
236
237 let idx = br.read_byte()? as usize;
238 validate!(idx < self.deltas.tabs.len());
239 let len = br.read_byte()? as usize;
240 validate!(((len * 2) as i64) == br.left());
241 for i in 0..len {
242 self.deltas.tabs[idx][i] = br.read_u16be()? as i16;
243 }
244
245 Ok(())
246 }
247 fn parse_cb_desc(&mut self, version: u8) -> DecoderResult<()> {
248 let mut mr = MemoryReader::new_read(&self.dec_buf);
249 let mut br = ByteReader::new(&mut mr);
250
251 if version == 0x0A {
252 self.deltas.vq_esc = br.read_byte()?;
253 validate!(self.deltas.vq_esc > 1);
254 let _tag = br.read_u16be()?;
255 }
256 let len = br.read_u16be()? as usize;
257 validate!(len + 3 == (br.left() as usize));
258 let num_entries = br.read_u16be()?;
259 validate!(num_entries == 256);
260 let max_elems = br.read_byte()?;
261 validate!(max_elems > 0 && max_elems <= 8);
262 let mut idx = 0;
263 while br.left() > 0 {
264 validate!(idx < self.deltas.codebook.len());
265 let num_elems = br.read_byte()? as usize;
266 validate!(num_elems <= 8);
267 self.deltas.num_elems[idx] = num_elems;
268 for i in 0..num_elems {
269 self.deltas.codebook[idx][i] = br.read_byte()?;
270 }
271 idx += 1;
272 }
273 validate!(idx == 256);
274 self.deltas.num_vq = idx;
275 Ok(())
276 }
277
278 fn decode_frame(&mut self, src: &[u8]) -> DecoderResult<()> {
279 let mut mr = MemoryReader::new_read(src);
280 let mut br = ByteReader::new(&mut mr);
281
282 self.deltas.reset(&mut br)?;
283 let bw = self.width / 8;
284 let bh = self.height / 8;
285 let ntiles = (bw + self.tile_size - 1) / self.tile_size;
286 let mut pos = self.cur_frame.stride;
287 let ydata = &mut self.cur_frame.ydata;
288 let udata = &mut self.cur_frame.udata;
289 let vdata = &mut self.cur_frame.vdata;
290 let stride = self.cur_frame.stride;
291 for by in 0..bh {
292 for tile in 0..ntiles {
293 let xpos = tile * self.tile_size;
294 let len = self.tile_size.min(bw - xpos);
295 let mut last_x = 0;
296 let mut last_y = 0;
297 for el in self.blk_info.iter_mut().take(len) {
298 let t1 = self.deltas.get_val(&mut br)?;
299 let t2 = self.deltas.get_val(&mut br)?;
300 validate!((t1 as usize) < NUM_CPARAMS);
301 validate!(self.cparams[t1 as usize][0] != CPARAM_MISSING);
302 el.btype = t1;
303 el.mode = t2;
304 if t2 > 0 {
305 el.mv_x = self.deltas.get_int(&mut br)?;
306 el.mv_y = self.deltas.get_int(&mut br)?;
307 last_x = el.mv_x;
308 last_y = el.mv_y;
309 } else {
310 el.mv_x = last_x;
311 el.mv_y = last_y;
312 }
313 }
314 for line in 0..8 {
315 let mut ypred = 0i16;
316 let mut upred = 0i16;
317 let mut vpred = 0i16;
318 for x in 0..len {
319 let bx = xpos + x;
320 let op = self.cparams[self.blk_info[x].btype as usize][line];
321 let cur_off = pos + bx * 8 + line * stride;
322 match op {
323 0 => { // y4|y4
324 for i in 0..8 {
325 let delta = self.deltas.get_dy(&mut br)?;
326 apply_delta!(ydata, cur_off + i, stride, ypred, delta);
327 }
328 copy_line!(udata, cur_off, stride);
329 copy_line!(vdata, cur_off, stride);
330 upred = 0;
331 vpred = 0;
332 },
333 1 => { // y2|y2
334 for i in 0..8 {
335 if (i & 1) == 0 {
336 let delta = self.deltas.get_dy(&mut br)?;
337 apply_delta!(ydata, cur_off + i, stride, ypred, delta);
338 } else {
339 ydata[cur_off + i] = ydata[cur_off + i - 1];
340 }
341 }
342 copy_line!(udata, cur_off, stride);
343 copy_line!(vdata, cur_off, stride);
344 upred = 0;
345 vpred = 0;
346 },
347 2 => { // y1|y1
348 for i in 0..8 {
349 if (i & 3) == 0 {
350 let delta = self.deltas.get_dy(&mut br)?;
351 apply_delta!(ydata, cur_off + i, stride, ypred, delta);
352 } else {
353 ydata[cur_off + i] = ydata[cur_off + i - 1];
354 }
355 }
356 copy_line!(udata, cur_off, stride);
357 copy_line!(vdata, cur_off, stride);
358 upred = 0;
359 vpred = 0;
360 },
361 3 => { // y1|0
362 let delta = self.deltas.get_dy(&mut br)?;
363 apply_delta!(ydata, cur_off, stride, ypred, delta);
364 for i in 1..8 {
365 ydata[cur_off + i] = ydata[cur_off];
366 }
367 copy_line!(udata, cur_off, stride);
368 copy_line!(vdata, cur_off, stride);
369 upred = 0;
370 vpred = 0;
371 },
372 4 => { // c2y2c2y2|c2y2c2y2
373 for i in (0..8).step_by(2) {
374 let delta = self.deltas.get_dc(&mut br)?;
375 apply_delta!(udata, cur_off + i + 0, stride, upred, delta);
376 udata[cur_off + i + 1] = udata[cur_off + i];
377 let delta = self.deltas.get_dc(&mut br)?;
378 apply_delta!(vdata, cur_off + i + 0, stride, vpred, delta);
379 vdata[cur_off + i + 1] = vdata[cur_off + i];
380 let delta = self.deltas.get_dy(&mut br)?;
381 apply_delta!(ydata, cur_off + i + 0, stride, ypred, delta);
382 let delta = self.deltas.get_dy(&mut br)?;
383 apply_delta!(ydata, cur_off + i + 1, stride, ypred, delta);
384 }
385 },
386 5 => { // c2y1|c2y1
387 for i in 0..8 {
388 if (i & 3) == 0 {
389 let delta = self.deltas.get_dc(&mut br)?;
390 apply_delta!(udata, cur_off + i, stride, upred, delta);
391 let delta = self.deltas.get_dc(&mut br)?;
392 apply_delta!(vdata, cur_off + i, stride, vpred, delta);
393 let delta = self.deltas.get_dy(&mut br)?;
394 apply_delta!(ydata, cur_off + i, stride, ypred, delta);
395 } else {
396 udata[cur_off + i] = udata[cur_off + i - 1];
397 vdata[cur_off + i] = vdata[cur_off + i - 1];
398 ydata[cur_off + i] = ydata[cur_off + i - 1];
399 }
400 }
401 },
402 6 | 7 => unreachable!(),
403 8 => { // c2y4|c2y4
404 for i in 0..8 {
405 if (i & 3) == 0 {
406 let delta = self.deltas.get_dc(&mut br)?;
407 apply_delta!(udata, cur_off + i, stride, upred, delta);
408 let delta = self.deltas.get_dc(&mut br)?;
409 apply_delta!(vdata, cur_off + i, stride, vpred, delta);
410 } else {
411 udata[cur_off + i] = udata[cur_off + i - 1];
412 vdata[cur_off + i] = vdata[cur_off + i - 1];
413 }
414 let delta = self.deltas.get_dy(&mut br)?;
415 apply_delta!(ydata, cur_off + i, stride, ypred, delta);
416 }
417 },
418 9 => { // c2y2|c2y2
419 for i in 0..8 {
420 if (i & 3) == 0 {
421 let delta = self.deltas.get_dc(&mut br)?;
422 apply_delta!(udata, cur_off + i, stride, upred, delta);
423 let delta = self.deltas.get_dc(&mut br)?;
424 apply_delta!(vdata, cur_off + i, stride, vpred, delta);
425 } else {
426 udata[cur_off + i] = udata[cur_off + i - 1];
427 vdata[cur_off + i] = vdata[cur_off + i - 1];
428 }
429 if (i & 1) == 0 {
430 let delta = self.deltas.get_dy(&mut br)?;
431 apply_delta!(ydata, cur_off + i, stride, ypred, delta);
432 } else {
433 ydata[cur_off + i] = ydata[cur_off + i - 1];
434 }
435 }
436 },
437 10 => { // c2y1|c2y1
438 for i in 0..8 {
439 if (i & 3) == 0 {
440 let delta = self.deltas.get_dc(&mut br)?;
441 apply_delta!(udata, cur_off + i, stride, upred, delta);
442 let delta = self.deltas.get_dc(&mut br)?;
443 apply_delta!(vdata, cur_off + i, stride, vpred, delta);
444 let delta = self.deltas.get_dy(&mut br)?;
445 apply_delta!(ydata, cur_off + i, stride, ypred, delta);
446 } else {
447 udata[cur_off + i] = udata[cur_off + i - 1];
448 vdata[cur_off + i] = vdata[cur_off + i - 1];
449 ydata[cur_off + i] = ydata[cur_off + i - 1];
450 }
451 }
452 },
453 11 => unreachable!(),
454 12 => { // c2y8
455 for i in 0..8 {
456 if i == 0 {
457 let delta = self.deltas.get_dc(&mut br)?;
458 apply_delta!(udata, cur_off + i, stride, upred, delta);
459 let delta = self.deltas.get_dc(&mut br)?;
460 apply_delta!(vdata, cur_off + i, stride, vpred, delta);
461 } else {
462 udata[cur_off + i] = udata[cur_off + i - 1];
463 vdata[cur_off + i] = vdata[cur_off + i - 1];
464 }
465 let delta = self.deltas.get_dy(&mut br)?;
466 apply_delta!(ydata, cur_off + i, stride, ypred, delta);
467 }
468 },
469 13 => { // c2y4
470 for i in 0..8 {
471 if i == 0 {
472 let delta = self.deltas.get_dc(&mut br)?;
473 apply_delta!(udata, cur_off + i, stride, upred, delta);
474 let delta = self.deltas.get_dc(&mut br)?;
475 apply_delta!(vdata, cur_off + i, stride, vpred, delta);
476 } else {
477 udata[cur_off + i] = udata[cur_off + i - 1];
478 vdata[cur_off + i] = vdata[cur_off + i - 1];
479 }
480 if (i & 1) == 0 {
481 let delta = self.deltas.get_dy(&mut br)?;
482 apply_delta!(ydata, cur_off + i, stride, ypred, delta);
483 } else {
484 ydata[cur_off + i] = ydata[cur_off + i - 1];
485 }
486 }
487 },
488 14 => { // c2y2
489 for i in 0..8 {
490 if i == 0 {
491 let delta = self.deltas.get_dc(&mut br)?;
492 apply_delta!(udata, cur_off + i, stride, upred, delta);
493 let delta = self.deltas.get_dc(&mut br)?;
494 apply_delta!(vdata, cur_off + i, stride, vpred, delta);
495 } else {
496 udata[cur_off + i] = udata[cur_off + i - 1];
497 vdata[cur_off + i] = vdata[cur_off + i - 1];
498 }
499 if (i & 3) == 0 {
500 let delta = self.deltas.get_dy(&mut br)?;
501 apply_delta!(ydata, cur_off + i, stride, ypred, delta);
502 } else {
503 ydata[cur_off + i] = ydata[cur_off + i - 1];
504 }
505 }
506 },
507 15 => { // c2y1
508 for i in 0..8 {
509 if i == 0 {
510 let delta = self.deltas.get_dc(&mut br)?;
511 apply_delta!(udata, cur_off + i, stride, upred, delta);
512 let delta = self.deltas.get_dc(&mut br)?;
513 apply_delta!(vdata, cur_off + i, stride, vpred, delta);
514 let delta = self.deltas.get_dy(&mut br)?;
515 apply_delta!(ydata, cur_off + i, stride, ypred, delta);
516 } else {
517 udata[cur_off + i] = udata[cur_off + i - 1];
518 vdata[cur_off + i] = vdata[cur_off + i - 1];
519 ydata[cur_off + i] = ydata[cur_off + i - 1];
520 }
521 }
522 },
523 CPARAM_NONE => {
524 copy_line!(ydata, cur_off, stride);
525 copy_line!(udata, cur_off, stride);
526 copy_line!(vdata, cur_off, stride);
527 ypred = 0;
528 upred = 0;
529 vpred = 0;
530 },
531 CPARAM_MV => {
532 let src_x = (bx as i16) * 8 + self.blk_info[x].mv_x;
533 let src_y = ((by * 8 + line) as i16) + self.blk_info[x].mv_y;
534 validate!(src_x >= 0 && (src_x as usize) + 8 <= self.width);
535 validate!(src_y >= 0 && (src_y as usize) + 1 <= self.height);
536 let ref_off = (src_x as usize) + ((src_y + 1) as usize) * stride;
537 for i in 0..8 {
538 ydata[cur_off + i] = self.ref_frame.ydata[ref_off + i];
539 udata[cur_off + i] = self.ref_frame.udata[ref_off + i];
540 vdata[cur_off + i] = self.ref_frame.vdata[ref_off + i];
541 }
542 ypred = ydata[cur_off + 7] - ydata[cur_off + 7 - stride];
543 upred = udata[cur_off + 7] - udata[cur_off + 7 - stride];
544 vpred = vdata[cur_off + 7] - vdata[cur_off + 7 - stride];
545 },
546 _ => unreachable!(),
547 }
548 }
549 }
550 }
551 pos += 8 * stride;
552 }
553
554 Ok(())
555 }
556 }
557
558 impl NADecoder for TM2XDecoder {
559 fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {
560 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
561 let fmt = NAPixelFormaton::new(ColorModel::YUV(YUVSubmodel::YUVJ),
562 Some(NAPixelChromaton::new(0, 0, false, 8, 0, 0, 1)),
563 Some(NAPixelChromaton::new(0, 0, false, 8, 0, 1, 1)),
564 Some(NAPixelChromaton::new(0, 0, false, 8, 0, 2, 1)),
565 None, None, 0, 3);
566 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, fmt));
567 self.width = vinfo.get_width();
568 self.height = vinfo.get_height();
569 self.cur_frame.resize(self.width, self.height);
570 self.ref_frame.resize(self.width, self.height);
571 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
572 Ok(())
573 } else {
574 Err(DecoderError::InvalidData)
575 }
576 }
577 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
578 let src = pkt.get_buffer();
579 validate!(src.len() > 8);
580 let mut mr = MemoryReader::new_read(&src);
581 let mut br = ByteReader::new(&mut mr);
582 let mut dec = Decryptor::default();
583
584 let mut initialised = false;
585 let mut got_key = false;
586 let mut data_size = 0;
587 self.cparams = [[CPARAM_MISSING; 8]; NUM_CPARAMS];
588 self.is_intra = false;
589 while br.left() >= 8 {
590 let magic = br.read_u24be()?;
591 let ctype = br.read_byte()?;
592 let size = br.read_u32be()? as usize;
593 validate!(magic == 0xA00001 && br.left() >= (size as i64));
594 if ctype == 0x06 {
595 validate!(size >= 4);
596 let key = br.read_u32be()?;
597 validate!((key as usize) == size - 4);
598 dec.set_state(key);
599 data_size = size - 4;
600 br.read_skip(size - 4)?;
601 got_key = true;
602 continue;
603 }
604 self.dec_buf.resize(size, 0);
605 br.read_buf(&mut self.dec_buf)?;
606 if ctype != 0x0A {
607 dec.decrypt(&mut self.dec_buf);
608 }
609 match ctype {
610 0x08 | 0x0C | 0x10 | 0x11 | 0x15 | 0x16 => {
611 if ctype < 0x15 { // old versions are not encrypted, roll back and zero key
612 dec.decrypt(&mut self.dec_buf);
613 dec.set_state(0);
614 got_key = true;
615 }
616 validate!(got_key && !initialised);
617 match ctype {
618 0x08 => self.parse_init(0)?,
619 0x0C => self.parse_init(1)?,
620 0x10 => self.parse_init(2)?,
621 0x11 => self.parse_init(3)?,
622 0x15 => self.parse_init(4)?,
623 0x16 => self.parse_init(5)?,
624 _ => unreachable!(),
625 };
626 initialised = true;
627 },
628 0x09 => {
629 validate!(initialised);
630 validate!(self.dec_buf.len() == 3);
631 validate!(self.dec_buf[0] == 8);
632 validate!(self.dec_buf[1] > 0);
633 validate!(self.dec_buf[2] == 1);
634 self.tile_size = self.dec_buf[1] as usize;
635 self.blk_info.resize(self.tile_size, BlkInfo::default());
636 },
637 0x0B => {
638 validate!(initialised);
639 validate!(self.dec_buf.len() == 4);
640 let idx = self.dec_buf[3] as usize;
641 validate!(idx < NUM_CPARAMS);
642 validate!((self.dec_buf[0] as usize) < TM2X_CODING_PARAMS.len());
643 if self.dec_buf[0] != 0 {
644 let tab = &TM2X_CODING_PARAMS[self.dec_buf[0] as usize];
645 let m0 = tab[0] as usize;
646 let m1 = tab[1] as usize;
647 let m2 = tab[2] as usize;
648 let m3 = tab[3] as usize;
649 let full_mode = (m2 * 4 + m0) as u8;
650 let lores_mode = m0 as u8;
651 for i in 0..8 {
652 if (i % m1) == 0 && (i % m3) == 0 {
653 self.cparams[idx][i] = full_mode;
654 } else if (i % m1) == 0 {
655 self.cparams[idx][i] = lores_mode;
656 } else {
657 self.cparams[idx][i] = CPARAM_NONE;
658 }
659 }
660 } else {
661 for i in 0..8 { self.cparams[idx][i] = CPARAM_MV; }
662 }
663 },
664 0x02 => {
665 validate!(initialised);
666 self.parse_tabs()?;
667 },
668 0x0A => {
669 validate!(initialised);
670 self.parse_cb_desc(0xA)?;
671 },
672 _ => { unimplemented!(); },
673 };
674 }
675 if !self.is_intra {
676 std::mem::swap(&mut self.cur_frame, &mut self.ref_frame);
677 }
678 self.decode_frame(&src[12..][..data_size])?;
679
680 let myinfo = self.info.get_properties().get_video_info().unwrap();
681 let bufret = alloc_video_buffer(myinfo, 2);
682 if let Err(_) = bufret { return Err(DecoderError::InvalidData); }
683 let bufinfo = bufret.unwrap();
684 let mut buf = bufinfo.get_vbuf().unwrap();
685
686 self.output_frame(&mut buf);
687
688 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
689 frm.set_keyframe(self.is_intra);
690 frm.set_frame_type(if self.is_intra { FrameType::I } else { FrameType::P });
691 Ok(Rc::new(RefCell::new(frm)))
692 }
693 }
694
695 pub fn get_decoder() -> Box<NADecoder> {
696 Box::new(TM2XDecoder::new())
697 }
698
699 #[cfg(test)]
700 mod test {
701 use nihav_core::codecs::RegisteredDecoders;
702 use nihav_core::demuxers::RegisteredDemuxers;
703 use nihav_core::test::dec_video::*;
704 use crate::codecs::duck_register_all_codecs;
705 use nihav_commonfmt::demuxers::generic_register_all_demuxers;
706 #[test]
707 fn test_tm2x() {
708 let mut dmx_reg = RegisteredDemuxers::new();
709 generic_register_all_demuxers(&mut dmx_reg);
710 let mut dec_reg = RegisteredDecoders::new();
711 duck_register_all_codecs(&mut dec_reg);
712
713 test_file_decoding("avi", "assets/Duck/TM2x.avi", Some(16), true, false, None/*Some("tm2x")*/, &dmx_reg, &dec_reg);
714 }
715 }
716
717 const TM2X_CODING_PARAMS: [[u8; 4]; 25] = [
718 [ 0, 0, 0, 0 ], [ 0, 1, 1, 1 ], [ 0, 1, 1, 2 ], [ 0, 1, 2, 4 ], [ 1, 1, 2, 4 ],
719 [ 0, 2, 2, 4 ], [ 1, 2, 2, 4 ], [ 2, 2, 2, 4 ], [ 1, 4, 2, 4 ], [ 2, 4, 2, 4 ],
720 [ 2, 8, 3, 8 ], [ 3, 4, 3, 8 ], [ 3, 8, 3, 8 ], [ 0, 1, 1, 4 ], [ 0, 1, 2, 2 ],
721 [ 0, 2, 1, 4 ], [ 1, 1, 2, 2 ], [ 1, 4, 2, 8 ], [ 2, 2, 3, 4 ], [ 2, 4, 3, 8 ],
722 [ 0, 1, 3, 8 ], [ 1, 2, 3, 8 ], [ 2, 4, 2, 4 ], [ 2, 4, 3, 8 ], [ 3, 8, 3, 8 ]
723 ];
NihAV is a research multimedia framework