mxf 0.1.2

Library to read/write following SMPTE 377M (MXF) standard.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88


use byteorder::{ByteOrder, BigEndian, WriteBytesExt};
use serializer::encoder::*;

use std::io::Read;

#[derive(Debug)]
pub struct Length {
  pub value: usize
}

impl Encoder for Length {
  fn serialise(&self) -> Vec<u8> {
    if self.value <= 0x7f {
      return vec![self.value as u8]
    }
    if self.value <= 0xff {
      let mut result = vec![0x81];
      result.write_u8(self.value as u8).unwrap();
      return result
    }
    if self.value <= 0xffff {
      let mut result = vec![0x82];
      result.write_u16::<BigEndian>(self.value as u16).unwrap();
      return result
    }
    if self.value <= 0xffffff {
      let mut result = vec![0x83];
      result.write_u32::<BigEndian>(self.value as u32).unwrap();
      result.remove(1);
      return result
    }
    if self.value <= 0xffffffff {
      let mut result = vec![0x84];
      result.write_u32::<BigEndian>(self.value as u32).unwrap();
      return result
    }
    panic!("wrong length !!!")
  }
}

pub fn parse<R: Read>(stream: &mut R) -> Result<Option<Length>, String> {
  let mut length = vec![0; 1];
  try!(stream.read_exact(&mut length).map_err(|e| e.to_string()));

  // println!("length {:x}", length[0]);

  if length[0] <= 0x7f {
    Ok(Some(Length{value: length[0] as usize}))
  } else {
    let size = length[0] - 0x80;
    let mut data = vec![0; size as usize];
    try!(stream.read_exact(&mut data).map_err(|e| e.to_string()));

    // println!("length size = {:?}", size);

    let long_length = 
      match size {
        1 => data[0] as usize,
        2 => BigEndian::read_u16(&data) as usize,
        3 => {
          data.insert(0, 0);
          BigEndian::read_u32(&data) as usize
        },
        4 => BigEndian::read_u32(&data) as usize,
        5 => {
          data.insert(0, 0);
          data.insert(0, 0);
          data.insert(0, 0);
          BigEndian::read_u64(&data) as usize
        },
        6 => {
          data.insert(0, 0);
          data.insert(0, 0);
          BigEndian::read_u64(&data) as usize
        },
        7 => {
          data.insert(0, 0);
          BigEndian::read_u64(&data) as usize
        },
        8 => BigEndian::read_u64(&data) as usize,
        _ => return Err("wrong length".to_string())
      };
    
    // println!("long_length {:?}", long_length);
    Ok(Some(Length{value: long_length as usize}))
  }
}