midi: improve dump example

midi/dump.cpp

@@ -1,8 +1,7 @@
-#include <iostream>
+#include <cstdio>
-#include <fstream>
-#include <tuple>
 #include <cassert>
-#include <tuple>
+#include <cstring>
+#include <cerrno>
 
 #include "parse.hpp"
 #include "strings.hpp"
@@ -38,14 +37,14 @@ dump_midi(midi::midi_event_t& midi_event)
   switch (midi_event.type) {
   case midi::midi_event_t::type_t::note_on:
     {
-      std::cout << "      note_on " << (int)midi_event.data.note_on.note << '\n';
+      printf("      note_on %d\n", (int)midi_event.data.note_on.note);
       auto&& [oct, fns] = midi_note_to_oct_fns(midi_event.data.note_on.note);
-      std::cout << "      oct " << oct << " fns " << fns << '\n';
+      printf("      oct %d fns %d\n", oct, fns);
     }
     break;
   case midi::midi_event_t::type_t::note_off:
     {
-      std::cout << "      note_off " << (int)midi_event.data.note_on.note << '\n';
+      printf("      note_off %d\n", (int)midi_event.data.note_on.note);
     }
     break;
   default:
@@ -58,60 +57,61 @@ int parse(uint8_t const * start)
   uint8_t const * buf = &start[0];
   auto header_o = midi::parse::header(buf);
   if (!header_o) {
-    std::cerr << "invalid header\n";
+    printf("invalid header\n");
     return -1;
   }
   midi::header_t header;
   std::tie(buf, header) = *header_o;
 
-  std::cout << "header.format: " << midi::strings::header_format(header.format) << '\n';
+  printf("header.format: %s\n", midi::strings::header_format(header.format).c_str());
-  std::cout << "header.ntrks: " << header.ntrks << '\n';
+  printf("header.ntrks: %d\n", header.ntrks);
 
   for (int32_t i = 0; i < header.ntrks; i++) {
-    std::cout << "track[" << i << "]:\n";
+    printf("track[%d]:\n", i);
 
     auto track_o = midi::parse::track(buf);
     if (!track_o) {
-      std::cerr << "invalid track\n";
+      printf("invalid track\n");
       return -1;
     }
 
-    uint32_t track_length;
+    midi::track_t track;
-    std::tie(buf, track_length) = *track_o;
+    std::tie(buf, track) = *track_o;
 
-    std::cout << "  track_length: " << track_length << '\n';
+    printf("  track.length: %d\n", track.length);
 
     uint8_t const * track_start = buf;
-    while (buf - track_start < track_length) {
+    uint8_t running_status = 0;
-      std::cout << "  event:\n";
+    while (buf - track_start < track.length) {
-      auto mtrk_event_o = midi::parse::mtrk_event(buf);
+      printf("  event:\n");
+      auto mtrk_event_o = midi::parse::mtrk_event(buf, running_status);
       if (!mtrk_event_o) {
-	std::cout << "    invalid mtrk_event\n";
+	printf("    invalid mtrk_event\n");
-	std::cout << std::hex << buf[0] << ' ' << buf[1] << ' ' << buf[2] << ' ' << buf[3];
+	printf("%02x %02x %02x %02x\n", buf[0], buf[1], buf[2], buf[3]);
 	return -1;
       }
 
       midi::mtrk_event_t mtrk_event;
       std::tie(buf, mtrk_event) = *mtrk_event_o;
-      std::cout << "    delta_time: " << mtrk_event.delta_time << '\n';
+      printf("    delta_time: %d\n", mtrk_event.delta_time);
       switch (mtrk_event.event.type) {
       case midi::event_t::type_t::midi:
-	std::cout << "    midi: " << '\n';
+	printf("    midi:\n");
 	dump_midi(mtrk_event.event.event.midi);
 	break;
       case midi::event_t::type_t::sysex:
-	std::cout << "    sysex: " << '\n';
+	printf("    sysex:\n");
 	break;
       case midi::event_t::type_t::meta:
-	std::cout << "    meta: " << '\n';
+	printf("    meta: \n");
 	break;
       default:
 	assert(false);
       }
     }
 
-    assert(buf - track_start == track_length);
+    assert(buf - track_start == track.length);
-    std::cout << "trailing/unparsed data: " << track_length - (buf - track_start) << '\n';
+    printf("trailing/unparsed data: %ld\n", track.length - (buf - track_start));
   }
   return 0;
 }
@@ -119,27 +119,27 @@ int parse(uint8_t const * start)
 int main(int argc, char *argv[])
 {
   if (argc < 2) {
-    std::cerr << "argc < 2\n";
+    printf("argc < 2\n");
     return -1;
   }
 
-  std::cerr << argv[1] << '\n';
+  printf("%s\n", argv[1]);
 
-  std::ifstream ifs;
+  FILE * fp = fopen(argv[1], "rb");
-  ifs.open(argv[1], std::ios::in | std::ios::binary | std::ios::trunc);
+  if (fp == nullptr) {
-  if (!ifs.is_open()) {
+    printf("fopen: %s\n", strerror(errno));
-    std::cerr << "ifstream\n";
     return -1;
   }
+  int ret = fseek(fp, 0L, SEEK_END);
+  assert(ret >= 0);
+  int size = ftell(fp);
+  assert(size >= 0);
+  ret = fseek(fp, 0L, SEEK_SET);
+  assert(ret >= 0);
 
-  auto size = static_cast<int32_t>(ifs.tellg());
   uint8_t start[size];
-  ifs.seekg(0);
+  size_t read_length = fread(start, size, 1, fp);
-  if (!ifs.read(reinterpret_cast<char*>(&start[0]), size)) {
+  assert(read_length == 1);
-    std::cerr << "read\n";
-    return -1;
-  }
-  ifs.close();
 
   parse(start);