[nihav.git] / nihav-indeo / src / codecs / indeo2.rs

use std::rc::Rc;
use std::cell::RefCell;
use nihav_core::io::bitreader::*;
use nihav_core::io::codebook::*;
use nihav_core::formats;
use nihav_core::codecs::*;
use nihav_core::frame::*;

static INDEO2_DELTA_TABLE: [[u8; 256]; 4] = [
    [
      0x80, 0x80, 0x84, 0x84, 0x7C, 0x7C, 0x7F, 0x85,
      0x81, 0x7B, 0x85, 0x7F, 0x7B, 0x81, 0x8C, 0x8C,
      0x74, 0x74, 0x83, 0x8D, 0x7D, 0x73, 0x8D, 0x83,
      0x73, 0x7D, 0x77, 0x89, 0x89, 0x77, 0x89, 0x77,
      0x77, 0x89, 0x8C, 0x95, 0x74, 0x6B, 0x95, 0x8C,
      0x6B, 0x74, 0x7C, 0x90, 0x84, 0x70, 0x90, 0x7C,
      0x70, 0x84, 0x96, 0x96, 0x6A, 0x6A, 0x82, 0x98,
      0x7E, 0x68, 0x98, 0x82, 0x68, 0x7E, 0x97, 0xA2,
      0x69, 0x5E, 0xA2, 0x97, 0x5E, 0x69, 0xA2, 0xA2,
      0x5E, 0x5E, 0x8B, 0xA3, 0x75, 0x5D, 0xA3, 0x8B,
      0x5D, 0x75, 0x71, 0x95, 0x8F, 0x6B, 0x95, 0x71,
      0x6B, 0x8F, 0x78, 0x9D, 0x88, 0x63, 0x9D, 0x78,
      0x63, 0x88, 0x7F, 0xA7, 0x81, 0x59, 0xA7, 0x7F,
      0x59, 0x81, 0xA4, 0xB1, 0x5C, 0x4F, 0xB1, 0xA4,
      0x4F, 0x5C, 0x96, 0xB1, 0x6A, 0x4F, 0xB1, 0x96,
      0x4F, 0x6A, 0xB2, 0xB2, 0x4E, 0x4E, 0x65, 0x9B,
      0x9B, 0x65, 0x9B, 0x65, 0x65, 0x9B, 0x89, 0xB4,
      0x77, 0x4C, 0xB4, 0x89, 0x4C, 0x77, 0x6A, 0xA3,
      0x96, 0x5D, 0xA3, 0x6A, 0x5D, 0x96, 0x73, 0xAC,
      0x8D, 0x54, 0xAC, 0x73, 0x54, 0x8D, 0xB4, 0xC3,
      0x4C, 0x3D, 0xC3, 0xB4, 0x3D, 0x4C, 0xA4, 0xC3,
      0x5C, 0x3D, 0xC3, 0xA4, 0x3D, 0x5C, 0xC4, 0xC4,
      0x3C, 0x3C, 0x96, 0xC6, 0x6A, 0x3A, 0xC6, 0x96,
      0x3A, 0x6A, 0x7C, 0xBA, 0x84, 0x46, 0xBA, 0x7C,
      0x46, 0x84, 0x5B, 0xAB, 0xA5, 0x55, 0xAB, 0x5B,
      0x55, 0xA5, 0x63, 0xB4, 0x9D, 0x4C, 0xB4, 0x63,
      0x4C, 0x9D, 0x86, 0xCA, 0x7A, 0x36, 0xCA, 0x86,
      0x36, 0x7A, 0xB6, 0xD7, 0x4A, 0x29, 0xD7, 0xB6,
      0x29, 0x4A, 0xC8, 0xD7, 0x38, 0x29, 0xD7, 0xC8,
      0x29, 0x38, 0xA4, 0xD8, 0x5C, 0x28, 0xD8, 0xA4,
      0x28, 0x5C, 0x6C, 0xC1, 0x94, 0x3F, 0xC1, 0x6C,
      0x3F, 0x94, 0xD9, 0xD9, 0x27, 0x27, 0x80, 0x80,
   ], [
      0x80, 0x80, 0x85, 0x85, 0x7B, 0x7B, 0x7E, 0x87,
      0x82, 0x79, 0x87, 0x7E, 0x79, 0x82, 0x8F, 0x8F,
      0x71, 0x71, 0x84, 0x8F, 0x7C, 0x71, 0x8F, 0x84,
      0x71, 0x7C, 0x75, 0x8B, 0x8B, 0x75, 0x8B, 0x75,
      0x75, 0x8B, 0x8E, 0x9A, 0x72, 0x66, 0x9A, 0x8E,
      0x66, 0x72, 0x7B, 0x93, 0x85, 0x6D, 0x93, 0x7B,
      0x6D, 0x85, 0x9B, 0x9B, 0x65, 0x65, 0x82, 0x9D,
      0x7E, 0x63, 0x9D, 0x82, 0x63, 0x7E, 0x9B, 0xA8,
      0x65, 0x58, 0xA8, 0x9B, 0x58, 0x65, 0xA9, 0xA9,
      0x57, 0x57, 0x8D, 0xAA, 0x73, 0x56, 0xAA, 0x8D,
      0x56, 0x73, 0x6E, 0x99, 0x92, 0x67, 0x99, 0x6E,
      0x67, 0x92, 0x76, 0xA2, 0x8A, 0x5E, 0xA2, 0x76,
      0x5E, 0x8A, 0x7F, 0xAF, 0x81, 0x51, 0xAF, 0x7F,
      0x51, 0x81, 0xAB, 0xBA, 0x55, 0x46, 0xBA, 0xAB,
      0x46, 0x55, 0x9A, 0xBB, 0x66, 0x45, 0xBB, 0x9A,
      0x45, 0x66, 0xBB, 0xBB, 0x45, 0x45, 0x60, 0xA0,
      0xA0, 0x60, 0xA0, 0x60, 0x60, 0xA0, 0x8B, 0xBE,
      0x75, 0x42, 0xBE, 0x8B, 0x42, 0x75, 0x66, 0xAA,
      0x9A, 0x56, 0xAA, 0x66, 0x56, 0x9A, 0x70, 0xB5,
      0x90, 0x4B, 0xB5, 0x70, 0x4B, 0x90, 0xBE, 0xCF,
      0x42, 0x31, 0xCF, 0xBE, 0x31, 0x42, 0xAB, 0xD0,
      0x55, 0x30, 0xD0, 0xAB, 0x30, 0x55, 0xD1, 0xD1,
      0x2F, 0x2F, 0x9A, 0xD3, 0x66, 0x2D, 0xD3, 0x9A,
      0x2D, 0x66, 0x7B, 0xC5, 0x85, 0x3B, 0xC5, 0x7B,
      0x3B, 0x85, 0x54, 0xB4, 0xAC, 0x4C, 0xB4, 0x54,
      0x4C, 0xAC, 0x5E, 0xBE, 0xA2, 0x42, 0xBE, 0x5E,
      0x42, 0xA2, 0x87, 0xD8, 0x79, 0x28, 0xD8, 0x87,
      0x28, 0x79, 0xC0, 0xE8, 0x40, 0x18, 0xE8, 0xC0,
      0x18, 0x40, 0xD5, 0xE8, 0x2B, 0x18, 0xE8, 0xD5,
      0x18, 0x2B, 0xAB, 0xE9, 0x55, 0x17, 0xE9, 0xAB,
      0x17, 0x55, 0x68, 0xCD, 0x98, 0x33, 0xCD, 0x68,
      0x33, 0x98, 0xEA, 0xEA, 0x16, 0x16, 0x80, 0x80,
    ], [
      0x80, 0x80, 0x86, 0x86, 0x7A, 0x7A, 0x7E, 0x88,
      0x82, 0x78, 0x88, 0x7E, 0x78, 0x82, 0x92, 0x92,
      0x6E, 0x6E, 0x85, 0x92, 0x7B, 0x6E, 0x92, 0x85,
      0x6E, 0x7B, 0x73, 0x8D, 0x8D, 0x73, 0x8D, 0x73,
      0x73, 0x8D, 0x91, 0x9E, 0x6F, 0x62, 0x9E, 0x91,
      0x62, 0x6F, 0x79, 0x97, 0x87, 0x69, 0x97, 0x79,
      0x69, 0x87, 0xA0, 0xA0, 0x60, 0x60, 0x83, 0xA2,
      0x7D, 0x5E, 0xA2, 0x83, 0x5E, 0x7D, 0xA0, 0xB0,
      0x60, 0x50, 0xB0, 0xA0, 0x50, 0x60, 0xB1, 0xB1,
      0x4F, 0x4F, 0x8F, 0xB2, 0x71, 0x4E, 0xB2, 0x8F,
      0x4E, 0x71, 0x6B, 0x9E, 0x95, 0x62, 0x9E, 0x6B,
      0x62, 0x95, 0x74, 0xA9, 0x8C, 0x57, 0xA9, 0x74,
      0x57, 0x8C, 0x7F, 0xB8, 0x81, 0x48, 0xB8, 0x7F,
      0x48, 0x81, 0xB4, 0xC5, 0x4C, 0x3B, 0xC5, 0xB4,
      0x3B, 0x4C, 0x9F, 0xC6, 0x61, 0x3A, 0xC6, 0x9F,
      0x3A, 0x61, 0xC6, 0xC6, 0x3A, 0x3A, 0x59, 0xA7,
      0xA7, 0x59, 0xA7, 0x59, 0x59, 0xA7, 0x8D, 0xCA,
      0x73, 0x36, 0xCA, 0x8D, 0x36, 0x73, 0x61, 0xB2,
      0x9F, 0x4E, 0xB2, 0x61, 0x4E, 0x9F, 0x6D, 0xBF,
      0x93, 0x41, 0xBF, 0x6D, 0x41, 0x93, 0xCA, 0xDF,
      0x36, 0x21, 0xDF, 0xCA, 0x21, 0x36, 0xB3, 0xDF,
      0x4D, 0x21, 0xDF, 0xB3, 0x21, 0x4D, 0xE1, 0xE1,
      0x1F, 0x1F, 0x9F, 0xE3, 0x61, 0x1D, 0xE3, 0x9F,
      0x1D, 0x61, 0x7A, 0xD3, 0x86, 0x2D, 0xD3, 0x7A,
      0x2D, 0x86, 0x4C, 0xBE, 0xB4, 0x42, 0xBE, 0x4C,
      0x42, 0xB4, 0x57, 0xCA, 0xA9, 0x36, 0xCA, 0x57,
      0x36, 0xA9, 0x88, 0xE9, 0x78, 0x17, 0xE9, 0x88,
      0x17, 0x78, 0xCC, 0xFB, 0x34, 0x05, 0xFB, 0xCC,
      0x05, 0x34, 0xE6, 0xFB, 0x1A, 0x05, 0xFB, 0xE6,
      0x05, 0x1A, 0xB4, 0xFD, 0x4C, 0x03, 0xFD, 0xB4,
      0x03, 0x4C, 0x63, 0xDC, 0x9D, 0x24, 0xDC, 0x63,
      0x24, 0x9D, 0xFE, 0xFE, 0x02, 0x02, 0x80, 0x80,
    ], [
      0x80, 0x80, 0x87, 0x87, 0x79, 0x79, 0x7E, 0x89,
      0x82, 0x77, 0x89, 0x7E, 0x77, 0x82, 0x95, 0x95,
      0x6B, 0x6B, 0x86, 0x96, 0x7A, 0x6A, 0x96, 0x86,
      0x6A, 0x7A, 0x70, 0x90, 0x90, 0x70, 0x90, 0x70,
      0x70, 0x90, 0x94, 0xA4, 0x6C, 0x5C, 0xA4, 0x94,
      0x5C, 0x6C, 0x78, 0x9B, 0x88, 0x65, 0x9B, 0x78,
      0x65, 0x88, 0xA6, 0xA6, 0x5A, 0x5A, 0x83, 0xA9,
      0x7D, 0x57, 0xA9, 0x83, 0x57, 0x7D, 0xA6, 0xB9,
      0x5A, 0x47, 0xB9, 0xA6, 0x47, 0x5A, 0xBA, 0xBA,
      0x46, 0x46, 0x92, 0xBC, 0x6E, 0x44, 0xBC, 0x92,
      0x44, 0x6E, 0x67, 0xA3, 0x99, 0x5D, 0xA3, 0x67,
      0x5D, 0x99, 0x72, 0xB0, 0x8E, 0x50, 0xB0, 0x72,
      0x50, 0x8E, 0x7F, 0xC3, 0x81, 0x3D, 0xC3, 0x7F,
      0x3D, 0x81, 0xBE, 0xD2, 0x42, 0x2E, 0xD2, 0xBE,
      0x2E, 0x42, 0xA5, 0xD4, 0x5B, 0x2C, 0xD4, 0xA5,
      0x2C, 0x5B, 0xD4, 0xD4, 0x2C, 0x2C, 0x52, 0xAE,
      0xAE, 0x52, 0xAE, 0x52, 0x52, 0xAE, 0x8F, 0xD8,
      0x71, 0x28, 0xD8, 0x8F, 0x28, 0x71, 0x5B, 0xBB,
      0xA5, 0x45, 0xBB, 0x5B, 0x45, 0xA5, 0x69, 0xCB,
      0x97, 0x35, 0xCB, 0x69, 0x35, 0x97, 0xD8, 0xF0,
      0x28, 0x10, 0xF0, 0xD8, 0x10, 0x28, 0xBD, 0xF1,
      0x43, 0x0F, 0xF1, 0xBD, 0x0F, 0x43, 0xF3, 0xF3,
      0x0D, 0x0D, 0xA5, 0xF6, 0x5B, 0x0A, 0xF6, 0xA5,
      0x0A, 0x5B, 0x78, 0xE2, 0x88, 0x1E, 0xE2, 0x78,
      0x1E, 0x88, 0x42, 0xC9, 0xBE, 0x37, 0xC9, 0x42,
      0x37, 0xBE, 0x4F, 0xD8, 0xB1, 0x28, 0xD8, 0x4F,
      0x28, 0xB1, 0x8A, 0xFD, 0x76, 0x03, 0xFD, 0x8A,
      0x03, 0x76, 0xDB, 0xFF, 0x25, 0x01, 0xFF, 0xDB,
      0x01, 0x25, 0xF9, 0xFF, 0x07, 0x01, 0xFF, 0xF9,
      0x01, 0x07, 0xBE, 0xFF, 0x42, 0x01, 0xFF, 0xBE,
      0x01, 0x42, 0x5E, 0xED, 0xA2, 0x13, 0xED, 0x5E,
      0x13, 0xA2, 0xFF, 0xFF, 0x01, 0x01, 0x80, 0x80,
    ]
];

static INDEO2_CODE_CODES: &[u16] = &[
    0x0000, 0x0004, 0x0006, 0x0001, 0x0009, 0x0019, 0x000D, 0x001D,
    0x0023, 0x0013, 0x0033, 0x000B, 0x002B, 0x001B, 0x0007, 0x0087,
    0x0027, 0x00A7, 0x0067, 0x00E7, 0x0097, 0x0057, 0x0037, 0x00B7,
    0x00F7, 0x000F, 0x008F, 0x018F, 0x014F, 0x00CF, 0x002F, 0x012F,
    0x01AF, 0x006F, 0x00EF, 0x01EF, 0x001F, 0x021F, 0x011F, 0x031F,
    0x009F, 0x029F, 0x019F, 0x039F, 0x005F, 0x025F, 0x015F, 0x035F,
    0x00DF, 0x02DF, 0x01DF, 0x03DF, 0x003F, 0x103F, 0x083F, 0x183F,
    0x043F, 0x143F, 0x0C3F, 0x1C3F, 0x023F, 0x123F, 0x0A3F, 0x1A3F,
    0x063F, 0x163F, 0x0E3F, 0x1E3F, 0x013F, 0x113F, 0x093F, 0x193F,
    0x053F, 0x153F, 0x0D3F, 0x1D3F, 0x033F, 0x133F, 0x0B3F, 0x1B3F,
    0x073F, 0x173F, 0x0F3F, 0x1F3F, 0x00BF, 0x10BF, 0x08BF, 0x18BF,
    0x04BF, 0x14BF, 0x0CBF, 0x1CBF, 0x02BF, 0x12BF, 0x0ABF, 0x1ABF,
    0x06BF, 0x16BF, 0x0EBF, 0x1EBF, 0x01BF, 0x11BF, 0x09BF, 0x19BF,
    0x05BF, 0x15BF, 0x0DBF, 0x1DBF, 0x03BF, 0x13BF, 0x0BBF, 0x1BBF,
    0x07BF, 0x17BF, 0x0FBF, 0x1FBF, 0x007F, 0x207F, 0x107F, 0x307F,
    0x087F, 0x287F, 0x187F, 0x387F, 0x047F, 0x247F, 0x147F, 0x0002,
    0x0011, 0x0005, 0x0015, 0x0003, 0x003B, 0x0047, 0x00C7, 0x0017,
    0x00D7, 0x0077, 0x010F, 0x004F, 0x01CF, 0x00AF, 0x016F
];

static INDEO2_CODE_LENGTHS: &[u8] = &[
     3,  3,  3,  5,  5,  5,  5,  5,  6,  6,  6,  6,  6,  6,  8,  8,
     8,  8,  8,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,
     9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
    10, 10, 10, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
    13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,  3,
     5,  5,  5,  6,  6,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9
];

struct IR2CodeReader { }

impl CodebookDescReader<u8> for IR2CodeReader {
    fn bits(&mut self, idx: usize) -> u8  { INDEO2_CODE_LENGTHS[idx] }
    fn code(&mut self, idx: usize) -> u32 { INDEO2_CODE_CODES[idx] as u32 }
    fn sym (&mut self, idx: usize) -> u8 {
        if idx < 0x7F { (idx + 1) as u8 } else { (idx + 2) as u8 }
    }
    fn len(&mut self) -> usize { INDEO2_CODE_LENGTHS.len() }
}

struct Indeo2Decoder {
    info:    Rc<NACodecInfo>,
    cb:      Codebook<u8>,
    frmmgr:  HAMShuffler,
}

impl Indeo2Decoder {
    fn new() -> Self {
        let dummy_info = Rc::new(DUMMY_CODEC_INFO);
        let mut coderead = IR2CodeReader{};
        let cb = Codebook::new(&mut coderead, CodebookMode::LSB).unwrap();
        Indeo2Decoder { info: dummy_info, cb: cb, frmmgr: HAMShuffler::new() }
    }

    fn decode_plane_intra(&self, br: &mut BitReader,
                          buf: &mut NAVideoBuffer<u8>, planeno: usize,
                          tableno: usize) -> DecoderResult<()> {
        let offs = buf.get_offset(planeno);
        let (w, h) = buf.get_dimensions(planeno);
        let stride = buf.get_stride(planeno);
        let cb = &self.cb;

        let mut data = buf.get_data_mut();
        let framebuf: &mut [u8] = data.as_mut_slice();

        let table = &INDEO2_DELTA_TABLE[tableno];

        let mut base = offs;
        let mut x: usize = 0;
        while x < w {
            let idx = br.read_cb(cb)? as usize;
            if idx >= 0x80 {
                let run = (idx - 0x80) * 2;
                if x + run > w { return Err(DecoderError::InvalidData); }
                for i in 0..run {
                    framebuf[base + x + i] = 0x80;
                }
                x += run;
            } else {
                framebuf[base + x + 0] = table[(idx * 2 + 0) as usize];
                framebuf[base + x + 1] = table[(idx * 2 + 1) as usize];
                x += 2;
            }
        }
        base += stride;
        for _ in 1..h {
            let mut x: usize = 0;
            while x < w {
                let idx = br.read_cb(cb)? as usize;
                if idx >= 0x80 {
                    let run = (idx - 0x80) * 2;
                    if x + run > w { return Err(DecoderError::InvalidData); }
                    for i in 0..run {
                        framebuf[base + x + i] = framebuf[base + x + i - stride];
                    }
                    x += run;
                } else {
                    let delta0 = (table[idx * 2 + 0] as i16) - 0x80;
                    let delta1 = (table[idx * 2 + 1] as i16) - 0x80;
                    let mut pix0 = framebuf[base + x + 0 - stride] as i16;
                    let mut pix1 = framebuf[base + x + 1 - stride] as i16;
                    pix0 += delta0;
                    pix1 += delta1;
                    if pix0 < 0 { pix0 = 0; }
                    if pix1 < 0 { pix1 = 0; }
                    if pix0 > 255 { pix0 = 255; }
                    if pix1 > 255 { pix1 = 255; }
                    framebuf[base + x + 0] = pix0 as u8;
                    framebuf[base + x + 1] = pix1 as u8;
                    x += 2;
                }
            }
            base += stride;
        }
        Ok(())
    }

    fn decode_plane_inter(&self, br: &mut BitReader,
                          buf: &mut NAVideoBuffer<u8>, planeno: usize,
                          tableno: usize) -> DecoderResult<()> {
        let offs = buf.get_offset(planeno);
        let (w, h) = buf.get_dimensions(planeno);
        let stride = buf.get_stride(planeno);
        let cb = &self.cb;

        let mut data = buf.get_data_mut();
        let framebuf: &mut [u8] = data.as_mut_slice();

        let table = &INDEO2_DELTA_TABLE[tableno];

        let mut base = offs;
        for _ in 0..h {
            let mut x: usize = 0;
            while x < w {
                let idx = br.read_cb(cb)? as usize;
                if idx >= 0x80 {
                    let run = (idx - 0x80) * 2;
                    if x + run > w { return Err(DecoderError::InvalidData); }
                    x += run;
                } else {
                    let delta0 = (table[idx * 2 + 0] as i16) - 0x80;
                    let delta1 = (table[idx * 2 + 1] as i16) - 0x80;
                    let mut pix0 = framebuf[base + x + 0] as i16;
                    let mut pix1 = framebuf[base + x + 1] as i16;
                    pix0 += delta0 * 3 >> 2;
                    pix1 += delta1 * 3 >> 2;
                    if pix0 < 0 { pix0 = 0; }
                    if pix1 < 0 { pix1 = 0; }
                    if pix0 > 255 { pix0 = 255; }
                    if pix1 > 255 { pix1 = 255; }
                    framebuf[base + x + 0] = pix0 as u8;
                    framebuf[base + x + 1] = pix1 as u8;
                    x += 2;
                }
            }
            base += stride;
        }
        Ok(())
    }
}

const IR2_START: usize = 48;

impl NADecoder for Indeo2Decoder {
    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
        if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
            let w = vinfo.get_width();
            let h = vinfo.get_height();
            let f = vinfo.is_flipped();
            let fmt = formats::YUV410_FORMAT;
            let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, f, fmt));
            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
            self.frmmgr.clear();
            Ok(())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
        let src = pkt.get_buffer();
        if src.len() <= IR2_START { return Err(DecoderError::ShortData); }
        let interframe = src[18];
        let tabs = src[34];
        let mut br = BitReader::new(&src[IR2_START..], src.len() - IR2_START, BitReaderMode::LE);
        let luma_tab = tabs & 3;
        let chroma_tab = (tabs >> 2) & 3;
        if interframe != 0 {
            let vinfo = self.info.get_properties().get_video_info().unwrap();
            let bufret = alloc_video_buffer(vinfo, 2);
            if let Err(_) = bufret { return Err(DecoderError::InvalidData); }
            let mut bufinfo = bufret.unwrap();
            let mut buf = bufinfo.get_vbuf().unwrap();
            for plane in 0..3 {
                let tabidx = (if plane == 0 { luma_tab } else { chroma_tab }) as usize;
                self.decode_plane_intra(&mut br, &mut buf, plane, tabidx)?;
            }
            self.frmmgr.add_frame(buf);
            let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
            frm.set_keyframe(true);
            frm.set_frame_type(FrameType::I);
            Ok(Rc::new(RefCell::new(frm)))
        } else {
            let bufret = self.frmmgr.clone_ref();
            if let None = bufret { return Err(DecoderError::MissingReference); }
            let mut buf = bufret.unwrap();

            for plane in 0..3 {
                let tabidx = (if plane == 0 { luma_tab } else { chroma_tab }) as usize;
                self.decode_plane_inter(&mut br, &mut buf, plane, tabidx)?;
            }
            let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::Video(buf));
            frm.set_keyframe(false);
            frm.set_frame_type(FrameType::P);
            Ok(Rc::new(RefCell::new(frm)))
        }
    }
}

pub fn get_decoder() -> Box<NADecoder> {
    Box::new(Indeo2Decoder::new())
}

#[cfg(test)]
mod test {
    use nihav_core::codecs::RegisteredDecoders;
    use nihav_core::demuxers::RegisteredDemuxers;
    use nihav_core::test::dec_video::*;
    use crate::codecs::indeo_register_all_codecs;
    use nihav_commonfmt::demuxers::generic_register_all_demuxers;
    #[test]
    fn test_indeo2() {
        let mut dmx_reg = RegisteredDemuxers::new();
        generic_register_all_demuxers(&mut dmx_reg);
        let mut dec_reg = RegisteredDecoders::new();
        indeo_register_all_codecs(&mut dec_reg);

        test_file_decoding("avi", "assets/laser05.avi", Some(10), true, false, None, &dmx_reg, &dec_reg);
    }
}
Commit	Line	Data
5641dccf KS	1	use std::rc::Rc;
	2	use std::cell::RefCell;
	3	use nihav_core::io::bitreader::*;
	4	use nihav_core::io::codebook::*;
	5	use nihav_core::formats;
	6	use nihav_core::codecs::*;
	7	use nihav_core::frame::*;
77d06de2 KS	8
	9	static INDEO2_DELTA_TABLE: [[u8; 256]; 4] = [
	10	[
	11	0x80, 0x80, 0x84, 0x84, 0x7C, 0x7C, 0x7F, 0x85,
	12	0x81, 0x7B, 0x85, 0x7F, 0x7B, 0x81, 0x8C, 0x8C,
	13	0x74, 0x74, 0x83, 0x8D, 0x7D, 0x73, 0x8D, 0x83,
	14	0x73, 0x7D, 0x77, 0x89, 0x89, 0x77, 0x89, 0x77,
	15	0x77, 0x89, 0x8C, 0x95, 0x74, 0x6B, 0x95, 0x8C,
	16	0x6B, 0x74, 0x7C, 0x90, 0x84, 0x70, 0x90, 0x7C,
	17	0x70, 0x84, 0x96, 0x96, 0x6A, 0x6A, 0x82, 0x98,
	18	0x7E, 0x68, 0x98, 0x82, 0x68, 0x7E, 0x97, 0xA2,
	19	0x69, 0x5E, 0xA2, 0x97, 0x5E, 0x69, 0xA2, 0xA2,
	20	0x5E, 0x5E, 0x8B, 0xA3, 0x75, 0x5D, 0xA3, 0x8B,
	21	0x5D, 0x75, 0x71, 0x95, 0x8F, 0x6B, 0x95, 0x71,
	22	0x6B, 0x8F, 0x78, 0x9D, 0x88, 0x63, 0x9D, 0x78,
	23	0x63, 0x88, 0x7F, 0xA7, 0x81, 0x59, 0xA7, 0x7F,
	24	0x59, 0x81, 0xA4, 0xB1, 0x5C, 0x4F, 0xB1, 0xA4,
	25	0x4F, 0x5C, 0x96, 0xB1, 0x6A, 0x4F, 0xB1, 0x96,
	26	0x4F, 0x6A, 0xB2, 0xB2, 0x4E, 0x4E, 0x65, 0x9B,
	27	0x9B, 0x65, 0x9B, 0x65, 0x65, 0x9B, 0x89, 0xB4,
	28	0x77, 0x4C, 0xB4, 0x89, 0x4C, 0x77, 0x6A, 0xA3,
	29	0x96, 0x5D, 0xA3, 0x6A, 0x5D, 0x96, 0x73, 0xAC,
	30	0x8D, 0x54, 0xAC, 0x73, 0x54, 0x8D, 0xB4, 0xC3,
	31	0x4C, 0x3D, 0xC3, 0xB4, 0x3D, 0x4C, 0xA4, 0xC3,
	32	0x5C, 0x3D, 0xC3, 0xA4, 0x3D, 0x5C, 0xC4, 0xC4,
	33	0x3C, 0x3C, 0x96, 0xC6, 0x6A, 0x3A, 0xC6, 0x96,
	34	0x3A, 0x6A, 0x7C, 0xBA, 0x84, 0x46, 0xBA, 0x7C,
	35	0x46, 0x84, 0x5B, 0xAB, 0xA5, 0x55, 0xAB, 0x5B,
	36	0x55, 0xA5, 0x63, 0xB4, 0x9D, 0x4C, 0xB4, 0x63,
	37	0x4C, 0x9D, 0x86, 0xCA, 0x7A, 0x36, 0xCA, 0x86,
	38	0x36, 0x7A, 0xB6, 0xD7, 0x4A, 0x29, 0xD7, 0xB6,
	39	0x29, 0x4A, 0xC8, 0xD7, 0x38, 0x29, 0xD7, 0xC8,
	40	0x29, 0x38, 0xA4, 0xD8, 0x5C, 0x28, 0xD8, 0xA4,
	41	0x28, 0x5C, 0x6C, 0xC1, 0x94, 0x3F, 0xC1, 0x6C,
	42	0x3F, 0x94, 0xD9, 0xD9, 0x27, 0x27, 0x80, 0x80,
	43	], [
	44	0x80, 0x80, 0x85, 0x85, 0x7B, 0x7B, 0x7E, 0x87,
	45	0x82, 0x79, 0x87, 0x7E, 0x79, 0x82, 0x8F, 0x8F,
	46	0x71, 0x71, 0x84, 0x8F, 0x7C, 0x71, 0x8F, 0x84,
	47	0x71, 0x7C, 0x75, 0x8B, 0x8B, 0x75, 0x8B, 0x75,
	48	0x75, 0x8B, 0x8E, 0x9A, 0x72, 0x66, 0x9A, 0x8E,
	49	0x66, 0x72, 0x7B, 0x93, 0x85, 0x6D, 0x93, 0x7B,
	50	0x6D, 0x85, 0x9B, 0x9B, 0x65, 0x65, 0x82, 0x9D,
	51	0x7E, 0x63, 0x9D, 0x82, 0x63, 0x7E, 0x9B, 0xA8,
	52	0x65, 0x58, 0xA8, 0x9B, 0x58, 0x65, 0xA9, 0xA9,
	53	0x57, 0x57, 0x8D, 0xAA, 0x73, 0x56, 0xAA, 0x8D,
	54	0x56, 0x73, 0x6E, 0x99, 0x92, 0x67, 0x99, 0x6E,
	55	0x67, 0x92, 0x76, 0xA2, 0x8A, 0x5E, 0xA2, 0x76,
	56	0x5E, 0x8A, 0x7F, 0xAF, 0x81, 0x51, 0xAF, 0x7F,
	57	0x51, 0x81, 0xAB, 0xBA, 0x55, 0x46, 0xBA, 0xAB,
	58	0x46, 0x55, 0x9A, 0xBB, 0x66, 0x45, 0xBB, 0x9A,
	59	0x45, 0x66, 0xBB, 0xBB, 0x45, 0x45, 0x60, 0xA0,
	60	0xA0, 0x60, 0xA0, 0x60, 0x60, 0xA0, 0x8B, 0xBE,
	61	0x75, 0x42, 0xBE, 0x8B, 0x42, 0x75, 0x66, 0xAA,
	62	0x9A, 0x56, 0xAA, 0x66, 0x56, 0x9A, 0x70, 0xB5,
	63	0x90, 0x4B, 0xB5, 0x70, 0x4B, 0x90, 0xBE, 0xCF,
	64	0x42, 0x31, 0xCF, 0xBE, 0x31, 0x42, 0xAB, 0xD0,
	65	0x55, 0x30, 0xD0, 0xAB, 0x30, 0x55, 0xD1, 0xD1,
	66	0x2F, 0x2F, 0x9A, 0xD3, 0x66, 0x2D, 0xD3, 0x9A,
	67	0x2D, 0x66, 0x7B, 0xC5, 0x85, 0x3B, 0xC5, 0x7B,
	68	0x3B, 0x85, 0x54, 0xB4, 0xAC, 0x4C, 0xB4, 0x54,
	69	0x4C, 0xAC, 0x5E, 0xBE, 0xA2, 0x42, 0xBE, 0x5E,
	70	0x42, 0xA2, 0x87, 0xD8, 0x79, 0x28, 0xD8, 0x87,
	71	0x28, 0x79, 0xC0, 0xE8, 0x40, 0x18, 0xE8, 0xC0,
72	0x18, 0x40, 0xD5, 0xE8, 0x2B, 0x18, 0xE8, 0xD5,
73	0x18, 0x2B, 0xAB, 0xE9, 0x55, 0x17, 0xE9, 0xAB,
74	0x17, 0x55, 0x68, 0xCD, 0x98, 0x33, 0xCD, 0x68,
75	0x33, 0x98, 0xEA, 0xEA, 0x16, 0x16, 0x80, 0x80,
76	], [
77	0x80, 0x80, 0x86, 0x86, 0x7A, 0x7A, 0x7E, 0x88,
78	0x82, 0x78, 0x88, 0x7E, 0x78, 0x82, 0x92, 0x92,
79	0x6E, 0x6E, 0x85, 0x92, 0x7B, 0x6E, 0x92, 0x85,
80	0x6E, 0x7B, 0x73, 0x8D, 0x8D, 0x73, 0x8D, 0x73,
81	0x73, 0x8D, 0x91, 0x9E, 0x6F, 0x62, 0x9E, 0x91,
82	0x62, 0x6F, 0x79, 0x97, 0x87, 0x69, 0x97, 0x79,
83	0x69, 0x87, 0xA0, 0xA0, 0x60, 0x60, 0x83, 0xA2,
84	0x7D, 0x5E, 0xA2, 0x83, 0x5E, 0x7D, 0xA0, 0xB0,
85	0x60, 0x50, 0xB0, 0xA0, 0x50, 0x60, 0xB1, 0xB1,
86	0x4F, 0x4F, 0x8F, 0xB2, 0x71, 0x4E, 0xB2, 0x8F,
87	0x4E, 0x71, 0x6B, 0x9E, 0x95, 0x62, 0x9E, 0x6B,
88	0x62, 0x95, 0x74, 0xA9, 0x8C, 0x57, 0xA9, 0x74,
89	0x57, 0x8C, 0x7F, 0xB8, 0x81, 0x48, 0xB8, 0x7F,
90	0x48, 0x81, 0xB4, 0xC5, 0x4C, 0x3B, 0xC5, 0xB4,
91	0x3B, 0x4C, 0x9F, 0xC6, 0x61, 0x3A, 0xC6, 0x9F,
92	0x3A, 0x61, 0xC6, 0xC6, 0x3A, 0x3A, 0x59, 0xA7,
93	0xA7, 0x59, 0xA7, 0x59, 0x59, 0xA7, 0x8D, 0xCA,
94	0x73, 0x36, 0xCA, 0x8D, 0x36, 0x73, 0x61, 0xB2,
95	0x9F, 0x4E, 0xB2, 0x61, 0x4E, 0x9F, 0x6D, 0xBF,
96	0x93, 0x41, 0xBF, 0x6D, 0x41, 0x93, 0xCA, 0xDF,
97	0x36, 0x21, 0xDF, 0xCA, 0x21, 0x36, 0xB3, 0xDF,
98	0x4D, 0x21, 0xDF, 0xB3, 0x21, 0x4D, 0xE1, 0xE1,
99	0x1F, 0x1F, 0x9F, 0xE3, 0x61, 0x1D, 0xE3, 0x9F,
100	0x1D, 0x61, 0x7A, 0xD3, 0x86, 0x2D, 0xD3, 0x7A,
101	0x2D, 0x86, 0x4C, 0xBE, 0xB4, 0x42, 0xBE, 0x4C,
102	0x42, 0xB4, 0x57, 0xCA, 0xA9, 0x36, 0xCA, 0x57,
103	0x36, 0xA9, 0x88, 0xE9, 0x78, 0x17, 0xE9, 0x88,
104	0x17, 0x78, 0xCC, 0xFB, 0x34, 0x05, 0xFB, 0xCC,
105	0x05, 0x34, 0xE6, 0xFB, 0x1A, 0x05, 0xFB, 0xE6,
106	0x05, 0x1A, 0xB4, 0xFD, 0x4C, 0x03, 0xFD, 0xB4,
107	0x03, 0x4C, 0x63, 0xDC, 0x9D, 0x24, 0xDC, 0x63,
108	0x24, 0x9D, 0xFE, 0xFE, 0x02, 0x02, 0x80, 0x80,
109	], [
110	0x80, 0x80, 0x87, 0x87, 0x79, 0x79, 0x7E, 0x89,
111	0x82, 0x77, 0x89, 0x7E, 0x77, 0x82, 0x95, 0x95,
112	0x6B, 0x6B, 0x86, 0x96, 0x7A, 0x6A, 0x96, 0x86,
113	0x6A, 0x7A, 0x70, 0x90, 0x90, 0x70, 0x90, 0x70,
114	0x70, 0x90, 0x94, 0xA4, 0x6C, 0x5C, 0xA4, 0x94,
115	0x5C, 0x6C, 0x78, 0x9B, 0x88, 0x65, 0x9B, 0x78,
116	0x65, 0x88, 0xA6, 0xA6, 0x5A, 0x5A, 0x83, 0xA9,
117	0x7D, 0x57, 0xA9, 0x83, 0x57, 0x7D, 0xA6, 0xB9,
118	0x5A, 0x47, 0xB9, 0xA6, 0x47, 0x5A, 0xBA, 0xBA,
119	0x46, 0x46, 0x92, 0xBC, 0x6E, 0x44, 0xBC, 0x92,
120	0x44, 0x6E, 0x67, 0xA3, 0x99, 0x5D, 0xA3, 0x67,
121	0x5D, 0x99, 0x72, 0xB0, 0x8E, 0x50, 0xB0, 0x72,
122	0x50, 0x8E, 0x7F, 0xC3, 0x81, 0x3D, 0xC3, 0x7F,
123	0x3D, 0x81, 0xBE, 0xD2, 0x42, 0x2E, 0xD2, 0xBE,
124	0x2E, 0x42, 0xA5, 0xD4, 0x5B, 0x2C, 0xD4, 0xA5,
125	0x2C, 0x5B, 0xD4, 0xD4, 0x2C, 0x2C, 0x52, 0xAE,
126	0xAE, 0x52, 0xAE, 0x52, 0x52, 0xAE, 0x8F, 0xD8,
127	0x71, 0x28, 0xD8, 0x8F, 0x28, 0x71, 0x5B, 0xBB,
128	0xA5, 0x45, 0xBB, 0x5B, 0x45, 0xA5, 0x69, 0xCB,
129	0x97, 0x35, 0xCB, 0x69, 0x35, 0x97, 0xD8, 0xF0,
130	0x28, 0x10, 0xF0, 0xD8, 0x10, 0x28, 0xBD, 0xF1,
131	0x43, 0x0F, 0xF1, 0xBD, 0x0F, 0x43, 0xF3, 0xF3,
132	0x0D, 0x0D, 0xA5, 0xF6, 0x5B, 0x0A, 0xF6, 0xA5,
133	0x0A, 0x5B, 0x78, 0xE2, 0x88, 0x1E, 0xE2, 0x78,
134	0x1E, 0x88, 0x42, 0xC9, 0xBE, 0x37, 0xC9, 0x42,
135	0x37, 0xBE, 0x4F, 0xD8, 0xB1, 0x28, 0xD8, 0x4F,
136	0x28, 0xB1, 0x8A, 0xFD, 0x76, 0x03, 0xFD, 0x8A,
137	0x03, 0x76, 0xDB, 0xFF, 0x25, 0x01, 0xFF, 0xDB,
138	0x01, 0x25, 0xF9, 0xFF, 0x07, 0x01, 0xFF, 0xF9,
139	0x01, 0x07, 0xBE, 0xFF, 0x42, 0x01, 0xFF, 0xBE,
140	0x01, 0x42, 0x5E, 0xED, 0xA2, 0x13, 0xED, 0x5E,
141	0x13, 0xA2, 0xFF, 0xFF, 0x01, 0x01, 0x80, 0x80,
142	]
143	];
144
145	static INDEO2_CODE_CODES: &[u16] = &[
146	0x0000, 0x0004, 0x0006, 0x0001, 0x0009, 0x0019, 0x000D, 0x001D,
147	0x0023, 0x0013, 0x0033, 0x000B, 0x002B, 0x001B, 0x0007, 0x0087,
148	0x0027, 0x00A7, 0x0067, 0x00E7, 0x0097, 0x0057, 0x0037, 0x00B7,
149	0x00F7, 0x000F, 0x008F, 0x018F, 0x014F, 0x00CF, 0x002F, 0x012F,
150	0x01AF, 0x006F, 0x00EF, 0x01EF, 0x001F, 0x021F, 0x011F, 0x031F,
151	0x009F, 0x029F, 0x019F, 0x039F, 0x005F, 0x025F, 0x015F, 0x035F,
152	0x00DF, 0x02DF, 0x01DF, 0x03DF, 0x003F, 0x103F, 0x083F, 0x183F,
153	0x043F, 0x143F, 0x0C3F, 0x1C3F, 0x023F, 0x123F, 0x0A3F, 0x1A3F,
154	0x063F, 0x163F, 0x0E3F, 0x1E3F, 0x013F, 0x113F, 0x093F, 0x193F,
155	0x053F, 0x153F, 0x0D3F, 0x1D3F, 0x033F, 0x133F, 0x0B3F, 0x1B3F,
156	0x073F, 0x173F, 0x0F3F, 0x1F3F, 0x00BF, 0x10BF, 0x08BF, 0x18BF,
157	0x04BF, 0x14BF, 0x0CBF, 0x1CBF, 0x02BF, 0x12BF, 0x0ABF, 0x1ABF,
158	0x06BF, 0x16BF, 0x0EBF, 0x1EBF, 0x01BF, 0x11BF, 0x09BF, 0x19BF,
159	0x05BF, 0x15BF, 0x0DBF, 0x1DBF, 0x03BF, 0x13BF, 0x0BBF, 0x1BBF,
160	0x07BF, 0x17BF, 0x0FBF, 0x1FBF, 0x007F, 0x207F, 0x107F, 0x307F,
161	0x087F, 0x287F, 0x187F, 0x387F, 0x047F, 0x247F, 0x147F, 0x0002,
162	0x0011, 0x0005, 0x0015, 0x0003, 0x003B, 0x0047, 0x00C7, 0x0017,
163	0x00D7, 0x0077, 0x010F, 0x004F, 0x01CF, 0x00AF, 0x016F
164	];
165
166	static INDEO2_CODE_LENGTHS: &[u8] = &[
167	3, 3, 3, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 8, 8,
168	8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9,
169	9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
170	10, 10, 10, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
171	13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
172	13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
173	13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
174	13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 3,
175	5, 5, 5, 6, 6, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9
176	];
177
178	struct IR2CodeReader { }
179
180	impl CodebookDescReader<u8> for IR2CodeReader {
181	fn bits(&mut self, idx: usize) -> u8 { INDEO2_CODE_LENGTHS[idx] }
182	fn code(&mut self, idx: usize) -> u32 { INDEO2_CODE_CODES[idx] as u32 }
183	fn sym (&mut self, idx: usize) -> u8 {
184	if idx < 0x7F { (idx + 1) as u8 } else { (idx + 2) as u8 }
185	}
186	fn len(&mut self) -> usize { INDEO2_CODE_LENGTHS.len() }
187	}
188
70259941	189	struct Indeo2Decoder {
77d06de2 KS	190	info: Rc<NACodecInfo>,
77d06de2 KS	191	cb: Codebook<u8>,
88c03b61	192	frmmgr: HAMShuffler,
77d06de2 KS	193	}
	194
	195	impl Indeo2Decoder {
70259941	196	fn new() -> Self {
77d06de2 KS	197	let dummy_info = Rc::new(DUMMY_CODEC_INFO);
	198	let mut coderead = IR2CodeReader{};
	199	let cb = Codebook::new(&mut coderead, CodebookMode::LSB).unwrap();
88c03b61	200	Indeo2Decoder { info: dummy_info, cb: cb, frmmgr: HAMShuffler::new() }
77d06de2 KS	201	}
	202
	203	fn decode_plane_intra(&self, br: &mut BitReader,
22cb00db	204	buf: &mut NAVideoBuffer<u8>, planeno: usize,
77d06de2	205	tableno: usize) -> DecoderResult<()> {
22cb00db KS	206	let offs = buf.get_offset(planeno);
	207	let (w, h) = buf.get_dimensions(planeno);
	208	let stride = buf.get_stride(planeno);
77d06de2 KS	209	let cb = &self.cb;
77d06de2 KS	210
22cb00db	211	let mut data = buf.get_data_mut();
9037cf6b	212	let framebuf: &mut [u8] = data.as_mut_slice();
77d06de2 KS	213
	214	let table = &INDEO2_DELTA_TABLE[tableno];
	215
	216	let mut base = offs;
	217	let mut x: usize = 0;
	218	while x < w {
	219	let idx = br.read_cb(cb)? as usize;
	220	if idx >= 0x80 {
	221	let run = (idx - 0x80) * 2;
	222	if x + run > w { return Err(DecoderError::InvalidData); }
	223	for i in 0..run {
	224	framebuf[base + x + i] = 0x80;
	225	}
	226	x += run;
	227	} else {
	228	framebuf[base + x + 0] = table[(idx * 2 + 0) as usize];
	229	framebuf[base + x + 1] = table[(idx * 2 + 1) as usize];
	230	x += 2;
	231	}
	232	}
	233	base += stride;
	234	for _ in 1..h {
	235	let mut x: usize = 0;
	236	while x < w {
	237	let idx = br.read_cb(cb)? as usize;
	238	if idx >= 0x80 {
	239	let run = (idx - 0x80) * 2;
	240	if x + run > w { return Err(DecoderError::InvalidData); }
	241	for i in 0..run {
	242	framebuf[base + x + i] = framebuf[base + x + i - stride];
	243	}
	244	x += run;
	245	} else {
	246	let delta0 = (table[idx * 2 + 0] as i16) - 0x80;
	247	let delta1 = (table[idx * 2 + 1] as i16) - 0x80;
	248	let mut pix0 = framebuf[base + x + 0 - stride] as i16;
	249	let mut pix1 = framebuf[base + x + 1 - stride] as i16;
	250	pix0 += delta0;
	251	pix1 += delta1;
	252	if pix0 < 0 { pix0 = 0; }
	253	if pix1 < 0 { pix1 = 0; }
	254	if pix0 > 255 { pix0 = 255; }
	255	if pix1 > 255 { pix1 = 255; }
	256	framebuf[base + x + 0] = pix0 as u8;
	257	framebuf[base + x + 1] = pix1 as u8;
	258	x += 2;
	259	}
	260	}
	261	base += stride;
	262	}
	263	Ok(())
	264	}
	265
	266	fn decode_plane_inter(&self, br: &mut BitReader,
22cb00db	267	buf: &mut NAVideoBuffer<u8>, planeno: usize,
77d06de2	268	tableno: usize) -> DecoderResult<()> {
22cb00db KS	269	let offs = buf.get_offset(planeno);
	270	let (w, h) = buf.get_dimensions(planeno);
	271	let stride = buf.get_stride(planeno);
77d06de2 KS	272	let cb = &self.cb;
77d06de2 KS	273
22cb00db	274	let mut data = buf.get_data_mut();
9037cf6b	275	let framebuf: &mut [u8] = data.as_mut_slice();
77d06de2 KS	276
	277	let table = &INDEO2_DELTA_TABLE[tableno];
	278
	279	let mut base = offs;
	280	for _ in 0..h {
	281	let mut x: usize = 0;
	282	while x < w {
	283	let idx = br.read_cb(cb)? as usize;
	284	if idx >= 0x80 {
	285	let run = (idx - 0x80) * 2;
	286	if x + run > w { return Err(DecoderError::InvalidData); }
	287	x += run;
	288	} else {
	289	let delta0 = (table[idx * 2 + 0] as i16) - 0x80;
	290	let delta1 = (table[idx * 2 + 1] as i16) - 0x80;
	291	let mut pix0 = framebuf[base + x + 0] as i16;
	292	let mut pix1 = framebuf[base + x + 1] as i16;
	293	pix0 += delta0 * 3 >> 2;
	294	pix1 += delta1 * 3 >> 2;
	295	if pix0 < 0 { pix0 = 0; }
	296	if pix1 < 0 { pix1 = 0; }
	297	if pix0 > 255 { pix0 = 255; }
	298	if pix1 > 255 { pix1 = 255; }
	299	framebuf[base + x + 0] = pix0 as u8;
	300	framebuf[base + x + 1] = pix1 as u8;
	301	x += 2;
	302	}
	303	}
	304	base += stride;
	305	}
	306	Ok(())
	307	}
	308	}
	309
	310	const IR2_START: usize = 48;
	311
	312	impl NADecoder for Indeo2Decoder {
77d06de2 KS	313	fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
	314	if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
	315	let w = vinfo.get_width();
	316	let h = vinfo.get_height();
	317	let f = vinfo.is_flipped();
	318	let fmt = formats::YUV410_FORMAT;
	319	let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, f, fmt));
	320	self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
88c03b61	321	self.frmmgr.clear();
77d06de2 KS	322	Ok(())
	323	} else {
	324	Err(DecoderError::InvalidData)
	325	}
	326	}
88c03b61	327	fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
77d06de2 KS	328	let src = pkt.get_buffer();
	329	if src.len() <= IR2_START { return Err(DecoderError::ShortData); }
	330	let interframe = src[18];
	331	let tabs = src[34];
	332	let mut br = BitReader::new(&src[IR2_START..], src.len() - IR2_START, BitReaderMode::LE);
	333	let luma_tab = tabs & 3;
	334	let chroma_tab = (tabs >> 2) & 3;
	335	if interframe != 0 {
22cb00db KS	336	let vinfo = self.info.get_properties().get_video_info().unwrap();
	337	let bufret = alloc_video_buffer(vinfo, 2);
	338	if let Err(_) = bufret { return Err(DecoderError::InvalidData); }
	339	let mut bufinfo = bufret.unwrap();
	340	let mut buf = bufinfo.get_vbuf().unwrap();
77d06de2 KS	341	for plane in 0..3 {
77d06de2 KS	342	let tabidx = (if plane == 0 { luma_tab } else { chroma_tab }) as usize;
22cb00db	343	self.decode_plane_intra(&mut br, &mut buf, plane, tabidx)?;
77d06de2	344	}
22cb00db KS	345	self.frmmgr.add_frame(buf);
	346	let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
	347	frm.set_keyframe(true);
	348	frm.set_frame_type(FrameType::I);
	349	Ok(Rc::new(RefCell::new(frm)))
77d06de2	350	} else {
22cb00db KS	351	let bufret = self.frmmgr.clone_ref();
	352	if let None = bufret { return Err(DecoderError::MissingReference); }
	353	let mut buf = bufret.unwrap();
	354
77d06de2 KS	355	for plane in 0..3 {
77d06de2 KS	356	let tabidx = (if plane == 0 { luma_tab } else { chroma_tab }) as usize;
22cb00db	357	self.decode_plane_inter(&mut br, &mut buf, plane, tabidx)?;
77d06de2	358	}
22cb00db KS	359	let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::Video(buf));
	360	frm.set_keyframe(false);
	361	frm.set_frame_type(FrameType::P);
	362	Ok(Rc::new(RefCell::new(frm)))
77d06de2 KS	363	}
	364	}
	365	}
	366
70259941 KS	367	pub fn get_decoder() -> Box<NADecoder> {
	368	Box::new(Indeo2Decoder::new())
	369	}
	370
77d06de2 KS	371	#[cfg(test)]
77d06de2 KS	372	mod test {
3167c45c KS	373	use nihav_core::codecs::RegisteredDecoders;
	374	use nihav_core::demuxers::RegisteredDemuxers;
	375	use nihav_core::test::dec_video::*;
	376	use crate::codecs::indeo_register_all_codecs;
	377	use nihav_commonfmt::demuxers::generic_register_all_demuxers;
77d06de2 KS	378	#[test]
77d06de2 KS	379	fn test_indeo2() {
3167c45c KS	380	let mut dmx_reg = RegisteredDemuxers::new();
	381	generic_register_all_demuxers(&mut dmx_reg);
	382	let mut dec_reg = RegisteredDecoders::new();
	383	indeo_register_all_codecs(&mut dec_reg);
	384
	385	test_file_decoding("avi", "assets/laser05.avi", Some(10), true, false, None, &dmx_reg, &dec_reg);
77d06de2	386	}
77d06de2	387	}