support matrix rotation

Author: alfredoyang

mp4parse/src/lib.rs

@@ -120,6 +120,19 @@ struct MovieHeaderBox {
     duration: u64,
 }
 
+#[derive(Debug, Clone, Copy)]
+pub struct Matrix {
+    pub a: i32, // 16.16 fix point
+    pub b: i32, // 16.16 fix point
+    pub u: i32, // 2.30 fix point
+    pub c: i32, // 16.16 fix point
+    pub d: i32, // 16.16 fix point
+    pub v: i32, // 2.30 fix point
+    pub x: i32, // 16.16 fix point
+    pub y: i32, // 16.16 fix point
+    pub w: i32, // 2.30 fix point
+}
+
 /// Track header box 'tkhd'
 #[derive(Debug, Clone)]
 pub struct TrackHeaderBox {
@@ -128,6 +141,7 @@ pub struct TrackHeaderBox {
     pub duration: u64,
     pub width: u32,
     pub height: u32,
+    pub matrix: Matrix,
 }
 
 /// Edit list box 'elst'
@@ -999,7 +1013,14 @@ fn read_tkhd<T: Read>(src: &mut BMFFBox<T>) -> Result<TrackHeaderBox> {
         _ => return Err(Error::InvalidData("unhandled tkhd version")),
     };
     // Skip uninteresting fields.
-    skip(src, 52)?;
+    skip(src, 16)?;
+
+    let matrix = Matrix{
+        a: be_i32(src)?, b: be_i32(src)?, u: be_i32(src)?,
+        c: be_i32(src)?, d: be_i32(src)?, v: be_i32(src)?,
+        x: be_i32(src)?, y: be_i32(src)?, w: be_i32(src)?,
+    };
+
     let width = be_u32(src)?;
     let height = be_u32(src)?;
     Ok(TrackHeaderBox {
@@ -1008,6 +1029,7 @@ fn read_tkhd<T: Read>(src: &mut BMFFBox<T>) -> Result<TrackHeaderBox> {
         duration: duration,
         width: width,
         height: height,
+        matrix: matrix,
     })
 }
 

mp4parse_capi/examples/afl-capi.rs

@@ -52,6 +52,7 @@ fn doit() {
                                 display_height: 0,
                                 image_width: 0,
                                 image_height: 0,
+                                rotation: 0,
                                 extra_data: mp4parse_byte_data::default(), 
                                 protected_data: Default::default(),
                             };

mp4parse_capi/src/lib.rs

@@ -196,6 +196,7 @@ pub struct mp4parse_track_video_info {
     pub display_height: u32,
     pub image_width: u16,
     pub image_height: u16,
+    pub rotation: u16,
     pub extra_data: mp4parse_byte_data,
     pub protected_data: mp4parse_sinf_info,
 }
@@ -633,6 +634,14 @@ pub unsafe extern fn mp4parse_get_track_video_info(parser: *mut mp4parse_parser,
     if let Some(ref tkhd) = track.tkhd {
         (*info).display_width = tkhd.width >> 16; // 16.16 fixed point
         (*info).display_height = tkhd.height >> 16; // 16.16 fixed point
+        let matrix = (tkhd.matrix.a >> 16, tkhd.matrix.b >> 16,
+                      tkhd.matrix.c >> 16, tkhd.matrix.d >> 16);
+        (*info).rotation = match matrix {
+            ( 0,  1, -1,  0) => 90, // rotate 90 degrees
+            (-1,  0,  0, -1) => 180, // rotate 180 degrees
+            ( 0, -1,  1,  0) => 270, // rotate 270 degrees
+            _ => 0,
+        };
     } else {
         return MP4PARSE_ERROR_INVALID;
     }
@@ -1221,6 +1230,7 @@ fn arg_validation() {
             display_height: 0,
             image_width: 0,
             image_height: 0,
+            rotation: 0,
             extra_data: mp4parse_byte_data::default(),
             protected_data: Default::default(),
         };
@@ -1267,6 +1277,7 @@ fn arg_validation_with_parser() {
             display_height: 0,
             image_width: 0,
             image_height: 0,
+            rotation: 0,
             extra_data: mp4parse_byte_data::default(),
             protected_data: Default::default(),
         };
@@ -1340,6 +1351,7 @@ fn arg_validation_with_data() {
             display_height: 0,
             image_width: 0,
             image_height: 0,
+            rotation: 0,
             extra_data: mp4parse_byte_data::default(),
             protected_data: Default::default(),
         };
@@ -1374,6 +1386,7 @@ fn arg_validation_with_data() {
                                                     display_height: 0,
                                                     image_width: 0,
                                                     image_height: 0,
+                                                    rotation: 0,
                                                     extra_data: mp4parse_byte_data::default(),
                                                     protected_data: Default::default(),
         };

mp4parse_capi/tests/test_rotation.rs

@@ -0,0 +1,49 @@
+extern crate mp4parse_capi;
+use std::io::Read;
+use mp4parse_capi::*;
+
+extern fn buf_read(buf: *mut u8, size: usize, userdata: *mut std::os::raw::c_void) -> isize {
+    let mut input: &mut std::fs::File = unsafe { &mut *(userdata as *mut _) };
+    let mut buf = unsafe { std::slice::from_raw_parts_mut(buf, size) };
+    match input.read(&mut buf) {
+        Ok(n) => n as isize,
+        Err(_) => -1,
+    }
+}
+
+#[test]
+fn parse_rotation() {
+    let mut file = std::fs::File::open("tests/video_rotation_90.mp4").expect("Unknown file");
+    let io = mp4parse_io {
+        read: buf_read,
+        userdata: &mut file as *mut _ as *mut std::os::raw::c_void
+    };
+
+    unsafe {
+        let parser = mp4parse_new(&io);
+
+        let mut rv = mp4parse_read(parser);
+        assert_eq!(rv, mp4parse_error::MP4PARSE_OK);
+
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, mp4parse_error::MP4PARSE_OK);
+        assert_eq!(counts, 1);
+
+        let mut video = mp4parse_track_video_info {
+            display_width: 0,
+            display_height: 0,
+            image_width: 0,
+            image_height: 0,
+            rotation: 0,
+            extra_data: mp4parse_byte_data::default(), 
+            protected_data: Default::default(),
+        };
+
+        let rv = mp4parse_get_track_video_info(parser, 0, &mut video);
+        assert_eq!(rv, mp4parse_error::MP4PARSE_OK);
+        assert_eq!(video.rotation, 90);
+
+        mp4parse_free(parser);
+    }
+}