Merge pull request mozilla#200 from mozilla/read-in-new

Merge mp4parse[_avif]_read into mp4parse[_avif]_new

Author: baumanj

mp4parse/src/lib.rs

@@ -775,7 +775,7 @@ impl AvifContext {
 /// A Media Data Box
 /// See ISO 14496-12:2015 § 8.1.1
 struct MediaDataBox {
-    /// Offset of `data` from the beginning of the file. See ConstructionMethod::FileOffset
+    /// Offset of `data` from the beginning of the file. See ConstructionMethod::File
     offset: u64,
     data: Vec<u8>,
 }
@@ -900,19 +900,19 @@ impl TryFrom<u8> for IlocVersion {
 struct ItemLocationBoxItem {
     item_id: u32,
     construction_method: ConstructionMethod,
-    /// Unused for ConstructionMethod::IdatOffset
+    /// Unused for ConstructionMethod::Idat
     extents: Vec<ItemLocationBoxExtent>,
 }
 
 #[derive(Clone, Copy, Debug)]
 enum ConstructionMethod {
-    FileOffset,
-    IdatOffset,
+    File,
+    Idat,
     #[allow(dead_code)] // TODO: see https://github.com/mozilla/mp4parse-rust/issues/196
-    ItemOffset,
+    Item,
 }
 
-/// `extent_index` is omitted since it's only used for ConstructionMethod::ItemOffset which
+/// `extent_index` is omitted since it's only used for ConstructionMethod::Item which
 /// is currently not implemented.
 #[derive(Clone, Debug)]
 struct ItemLocationBoxExtent {
@@ -1247,7 +1247,7 @@ pub fn read_avif<T: Read>(f: &mut T, context: &mut AvifContext) -> Result<()> {
                 read_meta = true;
                 let primary_item_loc = read_avif_meta(&mut b)?;
                 match primary_item_loc.construction_method {
-                    ConstructionMethod::FileOffset => {
+                    ConstructionMethod::File => {
                         primary_item_extents = Some(primary_item_loc.extents);
                         primary_item_extents_data = primary_item_extents.iter().map(|_| vec![]).collect();
                     }
@@ -1477,12 +1477,12 @@ fn read_iloc<T: Read>(src: &mut BMFFBox<T>) -> Result<Vec<ItemLocationBoxItem>>
         //  version 1 with `construction_method==0`, or version 2 when possible."
         // We take this to imply version 0 can be interpreted as using file offsets.
         let construction_method = match version {
-            IlocVersion::Zero => ConstructionMethod::FileOffset,
+            IlocVersion::Zero => ConstructionMethod::File,
             IlocVersion::One | IlocVersion::Two => {
                 let _reserved = iloc.read_u16(12)?;
                 match iloc.read_u16(4)? {
-                    0 => ConstructionMethod::FileOffset,
-                    1 => ConstructionMethod::IdatOffset,
+                    0 => ConstructionMethod::File,
+                    1 => ConstructionMethod::Idat,
                     2 => return Err(Error::Unsupported("construction_method 'item_offset' is not supported")),
                     _ => return Err(Error::InvalidData("construction_method is taken from the set 0, 1 or 2 per ISO 14496-12:2015 § 8.11.3.3"))
                 }

mp4parse_capi/examples/dump.rs

@@ -28,9 +28,10 @@ fn dump_file(filename: &str) {
     };
 
     unsafe {
-        let parser = mp4parse_new(&io);
+        let mut rv = Mp4parseStatus::Invalid;
+        let parser = mp4parse_new(&io, &mut rv);
 
-        match mp4parse_read(parser) {
+        match rv {
             Mp4parseStatus::Ok => (),
             _ => {
                 println!("-- fail to parse, '-v' for more info");

mp4parse_capi/examples/test.cc

@@ -16,12 +16,6 @@
 
 #include "mp4parse.h"
 
-intptr_t abort_read(uint8_t *buffer, uintptr_t size, void *userdata)
-{
-  // This shouldn't be called when allocating a parser.
-  abort();
-}
-
 intptr_t error_read(uint8_t *buffer, uintptr_t size, void *userdata)
 {
   return -1;
@@ -39,36 +33,28 @@ intptr_t io_read(uint8_t *buffer, uintptr_t size, void *userdata)
   return r;
 }
 
-void test_new_parser()
-{
-  int dummy_value = 42;
-  Mp4parseIo io = { abort_read, &dummy_value };
-  Mp4parseParser *parser = mp4parse_new(&io);
-  assert(parser != nullptr);
-  mp4parse_free(parser);
-  assert(dummy_value == 42);
-}
-
 void test_arg_validation()
 {
-  Mp4parseParser *parser = mp4parse_new(nullptr);
+  Mp4parseParser *parser = mp4parse_new(nullptr, nullptr);
   assert(parser == nullptr);
 
-  Mp4parseIo io = { nullptr, nullptr };
-  parser = mp4parse_new(&io);
+  Mp4parseStatus rv = MP4PARSE_STATUS_INVALID;
+  parser = mp4parse_new(nullptr, &rv);
+  assert(rv == MP4PARSE_STATUS_BAD_ARG);
   assert(parser == nullptr);
 
-  io = { abort_read, nullptr };
-  parser = mp4parse_new(&io);
+  Mp4parseIo io = { nullptr, nullptr };
+  rv = MP4PARSE_STATUS_INVALID;
+  parser = mp4parse_new(&io, &rv);
+  assert(rv == MP4PARSE_STATUS_BAD_ARG);
   assert(parser == nullptr);
 
   int dummy_value = 42;
   io = { nullptr, &dummy_value };
-  parser = mp4parse_new(&io);
-  assert(parser == nullptr);
-
-  int32_t rv = mp4parse_read(nullptr);
+  rv = MP4PARSE_STATUS_INVALID;
+  parser = mp4parse_new(&io, &rv);
   assert(rv == MP4PARSE_STATUS_BAD_ARG);
+  assert(parser == nullptr);
 
   Mp4parseTrackInfo info;
   rv = mp4parse_get_track_info(nullptr, 0, &info);
@@ -89,11 +75,10 @@ void test_arg_validation_with_parser()
 {
   int dummy_value = 42;
   Mp4parseIo io = { error_read, &dummy_value };
-  Mp4parseParser *parser = mp4parse_new(&io);
-  assert(parser != nullptr);
-
-  int32_t rv = mp4parse_read(parser);
+  Mp4parseStatus rv = MP4PARSE_STATUS_INVALID;
+  Mp4parseParser *parser = mp4parse_new(&io, &rv);
   assert(rv == MP4PARSE_STATUS_IO);
+  assert(parser == nullptr);
 
   rv = mp4parse_get_track_info(parser, 0, nullptr);
   assert(rv == MP4PARSE_STATUS_BAD_ARG);
@@ -104,7 +89,6 @@ void test_arg_validation_with_parser()
   rv = mp4parse_get_track_audio_info(parser, 0, nullptr);
   assert(rv == MP4PARSE_STATUS_BAD_ARG);
 
-  mp4parse_free(parser);
   assert(dummy_value == 42);
 }
 
@@ -113,11 +97,10 @@ void test_arg_validation_with_data(const std::string& filename)
   FILE* f = fopen(filename.c_str(), "rb");
   assert(f != nullptr);
   Mp4parseIo io = { io_read, f };
-  Mp4parseParser *parser = mp4parse_new(&io);
-  assert(parser != nullptr);
-
-  Mp4parseStatus rv = mp4parse_read(parser);
+  Mp4parseStatus rv = MP4PARSE_STATUS_INVALID;
+  Mp4parseParser *parser = mp4parse_new(&io, &rv);
   assert(rv == MP4PARSE_STATUS_OK);
+  assert(parser != nullptr);
 
   uint32_t tracks;
   rv = mp4parse_get_track_count(parser, &tracks);
@@ -198,14 +181,13 @@ int32_t read_file(const char* filename)
   FILE* f = fopen(filename, "rb");
   assert(f != nullptr);
 
+  fprintf(stderr, "Parsing file '%s'.\n", filename);
   Mp4parseIo io = { io_read, f };
-  Mp4parseParser *parser = mp4parse_new(&io);
-  assert(parser != nullptr);
+  Mp4parseStatus rv = MP4PARSE_STATUS_INVALID;
+  Mp4parseParser *parser = mp4parse_new(&io, &rv);
 
-  fprintf(stderr, "Parsing file '%s'.\n", filename);
-  Mp4parseStatus rv = mp4parse_read(parser);
   if (rv != MP4PARSE_STATUS_OK) {
-    mp4parse_free(parser);
+    assert(parser == nullptr);
     fclose(f);
     fprintf(stderr, "Parsing failed: %s\n", errorstring(rv));
     return rv;
@@ -234,7 +216,6 @@ int main(int argc, char* argv[])
   // Parse command line options.
   std::vector<std::string> args(argv + 1, argv + argc);
 
-  test_new_parser();
   test_arg_validation();
   test_arg_validation_with_parser();