capi: Go back to lowercase enum type names.

Having cheddar prefix the type name before enum values as a
C-style namespace lets us use shorter value names on the
rust side, but creates a style issue. We want to keep descriptive,
lowercase typedef names in the output, but have capitalized
values.

We could extend cheddar to mangle the case in different ways,
but it really doesn't matter than much. Instead just go back
to lower-case enum names and live with the variable casing
of the values in the generated C header.

Also use the more meaninful `mp4parse_status` as the result
type, which generalizes over MP4PARSE_OK and MP4PARSE_ERROR_*.

Author: rillian

mp4parse_capi/examples/afl-capi.rs

@@ -26,27 +26,27 @@ fn doit() {
     unsafe {
         let context = mp4parse_new(&io);
         let rv = mp4parse_read(context);
-        if rv == MP4PARSE::OK {
+        if rv == mp4parse_status::OK {
             let count = {
                 let mut count = 0;
                 let rv = mp4parse_get_track_count(context, &mut count);
-                assert_eq!(rv, MP4PARSE::OK);
+                assert_eq!(rv, mp4parse_status::OK);
                 count
             };
             for track in 0..count {
                 let mut info = mp4parse_track_info {
-                    track_type: MP4PARSE_TRACK_TYPE::VIDEO,
-                    codec: MP4PARSE_CODEC::UNKNOWN,
+                    track_type: mp4parse_track_type::VIDEO,
+                    codec: mp4parse_codec::UNKNOWN,
                     track_id: 0,
                     duration: 0,
                     media_time: 0,
                 };
                 let rv = mp4parse_get_track_info(context, track, &mut info);
-                if rv == MP4PARSE::OK {
+                if rv == mp4parse_status::OK {
                     println!("track {}: id={} duration={} media_time={}",
                              track, info.track_id, info.duration, info.media_time);
                     match info.track_type {
-                        MP4PARSE_TRACK_TYPE::VIDEO => {
+                        mp4parse_track_type::VIDEO => {
                             let mut video = mp4parse_track_video_info {
                                 display_width: 0,
                                 display_height: 0,
@@ -57,16 +57,16 @@ fn doit() {
                                 protected_data: Default::default(),
                             };
                             let rv = mp4parse_get_track_video_info(context, track, &mut video);
-                            if rv == MP4PARSE::OK {
+                            if rv == mp4parse_status::OK {
                                 println!("  video: display={}x{} image={}x{}",
                                          video.display_width, video.display_height,
                                          video.image_width, video.image_height);
                             }
                         }
-                        MP4PARSE_TRACK_TYPE::AUDIO => {
+                        mp4parse_track_type::AUDIO => {
                             let mut audio = Default::default();
                             let rv = mp4parse_get_track_audio_info(context, track, &mut audio);
-                            if rv == MP4PARSE::OK {
+                            if rv == mp4parse_status::OK {
                                 println!("  audio: channels={} bit_depth={} sample_rate={}",
                                          audio.channels, audio.bit_depth, audio.sample_rate);
                             }

mp4parse_capi/examples/test.cc

@@ -67,19 +67,19 @@ void test_arg_validation()
   assert(parser == nullptr);
 
   int32_t rv = mp4parse_read(nullptr);
-  assert(rv == MP4PARSE_ERROR_BADARG);
+  assert(rv == mp4parse_status_BAD_ARG);
 
   mp4parse_track_info info;
   rv = mp4parse_get_track_info(nullptr, 0, &info);
-  assert(rv == MP4PARSE_ERROR_BADARG);
+  assert(rv == mp4parse_status_BAD_ARG);
 
   mp4parse_track_video_info video;
   rv = mp4parse_get_track_video_info(nullptr, 0, &video);
-  assert(rv == MP4PARSE_ERROR_BADARG);
+  assert(rv == mp4parse_status_BAD_ARG);
 
   mp4parse_track_audio_info audio;
   rv = mp4parse_get_track_audio_info(nullptr, 0, &audio);
-  assert(rv == MP4PARSE_ERROR_BADARG);
+  assert(rv == mp4parse_status_BAD_ARG);
 
   assert(dummy_value == 42);
 }
@@ -92,16 +92,16 @@ void test_arg_validation_with_parser()
   assert(parser != nullptr);
 
   int32_t rv = mp4parse_read(parser);
-  assert(rv == MP4PARSE_ERROR_IO);
+  assert(rv == mp4parse_status_IO);
 
   rv = mp4parse_get_track_info(parser, 0, nullptr);
-  assert(rv == MP4PARSE_ERROR_BADARG);
+  assert(rv == mp4parse_status_BAD_ARG);
 
   rv = mp4parse_get_track_video_info(parser, 0, nullptr);
-  assert(rv == MP4PARSE_ERROR_BADARG);
+  assert(rv == mp4parse_status_BAD_ARG);
 
   rv = mp4parse_get_track_audio_info(parser, 0, nullptr);
-  assert(rv == MP4PARSE_ERROR_BADARG);
+  assert(rv == mp4parse_status_BAD_ARG);
 
   mp4parse_free(parser);
   assert(dummy_value == 42);
@@ -115,75 +115,75 @@ void test_arg_validation_with_data(const std::string& filename)
   mp4parse_parser *parser = mp4parse_new(&io);
   assert(parser != nullptr);
 
-  MP4PARSE rv = mp4parse_read(parser);
-  assert(rv == MP4PARSE_OK);
+  mp4parse_status rv = mp4parse_read(parser);
+  assert(rv == mp4parse_status_OK);
 
   uint32_t tracks;
   rv = mp4parse_get_track_count(parser, &tracks);
-  assert(rv == MP4PARSE_OK);
+  assert(rv == mp4parse_status_OK);
   assert(tracks == 2);
 
   mp4parse_track_info info;
   rv = mp4parse_get_track_info(parser, 0, &info);
-  assert(rv == MP4PARSE_OK);
-  assert(info.track_type == MP4PARSE_TRACK_TYPE_VIDEO);
+  assert(rv == mp4parse_status_OK);
+  assert(info.track_type == mp4parse_track_type_VIDEO);
   assert(info.track_id == 1);
   assert(info.duration == 40000);
   assert(info.media_time == 0);
 
   rv = mp4parse_get_track_info(parser, 1, &info);
-  assert(rv == MP4PARSE_OK);
-  assert(info.track_type == MP4PARSE_TRACK_TYPE_AUDIO);
+  assert(rv == mp4parse_status_OK);
+  assert(info.track_type == mp4parse_track_type_AUDIO);
   assert(info.track_id == 2);
   assert(info.duration == 61333);
   assert(info.media_time == 21333);
 
   mp4parse_track_video_info video;
   rv = mp4parse_get_track_video_info(parser, 0, &video);
-  assert(rv == MP4PARSE_OK);
+  assert(rv == mp4parse_status_OK);
   assert(video.display_width == 320);
   assert(video.display_height == 240);
   assert(video.image_width == 320);
   assert(video.image_height == 240);
 
   mp4parse_track_audio_info audio;
   rv = mp4parse_get_track_audio_info(parser, 1, &audio);
-  assert(rv == MP4PARSE_OK);
+  assert(rv == mp4parse_status_OK);
   assert(audio.channels == 1);
   assert(audio.bit_depth == 16);
   assert(audio.sample_rate == 48000);
 
   // Test with an invalid track number.
 
   rv = mp4parse_get_track_info(parser, 3, &info);
-  assert(rv == MP4PARSE_ERROR_BADARG);
+  assert(rv == mp4parse_status_BAD_ARG);
   rv = mp4parse_get_track_video_info(parser, 3, &video);
-  assert(rv == MP4PARSE_ERROR_BADARG);
+  assert(rv == mp4parse_status_BAD_ARG);
   rv = mp4parse_get_track_audio_info(parser, 3, &audio);
-  assert(rv == MP4PARSE_ERROR_BADARG);
+  assert(rv == mp4parse_status_BAD_ARG);
 
   mp4parse_free(parser);
   fclose(f);
 }
 
-const char * tracktype2str(MP4PARSE_TRACK_TYPE type)
+const char * tracktype2str(mp4parse_track_type type)
 {
   switch (type) {
-    case MP4PARSE_TRACK_TYPE_VIDEO: return "video";
-    case MP4PARSE_TRACK_TYPE_AUDIO: return "audio";
+    case mp4parse_track_type_VIDEO: return "video";
+    case mp4parse_track_type_AUDIO: return "audio";
   }
   return "unknown";
 }
 
-const char * errorstring(MP4PARSE error)
+const char * errorstring(mp4parse_status error)
 {
   switch (error) {
-    case MP4PARSE_OK: return "Ok";
-    case MP4PARSE_ERROR_BADARG: return "Invalid argument";
-    case MP4PARSE_ERROR_INVALID: return "Invalid data";
-    case MP4PARSE_ERROR_UNSUPPORTED: return "Feature unsupported";
-    case MP4PARSE_ERROR_EOF: return "Unexpected end-of-file";
-    case MP4PARSE_ERROR_IO: return "I/O error";
+    case mp4parse_status_OK: return "Ok";
+    case mp4parse_status_BAD_ARG: return "Invalid argument";
+    case mp4parse_status_INVALID: return "Invalid data";
+    case mp4parse_status_UNSUPPORTED: return "Feature unsupported";
+    case mp4parse_status_EOF: return "Unexpected end-of-file";
+    case mp4parse_status_IO: return "I/O error";
   }
   return "Unknown error";
 }
@@ -198,30 +198,30 @@ int32_t read_file(const char* filename)
   assert(parser != nullptr);
 
   fprintf(stderr, "Parsing file '%s'.\n", filename);
-  MP4PARSE rv = mp4parse_read(parser);
-  if (rv != MP4PARSE_OK) {
+  mp4parse_status rv = mp4parse_read(parser);
+  if (rv != mp4parse_status_OK) {
     mp4parse_free(parser);
     fclose(f);
     fprintf(stderr, "Parsing failed: %s\n", errorstring(rv));
     return rv;
   }
   uint32_t tracks;
   rv = mp4parse_get_track_count(parser, &tracks);
-  assert(rv == MP4PARSE_OK);
+  assert(rv == mp4parse_status_OK);
   fprintf(stderr, "%u tracks returned to C code.\n", tracks);
 
   for (uint32_t i = 0; i < tracks; ++i) {
     mp4parse_track_info track_info;
     int32_t rv2 = mp4parse_get_track_info(parser, i, &track_info);
-    assert(rv2 == MP4PARSE_OK);
+    assert(rv2 == mp4parse_status_OK);
     fprintf(stderr, "Track %d: type=%s duration=%" PRId64 " media_time=%" PRId64 " track_id=%d\n",
             i, tracktype2str(track_info.track_type), track_info.duration, track_info.media_time, track_info.track_id);
   }
 
   mp4parse_free(parser);
   fclose(f);
 
-  return MP4PARSE_OK;
+  return mp4parse_status_OK;
 }
 
 int main(int argc, char* argv[])