nihav-indeo/src/codecs/indeo2.rs

   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::*;
   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
 189 struct Indeo2Decoder {
 190     info:    Rc<NACodecInfo>,
 191     cb:      Codebook<u8>,
 192     frmmgr:  HAMShuffler,
 193 }
 194
 195 impl Indeo2Decoder {
 196     fn new() -> Self {
 197         let dummy_info = Rc::new(DUMMY_CODEC_INFO);
 198         let mut coderead = IR2CodeReader{};
 199         let cb = Codebook::new(&mut coderead, CodebookMode::LSB).unwrap();
 200         Indeo2Decoder { info: dummy_info, cb: cb, frmmgr: HAMShuffler::new() }
 201     }
 202
 203     fn decode_plane_intra(&self, br: &mut BitReader,
 204                           buf: &mut NAVideoBuffer<u8>, planeno: usize,
 205                           tableno: usize) -> DecoderResult<()> {
 206         let offs = buf.get_offset(planeno);
 207         let (w, h) = buf.get_dimensions(planeno);
 208         let stride = buf.get_stride(planeno);
 209         let cb = &self.cb;
 210
 211         let mut data = buf.get_data_mut();
 212         let framebuf: &mut [u8] = data.as_mut_slice();
 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,
 267                           buf: &mut NAVideoBuffer<u8>, planeno: usize,
 268                           tableno: usize) -> DecoderResult<()> {
 269         let offs = buf.get_offset(planeno);
 270         let (w, h) = buf.get_dimensions(planeno);
 271         let stride = buf.get_stride(planeno);
 272         let cb = &self.cb;
 273
 274         let mut data = buf.get_data_mut();
 275         let framebuf: &mut [u8] = data.as_mut_slice();
 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 {
 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()));
 321             self.frmmgr.clear();
 322             Ok(())
 323         } else {
 324             Err(DecoderError::InvalidData)
 325         }
 326     }
 327     fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
 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 {
 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();
 341             for plane in 0..3 {
 342                 let tabidx = (if plane == 0 { luma_tab } else { chroma_tab }) as usize;
 343                 self.decode_plane_intra(&mut br, &mut buf, plane, tabidx)?;
 344             }
 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)))
 350         } else {
 351             let bufret = self.frmmgr.clone_ref();
 352             if let None = bufret { return Err(DecoderError::MissingReference); }
 353             let mut buf = bufret.unwrap();
 354
 355             for plane in 0..3 {
 356                 let tabidx = (if plane == 0 { luma_tab } else { chroma_tab }) as usize;
 357                 self.decode_plane_inter(&mut br, &mut buf, plane, tabidx)?;
 358             }
 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)))
 363         }
 364     }
 365 }
 366
 367 pub fn get_decoder() -> Box<NADecoder> {
 368     Box::new(Indeo2Decoder::new())
 369 }
 370
 371 #[cfg(test)]
 372 mod test {
 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;
 378     #[test]
 379     fn test_indeo2() {
 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);
 386     }
 387 }